1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 3.1 Module
3 * -------------------------------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Program interface utilities
22 *//*--------------------------------------------------------------------*/
23
24 #include "es31fProgramInterfaceDefinitionUtil.hpp"
25 #include "es31fProgramInterfaceDefinition.hpp"
26 #include "gluVarType.hpp"
27 #include "gluVarTypeUtil.hpp"
28 #include "gluShaderUtil.hpp"
29 #include "deString.h"
30 #include "deStringUtil.hpp"
31 #include "glwEnums.hpp"
32
33 #include <set>
34 #include <map>
35 #include <sstream>
36 #include <vector>
37 #include <algorithm>
38
39 namespace deqp
40 {
41 namespace gles31
42 {
43 namespace Functional
44 {
45 namespace ProgramInterfaceDefinition
46 {
47
VariableSearchFilter(void)48 VariableSearchFilter::VariableSearchFilter (void)
49 : m_shaderTypeBits (0xFFFFFFFFul)
50 , m_storageBits (0xFFFFFFFFul)
51 {
52 }
53
createShaderTypeFilter(glu::ShaderType type)54 VariableSearchFilter VariableSearchFilter::createShaderTypeFilter (glu::ShaderType type)
55 {
56 DE_ASSERT(type < glu::SHADERTYPE_LAST);
57
58 VariableSearchFilter filter;
59 filter.m_shaderTypeBits = (1u << type);
60 return filter;
61 }
62
createStorageFilter(glu::Storage storage)63 VariableSearchFilter VariableSearchFilter::createStorageFilter (glu::Storage storage)
64 {
65 DE_ASSERT(storage < glu::STORAGE_LAST);
66
67 VariableSearchFilter filter;
68 filter.m_storageBits = (1u << storage);
69 return filter;
70 }
71
createShaderTypeStorageFilter(glu::ShaderType type,glu::Storage storage)72 VariableSearchFilter VariableSearchFilter::createShaderTypeStorageFilter (glu::ShaderType type, glu::Storage storage)
73 {
74 return logicalAnd(createShaderTypeFilter(type), createStorageFilter(storage));
75 }
76
logicalOr(const VariableSearchFilter & a,const VariableSearchFilter & b)77 VariableSearchFilter VariableSearchFilter::logicalOr (const VariableSearchFilter& a, const VariableSearchFilter& b)
78 {
79 VariableSearchFilter filter;
80 filter.m_shaderTypeBits = a.m_shaderTypeBits | b.m_shaderTypeBits;
81 filter.m_storageBits = a.m_storageBits | b.m_storageBits;
82 return filter;
83 }
84
logicalAnd(const VariableSearchFilter & a,const VariableSearchFilter & b)85 VariableSearchFilter VariableSearchFilter::logicalAnd (const VariableSearchFilter& a, const VariableSearchFilter& b)
86 {
87 VariableSearchFilter filter;
88 filter.m_shaderTypeBits = a.m_shaderTypeBits & b.m_shaderTypeBits;
89 filter.m_storageBits = a.m_storageBits & b.m_storageBits;
90 return filter;
91 }
92
matchesFilter(const ProgramInterfaceDefinition::Shader * shader) const93 bool VariableSearchFilter::matchesFilter (const ProgramInterfaceDefinition::Shader* shader) const
94 {
95 DE_ASSERT(shader->getType() < glu::SHADERTYPE_LAST);
96 return (m_shaderTypeBits & (1u << shader->getType())) != 0;
97 }
98
matchesFilter(const glu::VariableDeclaration & variable) const99 bool VariableSearchFilter::matchesFilter (const glu::VariableDeclaration& variable) const
100 {
101 DE_ASSERT(variable.storage < glu::STORAGE_LAST);
102 return (m_storageBits & (1u << variable.storage)) != 0;
103 }
104
matchesFilter(const glu::InterfaceBlock & block) const105 bool VariableSearchFilter::matchesFilter (const glu::InterfaceBlock& block) const
106 {
107 DE_ASSERT(block.storage < glu::STORAGE_LAST);
108 return (m_storageBits & (1u << block.storage)) != 0;
109 }
110
111 } // ProgramInterfaceDefinition
112
incrementMultiDimensionIndex(std::vector<int> & index,const std::vector<int> & dimensions)113 static bool incrementMultiDimensionIndex (std::vector<int>& index, const std::vector<int>& dimensions)
114 {
115 int incrementDimensionNdx = (int)(index.size() - 1);
116
117 while (incrementDimensionNdx >= 0)
118 {
119 if (++index[incrementDimensionNdx] == dimensions[incrementDimensionNdx])
120 index[incrementDimensionNdx--] = 0;
121 else
122 break;
123 }
124
125 return (incrementDimensionNdx != -1);
126 }
127
programContainsIOBlocks(const ProgramInterfaceDefinition::Program * program)128 bool programContainsIOBlocks (const ProgramInterfaceDefinition::Program* program)
129 {
130 for (int shaderNdx = 0; shaderNdx < (int)program->getShaders().size(); ++shaderNdx)
131 {
132 if (shaderContainsIOBlocks(program->getShaders()[shaderNdx]))
133 return true;
134 }
135
136 return false;
137 }
138
shaderContainsIOBlocks(const ProgramInterfaceDefinition::Shader * shader)139 bool shaderContainsIOBlocks (const ProgramInterfaceDefinition::Shader* shader)
140 {
141 for (int ndx = 0; ndx < (int)shader->getDefaultBlock().interfaceBlocks.size(); ++ndx)
142 {
143 const glu::Storage storage = shader->getDefaultBlock().interfaceBlocks[ndx].storage;
144 if (storage == glu::STORAGE_IN ||
145 storage == glu::STORAGE_OUT ||
146 storage == glu::STORAGE_PATCH_IN ||
147 storage == glu::STORAGE_PATCH_OUT)
148 {
149 return true;
150 }
151 }
152 return false;
153 }
154
getProgramTransformFeedbackStage(const ProgramInterfaceDefinition::Program * program)155 glu::ShaderType getProgramTransformFeedbackStage (const ProgramInterfaceDefinition::Program* program)
156 {
157 if (program->hasStage(glu::SHADERTYPE_GEOMETRY))
158 return glu::SHADERTYPE_GEOMETRY;
159
160 if (program->hasStage(glu::SHADERTYPE_TESSELLATION_EVALUATION))
161 return glu::SHADERTYPE_TESSELLATION_EVALUATION;
162
163 if (program->hasStage(glu::SHADERTYPE_VERTEX))
164 return glu::SHADERTYPE_VERTEX;
165
166 DE_ASSERT(false);
167 return glu::SHADERTYPE_LAST;
168 }
169
generateVariableTypeResourceNames(std::vector<std::string> & resources,const std::string & name,const glu::VarType & type,deUint32 resourceNameGenerationFlags)170 void generateVariableTypeResourceNames (std::vector<std::string>& resources, const std::string& name, const glu::VarType& type, deUint32 resourceNameGenerationFlags)
171 {
172 DE_ASSERT((resourceNameGenerationFlags & (~RESOURCE_NAME_GENERATION_FLAG_MASK)) == 0);
173
174 // remove top-level flag from children
175 const deUint32 childFlags = resourceNameGenerationFlags & ~((deUint32)RESOURCE_NAME_GENERATION_FLAG_TOP_LEVEL_BUFFER_VARIABLE);
176
177 if (type.isBasicType())
178 resources.push_back(name);
179 else if (type.isStructType())
180 {
181 const glu::StructType* structType = type.getStructPtr();
182 for (int ndx = 0; ndx < structType->getNumMembers(); ++ndx)
183 generateVariableTypeResourceNames(resources, name + "." + structType->getMember(ndx).getName(), structType->getMember(ndx).getType(), childFlags);
184 }
185 else if (type.isArrayType())
186 {
187 // Bottom-level arrays of basic types of a transform feedback variable will produce only the first
188 // element but without the trailing "[0]"
189 if (type.getElementType().isBasicType() &&
190 (resourceNameGenerationFlags & RESOURCE_NAME_GENERATION_FLAG_TRANSFORM_FEEDBACK_VARIABLE) != 0)
191 {
192 resources.push_back(name);
193 }
194 // Bottom-level arrays of basic types and SSBO top-level arrays of any type procude only first element
195 else if (type.getElementType().isBasicType() ||
196 (resourceNameGenerationFlags & RESOURCE_NAME_GENERATION_FLAG_TOP_LEVEL_BUFFER_VARIABLE) != 0)
197 {
198 generateVariableTypeResourceNames(resources, name + "[0]", type.getElementType(), childFlags);
199 }
200 // Other arrays of aggregate types are expanded
201 else
202 {
203 for (int ndx = 0; ndx < type.getArraySize(); ++ndx)
204 generateVariableTypeResourceNames(resources, name + "[" + de::toString(ndx) + "]", type.getElementType(), childFlags);
205 }
206 }
207 else
208 DE_ASSERT(false);
209 }
210
211 // Program source generation
212
213 namespace
214 {
215
216 using ProgramInterfaceDefinition::VariablePathComponent;
217 using ProgramInterfaceDefinition::VariableSearchFilter;
218
getShaderExtensionDeclarations(const ProgramInterfaceDefinition::Shader * shader)219 static std::string getShaderExtensionDeclarations (const ProgramInterfaceDefinition::Shader* shader)
220 {
221 std::vector<std::string> extensions;
222 std::ostringstream buf;
223
224 if (shader->getType() == glu::SHADERTYPE_GEOMETRY)
225 {
226 extensions.push_back("GL_EXT_geometry_shader");
227 }
228 else if (shader->getType() == glu::SHADERTYPE_TESSELLATION_CONTROL ||
229 shader->getType() == glu::SHADERTYPE_TESSELLATION_EVALUATION)
230 {
231 extensions.push_back("GL_EXT_tessellation_shader");
232 }
233
234 if (shaderContainsIOBlocks(shader))
235 extensions.push_back("GL_EXT_shader_io_blocks");
236
237 for (int ndx = 0; ndx < (int)extensions.size(); ++ndx)
238 buf << "#extension " << extensions[ndx] << " : require\n";
239 return buf.str();
240 }
241
getShaderTypeDeclarations(const ProgramInterfaceDefinition::Program * program,glu::ShaderType type)242 static std::string getShaderTypeDeclarations (const ProgramInterfaceDefinition::Program* program, glu::ShaderType type)
243 {
244 switch (type)
245 {
246 case glu::SHADERTYPE_VERTEX:
247 return "";
248
249 case glu::SHADERTYPE_FRAGMENT:
250 return "";
251
252 case glu::SHADERTYPE_GEOMETRY:
253 {
254 std::ostringstream buf;
255 buf << "layout(points) in;\n"
256 "layout(points, max_vertices=" << program->getGeometryNumOutputVertices() << ") out;\n";
257 return buf.str();
258 }
259
260 case glu::SHADERTYPE_TESSELLATION_CONTROL:
261 {
262 std::ostringstream buf;
263 buf << "layout(vertices=" << program->getTessellationNumOutputPatchVertices() << ") out;\n";
264 return buf.str();
265 }
266
267 case glu::SHADERTYPE_TESSELLATION_EVALUATION:
268 return "layout(triangles, point_mode) in;\n";
269
270 case glu::SHADERTYPE_COMPUTE:
271 return "layout(local_size_x=1) in;\n";
272
273 default:
274 DE_ASSERT(false);
275 return "";
276 }
277 }
278
279 class StructNameEqualPredicate
280 {
281 public:
StructNameEqualPredicate(const char * name)282 StructNameEqualPredicate (const char* name) : m_name(name) { }
operator ()(const glu::StructType * type)283 bool operator() (const glu::StructType* type) { return type->hasTypeName() && (deStringEqual(m_name, type->getTypeName()) == DE_TRUE); }
284 private:
285 const char* m_name;
286 };
287
collectNamedStructureDefinitions(std::vector<const glu::StructType * > & dst,const glu::VarType & type)288 static void collectNamedStructureDefinitions (std::vector<const glu::StructType*>& dst, const glu::VarType& type)
289 {
290 if (type.isBasicType())
291 return;
292 else if (type.isArrayType())
293 return collectNamedStructureDefinitions(dst, type.getElementType());
294 else if (type.isStructType())
295 {
296 if (type.getStructPtr()->hasTypeName())
297 {
298 // must be unique (may share the the same struct)
299 std::vector<const glu::StructType*>::iterator where = std::find_if(dst.begin(), dst.end(), StructNameEqualPredicate(type.getStructPtr()->getTypeName()));
300 if (where != dst.end())
301 {
302 DE_ASSERT(**where == *type.getStructPtr());
303
304 // identical type has been added already, types of members must be added too
305 return;
306 }
307 }
308
309 // Add types of members first
310 for (int ndx = 0; ndx < type.getStructPtr()->getNumMembers(); ++ndx)
311 collectNamedStructureDefinitions(dst, type.getStructPtr()->getMember(ndx).getType());
312
313 dst.push_back(type.getStructPtr());
314 }
315 else
316 DE_ASSERT(false);
317 }
318
writeStructureDefinitions(std::ostringstream & buf,const ProgramInterfaceDefinition::DefaultBlock & defaultBlock)319 static void writeStructureDefinitions (std::ostringstream& buf, const ProgramInterfaceDefinition::DefaultBlock& defaultBlock)
320 {
321 std::vector<const glu::StructType*> namedStructs;
322
323 // Collect all structs in post order
324
325 for (int ndx = 0; ndx < (int)defaultBlock.variables.size(); ++ndx)
326 collectNamedStructureDefinitions(namedStructs, defaultBlock.variables[ndx].varType);
327
328 for (int blockNdx = 0; blockNdx < (int)defaultBlock.interfaceBlocks.size(); ++blockNdx)
329 for (int ndx = 0; ndx < (int)defaultBlock.interfaceBlocks[blockNdx].variables.size(); ++ndx)
330 collectNamedStructureDefinitions(namedStructs, defaultBlock.interfaceBlocks[blockNdx].variables[ndx].varType);
331
332 // Write
333
334 for (int structNdx = 0; structNdx < (int)namedStructs.size(); ++structNdx)
335 {
336 buf << "struct " << namedStructs[structNdx]->getTypeName() << "\n"
337 "{\n";
338
339 for (int memberNdx = 0; memberNdx < namedStructs[structNdx]->getNumMembers(); ++memberNdx)
340 buf << glu::indent(1) << glu::declare(namedStructs[structNdx]->getMember(memberNdx).getType(), namedStructs[structNdx]->getMember(memberNdx).getName(), 1) << ";\n";
341
342 buf << "};\n";
343 }
344
345 if (!namedStructs.empty())
346 buf << "\n";
347 }
348
writeInterfaceBlock(std::ostringstream & buf,const glu::InterfaceBlock & interfaceBlock)349 static void writeInterfaceBlock (std::ostringstream& buf, const glu::InterfaceBlock& interfaceBlock)
350 {
351 buf << interfaceBlock.layout;
352
353 if (interfaceBlock.layout != glu::Layout())
354 buf << " ";
355
356 buf << glu::getStorageName(interfaceBlock.storage) << " " << interfaceBlock.interfaceName << "\n"
357 << "{\n";
358
359 for (int ndx = 0; ndx < (int)interfaceBlock.variables.size(); ++ndx)
360 buf << glu::indent(1) << interfaceBlock.variables[ndx] << ";\n";
361
362 buf << "}";
363
364 if (!interfaceBlock.instanceName.empty())
365 buf << " " << interfaceBlock.instanceName;
366
367 for (int dimensionNdx = 0; dimensionNdx < (int)interfaceBlock.dimensions.size(); ++dimensionNdx)
368 buf << "[" << interfaceBlock.dimensions[dimensionNdx] << "]";
369
370 buf << ";\n\n";
371 }
372
isReadableInterface(const glu::InterfaceBlock & interface)373 static bool isReadableInterface (const glu::InterfaceBlock& interface)
374 {
375 return interface.storage == glu::STORAGE_UNIFORM ||
376 interface.storage == glu::STORAGE_IN ||
377 interface.storage == glu::STORAGE_PATCH_IN ||
378 (interface.storage == glu::STORAGE_BUFFER && (interface.memoryAccessQualifierFlags & glu::MEMORYACCESSQUALIFIER_WRITEONLY_BIT) == 0);
379 }
380
isWritableInterface(const glu::InterfaceBlock & interface)381 static bool isWritableInterface (const glu::InterfaceBlock& interface)
382 {
383 return interface.storage == glu::STORAGE_OUT ||
384 interface.storage == glu::STORAGE_PATCH_OUT ||
385 (interface.storage == glu::STORAGE_BUFFER && (interface.memoryAccessQualifierFlags & glu::MEMORYACCESSQUALIFIER_READONLY_BIT) == 0);
386 }
387
388
writeVariableReadAccumulateExpression(std::ostringstream & buf,const std::string & accumulatorName,const std::string & name,glu::ShaderType shaderType,glu::Storage storage,const ProgramInterfaceDefinition::Program * program,const glu::VarType & varType)389 static void writeVariableReadAccumulateExpression (std::ostringstream& buf,
390 const std::string& accumulatorName,
391 const std::string& name,
392 glu::ShaderType shaderType,
393 glu::Storage storage,
394 const ProgramInterfaceDefinition::Program* program,
395 const glu::VarType& varType)
396 {
397 if (varType.isBasicType())
398 {
399 buf << "\t" << accumulatorName << " += ";
400
401 if (glu::isDataTypeScalar(varType.getBasicType()))
402 buf << "vec4(float(" << name << "))";
403 else if (glu::isDataTypeVector(varType.getBasicType()))
404 buf << "vec4(" << name << ".xyxy)";
405 else if (glu::isDataTypeMatrix(varType.getBasicType()))
406 buf << "vec4(float(" << name << "[0][0]))";
407 else if (glu::isDataTypeSamplerMultisample(varType.getBasicType()))
408 buf << "vec4(float(textureSize(" << name << ").x))";
409 else if (glu::isDataTypeSampler(varType.getBasicType()))
410 buf << "vec4(float(textureSize(" << name << ", 0).x))";
411 else if (glu::isDataTypeImage(varType.getBasicType()))
412 buf << "vec4(float(imageSize(" << name << ").x))";
413 else if (varType.getBasicType() == glu::TYPE_UINT_ATOMIC_COUNTER)
414 buf << "vec4(float(atomicCounterIncrement(" << name << ")))";
415 else
416 DE_ASSERT(false);
417
418 buf << ";\n";
419 }
420 else if (varType.isStructType())
421 {
422 for (int ndx = 0; ndx < varType.getStructPtr()->getNumMembers(); ++ndx)
423 writeVariableReadAccumulateExpression(buf,
424 accumulatorName,
425 name + "." + varType.getStructPtr()->getMember(ndx).getName(),
426 shaderType,
427 storage,
428 program,
429 varType.getStructPtr()->getMember(ndx).getType());
430 }
431 else if (varType.isArrayType())
432 {
433 if (varType.getArraySize() != glu::VarType::UNSIZED_ARRAY)
434 {
435 for (int ndx = 0; ndx < varType.getArraySize(); ++ndx)
436 writeVariableReadAccumulateExpression(buf,
437 accumulatorName,
438 name + "[" + de::toString(ndx) + "]",
439 shaderType,
440 storage,
441 program,
442 varType.getElementType());
443 }
444 else if (storage == glu::STORAGE_BUFFER)
445 {
446 // run-time sized array, read arbitrary
447 writeVariableReadAccumulateExpression(buf,
448 accumulatorName,
449 name + "[8]",
450 shaderType,
451 storage,
452 program,
453 varType.getElementType());
454 }
455 else
456 {
457 DE_ASSERT(storage == glu::STORAGE_IN);
458
459 if (shaderType == glu::SHADERTYPE_GEOMETRY)
460 {
461 // implicit sized geometry input array, size = primitive size. Just reading first is enough
462 writeVariableReadAccumulateExpression(buf,
463 accumulatorName,
464 name + "[0]",
465 shaderType,
466 storage,
467 program,
468 varType.getElementType());
469 }
470 else if (shaderType == glu::SHADERTYPE_TESSELLATION_CONTROL)
471 {
472 // implicit sized tessellation input array, size = input patch max size. Just reading current is enough
473 writeVariableReadAccumulateExpression(buf,
474 accumulatorName,
475 name + "[gl_InvocationID]",
476 shaderType,
477 storage,
478 program,
479 varType.getElementType());
480 }
481 else if (shaderType == glu::SHADERTYPE_TESSELLATION_EVALUATION)
482 {
483 // implicit sized tessellation input array, size = output patch max size. Read all to prevent optimizations
484 DE_ASSERT(program->getTessellationNumOutputPatchVertices() > 0);
485 for (int ndx = 0; ndx < (int)program->getTessellationNumOutputPatchVertices(); ++ndx)
486 {
487 writeVariableReadAccumulateExpression(buf,
488 accumulatorName,
489 name + "[" + de::toString(ndx) + "]",
490 shaderType,
491 storage,
492 program,
493 varType.getElementType());
494 }
495 }
496 else
497 DE_ASSERT(false);
498 }
499 }
500 else
501 DE_ASSERT(false);
502 }
503
writeInterfaceReadAccumulateExpression(std::ostringstream & buf,const std::string & accumulatorName,const glu::InterfaceBlock & block,glu::ShaderType shaderType,const ProgramInterfaceDefinition::Program * program)504 static void writeInterfaceReadAccumulateExpression (std::ostringstream& buf,
505 const std::string& accumulatorName,
506 const glu::InterfaceBlock& block,
507 glu::ShaderType shaderType,
508 const ProgramInterfaceDefinition::Program* program)
509 {
510 if (block.dimensions.empty())
511 {
512 const std::string prefix = (block.instanceName.empty()) ? ("") : (block.instanceName + ".");
513
514 for (int ndx = 0; ndx < (int)block.variables.size(); ++ndx)
515 {
516 writeVariableReadAccumulateExpression(buf,
517 accumulatorName,
518 prefix + block.variables[ndx].name,
519 shaderType,
520 block.storage,
521 program,
522 block.variables[ndx].varType);
523 }
524 }
525 else
526 {
527 std::vector<int> index(block.dimensions.size(), 0);
528
529 for (;;)
530 {
531 // access element
532 {
533 std::ostringstream name;
534 name << block.instanceName;
535
536 for (int dimensionNdx = 0; dimensionNdx < (int)block.dimensions.size(); ++dimensionNdx)
537 name << "[" << index[dimensionNdx] << "]";
538
539 for (int ndx = 0; ndx < (int)block.variables.size(); ++ndx)
540 {
541 writeVariableReadAccumulateExpression(buf,
542 accumulatorName,
543 name.str() + "." + block.variables[ndx].name,
544 shaderType,
545 block.storage,
546 program,
547 block.variables[ndx].varType);
548 }
549 }
550
551 // increment index
552 if (!incrementMultiDimensionIndex(index, block.dimensions))
553 break;
554 }
555 }
556 }
557
writeVariableWriteExpression(std::ostringstream & buf,const std::string & sourceVec4Name,const std::string & name,glu::ShaderType shaderType,glu::Storage storage,const ProgramInterfaceDefinition::Program * program,const glu::VarType & varType)558 static void writeVariableWriteExpression (std::ostringstream& buf,
559 const std::string& sourceVec4Name,
560 const std::string& name,
561 glu::ShaderType shaderType,
562 glu::Storage storage,
563 const ProgramInterfaceDefinition::Program* program,
564 const glu::VarType& varType)
565 {
566 if (varType.isBasicType())
567 {
568 buf << "\t" << name << " = ";
569
570 if (glu::isDataTypeScalar(varType.getBasicType()))
571 buf << glu::getDataTypeName(varType.getBasicType()) << "(" << sourceVec4Name << ".y)";
572 else if (glu::isDataTypeVector(varType.getBasicType()) || glu::isDataTypeMatrix(varType.getBasicType()))
573 buf << glu::getDataTypeName(varType.getBasicType()) << "(" << glu::getDataTypeName(glu::getDataTypeScalarType(varType.getBasicType())) << "(" << sourceVec4Name << ".y))";
574 else
575 DE_ASSERT(false);
576
577 buf << ";\n";
578 }
579 else if (varType.isStructType())
580 {
581 for (int ndx = 0; ndx < varType.getStructPtr()->getNumMembers(); ++ndx)
582 writeVariableWriteExpression(buf,
583 sourceVec4Name,
584 name + "." + varType.getStructPtr()->getMember(ndx).getName(),
585 shaderType,
586 storage,
587 program,
588 varType.getStructPtr()->getMember(ndx).getType());
589 }
590 else if (varType.isArrayType())
591 {
592 if (varType.getArraySize() != glu::VarType::UNSIZED_ARRAY)
593 {
594 for (int ndx = 0; ndx < varType.getArraySize(); ++ndx)
595 writeVariableWriteExpression(buf,
596 sourceVec4Name,
597 name + "[" + de::toString(ndx) + "]",
598 shaderType,
599 storage,
600 program,
601 varType.getElementType());
602 }
603 else if (storage == glu::STORAGE_BUFFER)
604 {
605 // run-time sized array, write arbitrary
606 writeVariableWriteExpression(buf,
607 sourceVec4Name,
608 name + "[9]",
609 shaderType,
610 storage,
611 program,
612 varType.getElementType());
613 }
614 else
615 {
616 DE_ASSERT(storage == glu::STORAGE_OUT);
617
618 if (shaderType == glu::SHADERTYPE_TESSELLATION_CONTROL)
619 {
620 // implicit sized tessellation onput array, size = output patch max size. Can only write to gl_InvocationID
621 writeVariableWriteExpression(buf,
622 sourceVec4Name,
623 name + "[gl_InvocationID]",
624 shaderType,
625 storage,
626 program,
627 varType.getElementType());
628 }
629 else
630 DE_ASSERT(false);
631 }
632 }
633 else
634 DE_ASSERT(false);
635 }
636
writeInterfaceWriteExpression(std::ostringstream & buf,const std::string & sourceVec4Name,const glu::InterfaceBlock & block,glu::ShaderType shaderType,const ProgramInterfaceDefinition::Program * program)637 static void writeInterfaceWriteExpression (std::ostringstream& buf,
638 const std::string& sourceVec4Name,
639 const glu::InterfaceBlock& block,
640 glu::ShaderType shaderType,
641 const ProgramInterfaceDefinition::Program* program)
642 {
643 if (block.dimensions.empty())
644 {
645 const std::string prefix = (block.instanceName.empty()) ? ("") : (block.instanceName + ".");
646
647 for (int ndx = 0; ndx < (int)block.variables.size(); ++ndx)
648 {
649 writeVariableWriteExpression(buf,
650 sourceVec4Name,
651 prefix + block.variables[ndx].name,
652 shaderType,
653 block.storage,
654 program,
655 block.variables[ndx].varType);
656 }
657 }
658 else
659 {
660 std::vector<int> index(block.dimensions.size(), 0);
661
662 for (;;)
663 {
664 // access element
665 {
666 std::ostringstream name;
667 name << block.instanceName;
668
669 for (int dimensionNdx = 0; dimensionNdx < (int)block.dimensions.size(); ++dimensionNdx)
670 name << "[" << index[dimensionNdx] << "]";
671
672 for (int ndx = 0; ndx < (int)block.variables.size(); ++ndx)
673 {
674 writeVariableWriteExpression(buf,
675 sourceVec4Name,
676 name.str() + "." + block.variables[ndx].name,
677 shaderType,
678 block.storage,
679 program,
680 block.variables[ndx].varType);
681 }
682 }
683
684 // increment index
685 if (!incrementMultiDimensionIndex(index, block.dimensions))
686 break;
687 }
688 }
689 }
690
traverseVariablePath(std::vector<VariablePathComponent> & typePath,const char * subPath,const glu::VarType & type)691 static bool traverseVariablePath (std::vector<VariablePathComponent>& typePath, const char* subPath, const glu::VarType& type)
692 {
693 glu::VarTokenizer tokenizer(subPath);
694
695 typePath.push_back(VariablePathComponent(&type));
696
697 if (tokenizer.getToken() == glu::VarTokenizer::TOKEN_END)
698 return true;
699
700 if (type.isStructType() && tokenizer.getToken() == glu::VarTokenizer::TOKEN_PERIOD)
701 {
702 tokenizer.advance();
703
704 // malformed path
705 if (tokenizer.getToken() != glu::VarTokenizer::TOKEN_IDENTIFIER)
706 return false;
707
708 for (int memberNdx = 0; memberNdx < type.getStructPtr()->getNumMembers(); ++memberNdx)
709 if (type.getStructPtr()->getMember(memberNdx).getName() == tokenizer.getIdentifier())
710 return traverseVariablePath(typePath, subPath + tokenizer.getCurrentTokenEndLocation(), type.getStructPtr()->getMember(memberNdx).getType());
711
712 // malformed path, no such member
713 return false;
714 }
715 else if (type.isArrayType() && tokenizer.getToken() == glu::VarTokenizer::TOKEN_LEFT_BRACKET)
716 {
717 tokenizer.advance();
718
719 // malformed path
720 if (tokenizer.getToken() != glu::VarTokenizer::TOKEN_NUMBER)
721 return false;
722
723 tokenizer.advance();
724 if (tokenizer.getToken() != glu::VarTokenizer::TOKEN_RIGHT_BRACKET)
725 return false;
726
727 return traverseVariablePath(typePath, subPath + tokenizer.getCurrentTokenEndLocation(), type.getElementType());
728 }
729
730 return false;
731 }
732
traverseVariablePath(std::vector<VariablePathComponent> & typePath,const std::string & path,const glu::VariableDeclaration & var)733 static bool traverseVariablePath (std::vector<VariablePathComponent>& typePath, const std::string& path, const glu::VariableDeclaration& var)
734 {
735 if (glu::parseVariableName(path.c_str()) != var.name)
736 return false;
737
738 typePath.push_back(VariablePathComponent(&var));
739 return traverseVariablePath(typePath, path.c_str() + var.name.length(), var.varType);
740 }
741
traverseShaderVariablePath(std::vector<VariablePathComponent> & typePath,const ProgramInterfaceDefinition::Shader * shader,const std::string & path,const VariableSearchFilter & filter)742 static bool traverseShaderVariablePath (std::vector<VariablePathComponent>& typePath, const ProgramInterfaceDefinition::Shader* shader, const std::string& path, const VariableSearchFilter& filter)
743 {
744 // Default block variable?
745 for (int varNdx = 0; varNdx < (int)shader->getDefaultBlock().variables.size(); ++varNdx)
746 if (filter.matchesFilter(shader->getDefaultBlock().variables[varNdx]))
747 if (traverseVariablePath(typePath, path, shader->getDefaultBlock().variables[varNdx]))
748 return true;
749
750 // is variable an interface block variable?
751 {
752 const std::string blockName = glu::parseVariableName(path.c_str());
753
754 for (int interfaceNdx = 0; interfaceNdx < (int)shader->getDefaultBlock().interfaceBlocks.size(); ++interfaceNdx)
755 {
756 if (!filter.matchesFilter(shader->getDefaultBlock().interfaceBlocks[interfaceNdx]))
757 continue;
758
759 if (shader->getDefaultBlock().interfaceBlocks[interfaceNdx].interfaceName == blockName)
760 {
761 // resource is a member of a named interface block
762 // \note there is no array index specifier even if the interface is declared as an array of instances
763 const std::string blockMemberPath = path.substr(blockName.size() + 1);
764 const std::string blockMemeberName = glu::parseVariableName(blockMemberPath.c_str());
765
766 for (int varNdx = 0; varNdx < (int)shader->getDefaultBlock().interfaceBlocks[interfaceNdx].variables.size(); ++varNdx)
767 {
768 if (shader->getDefaultBlock().interfaceBlocks[interfaceNdx].variables[varNdx].name == blockMemeberName)
769 {
770 typePath.push_back(VariablePathComponent(&shader->getDefaultBlock().interfaceBlocks[interfaceNdx]));
771 return traverseVariablePath(typePath, blockMemberPath, shader->getDefaultBlock().interfaceBlocks[interfaceNdx].variables[varNdx]);
772 }
773 }
774
775 // terminate search
776 return false;
777 }
778 else if (shader->getDefaultBlock().interfaceBlocks[interfaceNdx].instanceName.empty())
779 {
780 const std::string blockMemeberName = glu::parseVariableName(path.c_str());
781
782 // unnamed block contains such variable?
783 for (int varNdx = 0; varNdx < (int)shader->getDefaultBlock().interfaceBlocks[interfaceNdx].variables.size(); ++varNdx)
784 {
785 if (shader->getDefaultBlock().interfaceBlocks[interfaceNdx].variables[varNdx].name == blockMemeberName)
786 {
787 typePath.push_back(VariablePathComponent(&shader->getDefaultBlock().interfaceBlocks[interfaceNdx]));
788 return traverseVariablePath(typePath, path, shader->getDefaultBlock().interfaceBlocks[interfaceNdx].variables[varNdx]);
789 }
790 }
791
792 // continue search
793 }
794 }
795 }
796
797 return false;
798 }
799
traverseProgramVariablePath(std::vector<VariablePathComponent> & typePath,const ProgramInterfaceDefinition::Program * program,const std::string & path,const VariableSearchFilter & filter)800 static bool traverseProgramVariablePath (std::vector<VariablePathComponent>& typePath, const ProgramInterfaceDefinition::Program* program, const std::string& path, const VariableSearchFilter& filter)
801 {
802 for (int shaderNdx = 0; shaderNdx < (int)program->getShaders().size(); ++shaderNdx)
803 {
804 const ProgramInterfaceDefinition::Shader* shader = program->getShaders()[shaderNdx];
805
806 if (filter.matchesFilter(shader))
807 {
808 // \note modifying output variable even when returning false
809 typePath.clear();
810 if (traverseShaderVariablePath(typePath, shader, path, filter))
811 return true;
812 }
813 }
814
815 return false;
816 }
817
containsSubType(const glu::VarType & complexType,glu::DataType basicType)818 static bool containsSubType (const glu::VarType& complexType, glu::DataType basicType)
819 {
820 if (complexType.isBasicType())
821 {
822 return complexType.getBasicType() == basicType;
823 }
824 else if (complexType.isArrayType())
825 {
826 return containsSubType(complexType.getElementType(), basicType);
827 }
828 else if (complexType.isStructType())
829 {
830 for (int ndx = 0; ndx < complexType.getStructPtr()->getNumMembers(); ++ndx)
831 if (containsSubType(complexType.getStructPtr()->getMember(ndx).getType(), basicType))
832 return true;
833 return false;
834 }
835 else
836 {
837 DE_ASSERT(false);
838 return false;
839 }
840 }
841
getNumShaderBlocks(const ProgramInterfaceDefinition::Shader * shader,glu::Storage storage)842 static int getNumShaderBlocks (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage)
843 {
844 int retVal = 0;
845
846 for (int ndx = 0; ndx < (int)shader->getDefaultBlock().interfaceBlocks.size(); ++ndx)
847 {
848 if (shader->getDefaultBlock().interfaceBlocks[ndx].storage == storage)
849 {
850 int numInstances = 1;
851
852 for (int dimensionNdx = 0; dimensionNdx < (int)shader->getDefaultBlock().interfaceBlocks[ndx].dimensions.size(); ++dimensionNdx)
853 numInstances *= shader->getDefaultBlock().interfaceBlocks[ndx].dimensions[dimensionNdx];
854
855 retVal += numInstances;
856 }
857 }
858
859 return retVal;
860 }
861
getNumAtomicCounterBuffers(const ProgramInterfaceDefinition::Shader * shader)862 static int getNumAtomicCounterBuffers (const ProgramInterfaceDefinition::Shader* shader)
863 {
864 std::set<int> buffers;
865
866 for (int ndx = 0; ndx < (int)shader->getDefaultBlock().variables.size(); ++ndx)
867 {
868 if (containsSubType(shader->getDefaultBlock().variables[ndx].varType, glu::TYPE_UINT_ATOMIC_COUNTER))
869 {
870 DE_ASSERT(shader->getDefaultBlock().variables[ndx].layout.binding != -1);
871 buffers.insert(shader->getDefaultBlock().variables[ndx].layout.binding);
872 }
873 }
874
875 return (int)buffers.size();
876 }
877
878 template <typename DataTypeMap>
accumulateComplexType(const glu::VarType & complexType,const DataTypeMap & dTypeMap)879 static int accumulateComplexType (const glu::VarType& complexType, const DataTypeMap& dTypeMap)
880 {
881 if (complexType.isBasicType())
882 return dTypeMap(complexType.getBasicType());
883 else if (complexType.isArrayType())
884 {
885 const int arraySize = (complexType.getArraySize() == glu::VarType::UNSIZED_ARRAY) ? (1) : (complexType.getArraySize());
886 return arraySize * accumulateComplexType(complexType.getElementType(), dTypeMap);
887 }
888 else if (complexType.isStructType())
889 {
890 int sum = 0;
891 for (int ndx = 0; ndx < complexType.getStructPtr()->getNumMembers(); ++ndx)
892 sum += accumulateComplexType(complexType.getStructPtr()->getMember(ndx).getType(), dTypeMap);
893 return sum;
894 }
895 else
896 {
897 DE_ASSERT(false);
898 return false;
899 }
900 }
901
902 template <typename InterfaceBlockFilter, typename VarDeclFilter, typename DataTypeMap>
accumulateShader(const ProgramInterfaceDefinition::Shader * shader,const InterfaceBlockFilter & ibFilter,const VarDeclFilter & vdFilter,const DataTypeMap & dMap)903 static int accumulateShader (const ProgramInterfaceDefinition::Shader* shader,
904 const InterfaceBlockFilter& ibFilter,
905 const VarDeclFilter& vdFilter,
906 const DataTypeMap& dMap)
907 {
908 int retVal = 0;
909
910 for (int ndx = 0; ndx < (int)shader->getDefaultBlock().interfaceBlocks.size(); ++ndx)
911 {
912 if (ibFilter(shader->getDefaultBlock().interfaceBlocks[ndx]))
913 {
914 int numInstances = 1;
915
916 for (int dimensionNdx = 0; dimensionNdx < (int)shader->getDefaultBlock().interfaceBlocks[ndx].dimensions.size(); ++dimensionNdx)
917 numInstances *= shader->getDefaultBlock().interfaceBlocks[ndx].dimensions[dimensionNdx];
918
919 for (int varNdx = 0; varNdx < (int)shader->getDefaultBlock().interfaceBlocks[ndx].variables.size(); ++varNdx)
920 retVal += numInstances * accumulateComplexType(shader->getDefaultBlock().interfaceBlocks[ndx].variables[varNdx].varType, dMap);
921 }
922 }
923
924 for (int varNdx = 0; varNdx < (int)shader->getDefaultBlock().variables.size(); ++varNdx)
925 if (vdFilter(shader->getDefaultBlock().variables[varNdx]))
926 retVal += accumulateComplexType(shader->getDefaultBlock().variables[varNdx].varType, dMap);
927
928 return retVal;
929 }
930
dummyTrueConstantTypeFilter(glu::DataType d)931 static bool dummyTrueConstantTypeFilter (glu::DataType d)
932 {
933 DE_UNREF(d);
934 return true;
935 }
936
937 class InstanceCounter
938 {
939 public:
InstanceCounter(bool (* predicate)(glu::DataType))940 InstanceCounter (bool (*predicate)(glu::DataType))
941 : m_predicate(predicate)
942 {
943 }
944
operator ()(glu::DataType t) const945 int operator() (glu::DataType t) const
946 {
947 return (m_predicate(t)) ? (1) : (0);
948 }
949
950 private:
951 bool (*const m_predicate)(glu::DataType);
952 };
953
954 class InterfaceBlockStorageFilter
955 {
956 public:
InterfaceBlockStorageFilter(glu::Storage storage)957 InterfaceBlockStorageFilter (glu::Storage storage)
958 : m_storage(storage)
959 {
960 }
961
operator ()(const glu::InterfaceBlock & b) const962 bool operator() (const glu::InterfaceBlock& b) const
963 {
964 return m_storage == b.storage;
965 }
966
967 private:
968 const glu::Storage m_storage;
969 };
970
971 class VariableDeclarationStorageFilter
972 {
973 public:
VariableDeclarationStorageFilter(glu::Storage storage)974 VariableDeclarationStorageFilter (glu::Storage storage)
975 : m_storage(storage)
976 {
977 }
978
operator ()(const glu::VariableDeclaration & d) const979 bool operator() (const glu::VariableDeclaration& d) const
980 {
981 return m_storage == d.storage;
982 }
983
984 private:
985 const glu::Storage m_storage;
986 };
987
getNumTypeInstances(const glu::VarType & complexType,bool (* predicate)(glu::DataType))988 static int getNumTypeInstances (const glu::VarType& complexType, bool (*predicate)(glu::DataType))
989 {
990 return accumulateComplexType(complexType, InstanceCounter(predicate));
991 }
992
getNumTypeInstances(const ProgramInterfaceDefinition::Shader * shader,glu::Storage storage,bool (* predicate)(glu::DataType))993 static int getNumTypeInstances (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage, bool (*predicate)(glu::DataType))
994 {
995 return accumulateShader(shader, InterfaceBlockStorageFilter(storage), VariableDeclarationStorageFilter(storage), InstanceCounter(predicate));
996 }
997
getNumTypeInstances(const ProgramInterfaceDefinition::Shader * shader,glu::Storage storage)998 static int getNumTypeInstances (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage)
999 {
1000 return getNumTypeInstances(shader, storage, dummyTrueConstantTypeFilter);
1001 }
1002
accumulateShaderStorage(const ProgramInterfaceDefinition::Shader * shader,glu::Storage storage,int (* typeMap)(glu::DataType))1003 static int accumulateShaderStorage (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage, int (*typeMap)(glu::DataType))
1004 {
1005 return accumulateShader(shader, InterfaceBlockStorageFilter(storage), VariableDeclarationStorageFilter(storage), typeMap);
1006 }
1007
getNumDataTypeComponents(glu::DataType type)1008 static int getNumDataTypeComponents (glu::DataType type)
1009 {
1010 if (glu::isDataTypeScalarOrVector(type) || glu::isDataTypeMatrix(type))
1011 return glu::getDataTypeScalarSize(type);
1012 else
1013 return 0;
1014 }
1015
getNumDataTypeVectors(glu::DataType type)1016 static int getNumDataTypeVectors (glu::DataType type)
1017 {
1018 if (glu::isDataTypeScalar(type))
1019 return 1;
1020 else if (glu::isDataTypeVector(type))
1021 return 1;
1022 else if (glu::isDataTypeMatrix(type))
1023 return glu::getDataTypeMatrixNumColumns(type);
1024 else
1025 return 0;
1026 }
1027
getNumComponents(const ProgramInterfaceDefinition::Shader * shader,glu::Storage storage)1028 static int getNumComponents (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage)
1029 {
1030 return accumulateShaderStorage(shader, storage, getNumDataTypeComponents);
1031 }
1032
getNumVectors(const ProgramInterfaceDefinition::Shader * shader,glu::Storage storage)1033 static int getNumVectors (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage)
1034 {
1035 return accumulateShaderStorage(shader, storage, getNumDataTypeVectors);
1036 }
1037
getNumDefaultBlockComponents(const ProgramInterfaceDefinition::Shader * shader,glu::Storage storage)1038 static int getNumDefaultBlockComponents (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage)
1039 {
1040 int retVal = 0;
1041
1042 for (int varNdx = 0; varNdx < (int)shader->getDefaultBlock().variables.size(); ++varNdx)
1043 if (shader->getDefaultBlock().variables[varNdx].storage == storage)
1044 retVal += accumulateComplexType(shader->getDefaultBlock().variables[varNdx].varType, getNumDataTypeComponents);
1045
1046 return retVal;
1047 }
1048
getMaxBufferBinding(const ProgramInterfaceDefinition::Shader * shader,glu::Storage storage)1049 static int getMaxBufferBinding (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage)
1050 {
1051 int maxBinding = -1;
1052
1053 for (int ndx = 0; ndx < (int)shader->getDefaultBlock().interfaceBlocks.size(); ++ndx)
1054 {
1055 if (shader->getDefaultBlock().interfaceBlocks[ndx].storage == storage)
1056 {
1057 const int binding = (shader->getDefaultBlock().interfaceBlocks[ndx].layout.binding == -1) ? (0) : (shader->getDefaultBlock().interfaceBlocks[ndx].layout.binding);
1058 int numInstances = 1;
1059
1060 for (int dimensionNdx = 0; dimensionNdx < (int)shader->getDefaultBlock().interfaceBlocks[ndx].dimensions.size(); ++dimensionNdx)
1061 numInstances *= shader->getDefaultBlock().interfaceBlocks[ndx].dimensions[dimensionNdx];
1062
1063 maxBinding = de::max(maxBinding, binding + numInstances - 1);
1064 }
1065 }
1066
1067 return (int)maxBinding;
1068 }
1069
getBufferTypeSize(glu::DataType type,glu::MatrixOrder order)1070 static int getBufferTypeSize (glu::DataType type, glu::MatrixOrder order)
1071 {
1072 // assume vec4 alignments, should produce values greater than or equal to the actual resource usage
1073 int numVectors = 0;
1074
1075 if (glu::isDataTypeScalarOrVector(type))
1076 numVectors = 1;
1077 else if (glu::isDataTypeMatrix(type) && order == glu::MATRIXORDER_ROW_MAJOR)
1078 numVectors = glu::getDataTypeMatrixNumRows(type);
1079 else if (glu::isDataTypeMatrix(type) && order != glu::MATRIXORDER_ROW_MAJOR)
1080 numVectors = glu::getDataTypeMatrixNumColumns(type);
1081 else
1082 DE_ASSERT(false);
1083
1084 return 4 * numVectors;
1085 }
1086
getBufferVariableSize(const glu::VarType & type,glu::MatrixOrder order)1087 static int getBufferVariableSize (const glu::VarType& type, glu::MatrixOrder order)
1088 {
1089 if (type.isBasicType())
1090 return getBufferTypeSize(type.getBasicType(), order);
1091 else if (type.isArrayType())
1092 {
1093 const int arraySize = (type.getArraySize() == glu::VarType::UNSIZED_ARRAY) ? (1) : (type.getArraySize());
1094 return arraySize * getBufferVariableSize(type.getElementType(), order);
1095 }
1096 else if (type.isStructType())
1097 {
1098 int sum = 0;
1099 for (int ndx = 0; ndx < type.getStructPtr()->getNumMembers(); ++ndx)
1100 sum += getBufferVariableSize(type.getStructPtr()->getMember(ndx).getType(), order);
1101 return sum;
1102 }
1103 else
1104 {
1105 DE_ASSERT(false);
1106 return false;
1107 }
1108 }
1109
getBufferSize(const glu::InterfaceBlock & block,glu::MatrixOrder blockOrder)1110 static int getBufferSize (const glu::InterfaceBlock& block, glu::MatrixOrder blockOrder)
1111 {
1112 int size = 0;
1113
1114 for (int ndx = 0; ndx < (int)block.variables.size(); ++ndx)
1115 size += getBufferVariableSize(block.variables[ndx].varType, (block.variables[ndx].layout.matrixOrder == glu::MATRIXORDER_LAST) ? (blockOrder) : (block.variables[ndx].layout.matrixOrder));
1116
1117 return size;
1118 }
1119
getBufferMaxSize(const ProgramInterfaceDefinition::Shader * shader,glu::Storage storage)1120 static int getBufferMaxSize (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage)
1121 {
1122 int maxSize = 0;
1123
1124 for (int ndx = 0; ndx < (int)shader->getDefaultBlock().interfaceBlocks.size(); ++ndx)
1125 if (shader->getDefaultBlock().interfaceBlocks[ndx].storage == storage)
1126 maxSize = de::max(maxSize, getBufferSize(shader->getDefaultBlock().interfaceBlocks[ndx], shader->getDefaultBlock().interfaceBlocks[ndx].layout.matrixOrder));
1127
1128 return (int)maxSize;
1129 }
1130
getAtomicCounterMaxBinding(const ProgramInterfaceDefinition::Shader * shader)1131 static int getAtomicCounterMaxBinding (const ProgramInterfaceDefinition::Shader* shader)
1132 {
1133 int maxBinding = -1;
1134
1135 for (int ndx = 0; ndx < (int)shader->getDefaultBlock().variables.size(); ++ndx)
1136 {
1137 if (containsSubType(shader->getDefaultBlock().variables[ndx].varType, glu::TYPE_UINT_ATOMIC_COUNTER))
1138 {
1139 DE_ASSERT(shader->getDefaultBlock().variables[ndx].layout.binding != -1);
1140 maxBinding = de::max(maxBinding, shader->getDefaultBlock().variables[ndx].layout.binding);
1141 }
1142 }
1143
1144 return (int)maxBinding;
1145 }
1146
getUniformMaxBinding(const ProgramInterfaceDefinition::Shader * shader,bool (* predicate)(glu::DataType))1147 static int getUniformMaxBinding (const ProgramInterfaceDefinition::Shader* shader, bool (*predicate)(glu::DataType))
1148 {
1149 int maxBinding = -1;
1150
1151 for (int ndx = 0; ndx < (int)shader->getDefaultBlock().variables.size(); ++ndx)
1152 {
1153 const int binding = (shader->getDefaultBlock().variables[ndx].layout.binding == -1) ? (0) : (shader->getDefaultBlock().variables[ndx].layout.binding);
1154 const int numInstances = getNumTypeInstances(shader->getDefaultBlock().variables[ndx].varType, predicate);
1155
1156 maxBinding = de::max(maxBinding, binding + numInstances - 1);
1157 }
1158
1159 return maxBinding;
1160 }
1161
getAtomicCounterMaxBufferSize(const ProgramInterfaceDefinition::Shader * shader)1162 static int getAtomicCounterMaxBufferSize (const ProgramInterfaceDefinition::Shader* shader)
1163 {
1164 std::map<int, int> bufferSizes;
1165 int maxSize = 0;
1166
1167 for (int ndx = 0; ndx < (int)shader->getDefaultBlock().variables.size(); ++ndx)
1168 {
1169 if (containsSubType(shader->getDefaultBlock().variables[ndx].varType, glu::TYPE_UINT_ATOMIC_COUNTER))
1170 {
1171 const int bufferBinding = shader->getDefaultBlock().variables[ndx].layout.binding;
1172 const int offset = (shader->getDefaultBlock().variables[ndx].layout.offset == -1) ? (0) : (shader->getDefaultBlock().variables[ndx].layout.offset);
1173 const int size = offset + 4 * getNumTypeInstances(shader->getDefaultBlock().variables[ndx].varType, glu::isDataTypeAtomicCounter);
1174
1175 DE_ASSERT(shader->getDefaultBlock().variables[ndx].layout.binding != -1);
1176
1177 if (bufferSizes.find(bufferBinding) == bufferSizes.end())
1178 bufferSizes[bufferBinding] = size;
1179 else
1180 bufferSizes[bufferBinding] = de::max<int>(bufferSizes[bufferBinding], size);
1181 }
1182 }
1183
1184 for (std::map<int, int>::iterator it = bufferSizes.begin(); it != bufferSizes.end(); ++it)
1185 maxSize = de::max<int>(maxSize, it->second);
1186
1187 return maxSize;
1188 }
1189
getNumFeedbackVaryingComponents(const ProgramInterfaceDefinition::Program * program,const std::string & name)1190 static int getNumFeedbackVaryingComponents (const ProgramInterfaceDefinition::Program* program, const std::string& name)
1191 {
1192 std::vector<VariablePathComponent> path;
1193
1194 if (name == "gl_Position")
1195 return 4;
1196
1197 DE_ASSERT(deStringBeginsWith(name.c_str(), "gl_") == DE_FALSE);
1198
1199 if (!traverseProgramVariablePath(path, program, name, VariableSearchFilter::createShaderTypeStorageFilter(getProgramTransformFeedbackStage(program), glu::STORAGE_OUT)))
1200 DE_ASSERT(false); // Program failed validate, invalid operation
1201
1202 return accumulateComplexType(*path.back().getVariableType(), getNumDataTypeComponents);
1203 }
1204
getNumXFBComponents(const ProgramInterfaceDefinition::Program * program)1205 static int getNumXFBComponents (const ProgramInterfaceDefinition::Program* program)
1206 {
1207 int numComponents = 0;
1208
1209 for (int ndx = 0; ndx < (int)program->getTransformFeedbackVaryings().size(); ++ndx)
1210 numComponents += getNumFeedbackVaryingComponents(program, program->getTransformFeedbackVaryings()[ndx]);
1211
1212 return numComponents;
1213 }
1214
getNumMaxXFBOutputComponents(const ProgramInterfaceDefinition::Program * program)1215 static int getNumMaxXFBOutputComponents (const ProgramInterfaceDefinition::Program* program)
1216 {
1217 int numComponents = 0;
1218
1219 for (int ndx = 0; ndx < (int)program->getTransformFeedbackVaryings().size(); ++ndx)
1220 numComponents = de::max(numComponents, getNumFeedbackVaryingComponents(program, program->getTransformFeedbackVaryings()[ndx]));
1221
1222 return numComponents;
1223 }
1224
getFragmentOutputMaxLocation(const ProgramInterfaceDefinition::Shader * shader)1225 static int getFragmentOutputMaxLocation (const ProgramInterfaceDefinition::Shader* shader)
1226 {
1227 DE_ASSERT(shader->getType() == glu::SHADERTYPE_FRAGMENT);
1228
1229 int maxOutputLocation = -1;
1230
1231 for (int ndx = 0; ndx < (int)shader->getDefaultBlock().variables.size(); ++ndx)
1232 {
1233 if (shader->getDefaultBlock().variables[ndx].storage == glu::STORAGE_OUT)
1234 {
1235 // missing location qualifier means location == 0
1236 const int outputLocation = (shader->getDefaultBlock().variables[ndx].layout.location == -1)
1237 ? (0)
1238 : (shader->getDefaultBlock().variables[ndx].layout.location);
1239
1240 // only basic types or arrays of basic types possible
1241 DE_ASSERT(!shader->getDefaultBlock().variables[ndx].varType.isStructType());
1242
1243 const int locationSlotsTaken = (shader->getDefaultBlock().variables[ndx].varType.isArrayType())
1244 ? (shader->getDefaultBlock().variables[ndx].varType.getArraySize())
1245 : (1);
1246
1247 maxOutputLocation = de::max(maxOutputLocation, outputLocation + locationSlotsTaken - 1);
1248 }
1249 }
1250
1251 return maxOutputLocation;
1252 }
1253
1254 } // anonymous
1255
getProgramInterfaceBlockMemberResourceList(const glu::InterfaceBlock & interfaceBlock)1256 std::vector<std::string> getProgramInterfaceBlockMemberResourceList (const glu::InterfaceBlock& interfaceBlock)
1257 {
1258 const std::string namePrefix = (!interfaceBlock.instanceName.empty()) ? (interfaceBlock.interfaceName + ".") : ("");
1259 const bool isTopLevelBufferVariable = (interfaceBlock.storage == glu::STORAGE_BUFFER);
1260 std::vector<std::string> resources;
1261
1262 // \note this is defined in the GLSL spec, not in the GL spec
1263 for (int variableNdx = 0; variableNdx < (int)interfaceBlock.variables.size(); ++variableNdx)
1264 generateVariableTypeResourceNames(resources,
1265 namePrefix + interfaceBlock.variables[variableNdx].name,
1266 interfaceBlock.variables[variableNdx].varType,
1267 (isTopLevelBufferVariable) ?
1268 (RESOURCE_NAME_GENERATION_FLAG_TOP_LEVEL_BUFFER_VARIABLE) :
1269 (RESOURCE_NAME_GENERATION_FLAG_DEFAULT));
1270
1271 return resources;
1272 }
1273
getProgramInterfaceResourceList(const ProgramInterfaceDefinition::Program * program,ProgramInterface interface)1274 std::vector<std::string> getProgramInterfaceResourceList (const ProgramInterfaceDefinition::Program* program, ProgramInterface interface)
1275 {
1276 // The same {uniform (block), buffer (variable)} can exist in multiple shaders, remove duplicates but keep order
1277 const bool removeDuplicated = (interface == PROGRAMINTERFACE_UNIFORM) ||
1278 (interface == PROGRAMINTERFACE_UNIFORM_BLOCK) ||
1279 (interface == PROGRAMINTERFACE_BUFFER_VARIABLE) ||
1280 (interface == PROGRAMINTERFACE_SHADER_STORAGE_BLOCK);
1281 std::vector<std::string> resources;
1282
1283 switch (interface)
1284 {
1285 case PROGRAMINTERFACE_UNIFORM:
1286 case PROGRAMINTERFACE_BUFFER_VARIABLE:
1287 {
1288 const glu::Storage storage = (interface == PROGRAMINTERFACE_UNIFORM) ? (glu::STORAGE_UNIFORM) : (glu::STORAGE_BUFFER);
1289
1290 for (int shaderNdx = 0; shaderNdx < (int)program->getShaders().size(); ++shaderNdx)
1291 {
1292 const ProgramInterfaceDefinition::Shader* shader = program->getShaders()[shaderNdx];
1293
1294 for (int variableNdx = 0; variableNdx < (int)shader->getDefaultBlock().variables.size(); ++variableNdx)
1295 if (shader->getDefaultBlock().variables[variableNdx].storage == storage)
1296 generateVariableTypeResourceNames(resources,
1297 shader->getDefaultBlock().variables[variableNdx].name,
1298 shader->getDefaultBlock().variables[variableNdx].varType,
1299 RESOURCE_NAME_GENERATION_FLAG_DEFAULT);
1300
1301 for (int interfaceNdx = 0; interfaceNdx < (int)shader->getDefaultBlock().interfaceBlocks.size(); ++interfaceNdx)
1302 {
1303 const glu::InterfaceBlock& interfaceBlock = shader->getDefaultBlock().interfaceBlocks[interfaceNdx];
1304 if (interfaceBlock.storage == storage)
1305 {
1306 const std::vector<std::string> blockResources = getProgramInterfaceBlockMemberResourceList(interfaceBlock);
1307 resources.insert(resources.end(), blockResources.begin(), blockResources.end());
1308 }
1309 }
1310 }
1311 break;
1312 }
1313
1314 case PROGRAMINTERFACE_UNIFORM_BLOCK:
1315 case PROGRAMINTERFACE_SHADER_STORAGE_BLOCK:
1316 {
1317 const glu::Storage storage = (interface == PROGRAMINTERFACE_UNIFORM_BLOCK) ? (glu::STORAGE_UNIFORM) : (glu::STORAGE_BUFFER);
1318
1319 for (int shaderNdx = 0; shaderNdx < (int)program->getShaders().size(); ++shaderNdx)
1320 {
1321 const ProgramInterfaceDefinition::Shader* shader = program->getShaders()[shaderNdx];
1322 for (int interfaceNdx = 0; interfaceNdx < (int)shader->getDefaultBlock().interfaceBlocks.size(); ++interfaceNdx)
1323 {
1324 const glu::InterfaceBlock& interfaceBlock = shader->getDefaultBlock().interfaceBlocks[interfaceNdx];
1325 if (interfaceBlock.storage == storage)
1326 {
1327 std::vector<int> index(interfaceBlock.dimensions.size(), 0);
1328
1329 for (;;)
1330 {
1331 // add resource string for each element
1332 {
1333 std::ostringstream name;
1334 name << interfaceBlock.interfaceName;
1335
1336 for (int dimensionNdx = 0; dimensionNdx < (int)interfaceBlock.dimensions.size(); ++dimensionNdx)
1337 name << "[" << index[dimensionNdx] << "]";
1338
1339 resources.push_back(name.str());
1340 }
1341
1342 // increment index
1343 if (!incrementMultiDimensionIndex(index, interfaceBlock.dimensions))
1344 break;
1345 }
1346 }
1347 }
1348 }
1349 break;
1350 }
1351
1352 case PROGRAMINTERFACE_PROGRAM_INPUT:
1353 case PROGRAMINTERFACE_PROGRAM_OUTPUT:
1354 {
1355 const glu::Storage queryStorage = (interface == PROGRAMINTERFACE_PROGRAM_INPUT) ? (glu::STORAGE_IN) : (glu::STORAGE_OUT);
1356 const glu::Storage queryPatchStorage = (interface == PROGRAMINTERFACE_PROGRAM_INPUT) ? (glu::STORAGE_PATCH_IN) : (glu::STORAGE_PATCH_OUT);
1357 const glu::ShaderType shaderType = (interface == PROGRAMINTERFACE_PROGRAM_INPUT) ? (program->getFirstStage()) : (program->getLastStage());
1358
1359 for (int shaderNdx = 0; shaderNdx < (int)program->getShaders().size(); ++shaderNdx)
1360 {
1361 const ProgramInterfaceDefinition::Shader* shader = program->getShaders()[shaderNdx];
1362
1363 if (shader->getType() != shaderType)
1364 continue;
1365
1366 for (int variableNdx = 0; variableNdx < (int)shader->getDefaultBlock().variables.size(); ++variableNdx)
1367 {
1368 const glu::Storage variableStorage = shader->getDefaultBlock().variables[variableNdx].storage;
1369 if (variableStorage == queryStorage || variableStorage == queryPatchStorage)
1370 generateVariableTypeResourceNames(resources,
1371 shader->getDefaultBlock().variables[variableNdx].name,
1372 shader->getDefaultBlock().variables[variableNdx].varType,
1373 RESOURCE_NAME_GENERATION_FLAG_DEFAULT);
1374 }
1375
1376 for (int interfaceNdx = 0; interfaceNdx < (int)shader->getDefaultBlock().interfaceBlocks.size(); ++interfaceNdx)
1377 {
1378 const glu::InterfaceBlock& interfaceBlock = shader->getDefaultBlock().interfaceBlocks[interfaceNdx];
1379 if (interfaceBlock.storage == queryStorage || interfaceBlock.storage == queryPatchStorage)
1380 {
1381 const std::vector<std::string> blockResources = getProgramInterfaceBlockMemberResourceList(interfaceBlock);
1382 resources.insert(resources.end(), blockResources.begin(), blockResources.end());
1383 }
1384 }
1385 }
1386
1387 // built-ins
1388 if (interface == PROGRAMINTERFACE_PROGRAM_INPUT)
1389 {
1390 if (shaderType == glu::SHADERTYPE_VERTEX && resources.empty())
1391 resources.push_back("gl_VertexID"); // only read from when there are no other inputs
1392 else if (shaderType == glu::SHADERTYPE_FRAGMENT && resources.empty())
1393 resources.push_back("gl_FragCoord"); // only read from when there are no other inputs
1394 else if (shaderType == glu::SHADERTYPE_GEOMETRY)
1395 resources.push_back("gl_PerVertex.gl_Position");
1396 else if (shaderType == glu::SHADERTYPE_TESSELLATION_CONTROL)
1397 {
1398 resources.push_back("gl_InvocationID");
1399 resources.push_back("gl_PerVertex.gl_Position");
1400 }
1401 else if (shaderType == glu::SHADERTYPE_TESSELLATION_EVALUATION)
1402 resources.push_back("gl_PerVertex.gl_Position");
1403 else if (shaderType == glu::SHADERTYPE_COMPUTE && resources.empty())
1404 resources.push_back("gl_NumWorkGroups"); // only read from when there are no other inputs
1405 }
1406 else if (interface == PROGRAMINTERFACE_PROGRAM_OUTPUT)
1407 {
1408 if (shaderType == glu::SHADERTYPE_VERTEX)
1409 resources.push_back("gl_Position");
1410 else if (shaderType == glu::SHADERTYPE_FRAGMENT && resources.empty())
1411 resources.push_back("gl_FragDepth"); // only written to when there are no other outputs
1412 else if (shaderType == glu::SHADERTYPE_GEOMETRY)
1413 resources.push_back("gl_Position");
1414 else if (shaderType == glu::SHADERTYPE_TESSELLATION_CONTROL)
1415 {
1416 resources.push_back("gl_PerVertex.gl_Position");
1417 resources.push_back("gl_TessLevelOuter[0]");
1418 resources.push_back("gl_TessLevelInner[0]");
1419 }
1420 else if (shaderType == glu::SHADERTYPE_TESSELLATION_EVALUATION)
1421 resources.push_back("gl_Position");
1422 }
1423
1424 break;
1425 }
1426
1427 case PROGRAMINTERFACE_TRANSFORM_FEEDBACK_VARYING:
1428 {
1429 const glu::ShaderType xfbStage = getProgramTransformFeedbackStage(program);
1430
1431 for (int varyingNdx = 0; varyingNdx < (int)program->getTransformFeedbackVaryings().size(); ++varyingNdx)
1432 {
1433 const std::string& varyingName = program->getTransformFeedbackVaryings()[varyingNdx];
1434
1435 if (deStringBeginsWith(varyingName.c_str(), "gl_"))
1436 resources.push_back(varyingName); // builtin
1437 else
1438 {
1439 std::vector<VariablePathComponent> path;
1440
1441 if (!traverseProgramVariablePath(path, program, varyingName, VariableSearchFilter::createShaderTypeStorageFilter(xfbStage, glu::STORAGE_OUT)))
1442 DE_ASSERT(false); // Program failed validate, invalid operation
1443
1444 generateVariableTypeResourceNames(resources,
1445 varyingName,
1446 *path.back().getVariableType(),
1447 RESOURCE_NAME_GENERATION_FLAG_TRANSFORM_FEEDBACK_VARIABLE);
1448 }
1449 }
1450
1451 break;
1452 }
1453
1454 default:
1455 DE_ASSERT(false);
1456 }
1457
1458 if (removeDuplicated)
1459 {
1460 std::set<std::string> addedVariables;
1461 std::vector<std::string> uniqueResouces;
1462
1463 for (int ndx = 0; ndx < (int)resources.size(); ++ndx)
1464 {
1465 if (addedVariables.find(resources[ndx]) == addedVariables.end())
1466 {
1467 addedVariables.insert(resources[ndx]);
1468 uniqueResouces.push_back(resources[ndx]);
1469 }
1470 }
1471
1472 uniqueResouces.swap(resources);
1473 }
1474
1475 return resources;
1476 }
1477
generateProgramInterfaceProgramSources(const ProgramInterfaceDefinition::Program * program)1478 glu::ProgramSources generateProgramInterfaceProgramSources (const ProgramInterfaceDefinition::Program* program)
1479 {
1480 glu::ProgramSources sources;
1481
1482 DE_ASSERT(program->isValid());
1483
1484 for (int shaderNdx = 0; shaderNdx < (int)program->getShaders().size(); ++shaderNdx)
1485 {
1486 const ProgramInterfaceDefinition::Shader* shader = program->getShaders()[shaderNdx];
1487 bool containsUserDefinedOutputs = false;
1488 bool containsUserDefinedInputs = false;
1489 std::ostringstream sourceBuf;
1490 std::ostringstream usageBuf;
1491
1492 sourceBuf << glu::getGLSLVersionDeclaration(shader->getVersion()) << "\n"
1493 << getShaderExtensionDeclarations(shader)
1494 << getShaderTypeDeclarations(program, shader->getType())
1495 << "\n";
1496
1497 // Struct definitions
1498
1499 writeStructureDefinitions(sourceBuf, shader->getDefaultBlock());
1500
1501 // variables in the default scope
1502
1503 for (int ndx = 0; ndx < (int)shader->getDefaultBlock().variables.size(); ++ndx)
1504 sourceBuf << shader->getDefaultBlock().variables[ndx] << ";\n";
1505
1506 if (!shader->getDefaultBlock().variables.empty())
1507 sourceBuf << "\n";
1508
1509 // Interface blocks
1510
1511 for (int ndx = 0; ndx < (int)shader->getDefaultBlock().interfaceBlocks.size(); ++ndx)
1512 writeInterfaceBlock(sourceBuf, shader->getDefaultBlock().interfaceBlocks[ndx]);
1513
1514 // Use inputs and outputs so that they won't be removed by the optimizer
1515
1516 usageBuf << "highp vec4 readInputs()\n"
1517 "{\n"
1518 " highp vec4 retValue = vec4(0.0);\n";
1519
1520 // User-defined inputs
1521
1522 for (int ndx = 0; ndx < (int)shader->getDefaultBlock().variables.size(); ++ndx)
1523 {
1524 if (shader->getDefaultBlock().variables[ndx].storage == glu::STORAGE_IN ||
1525 shader->getDefaultBlock().variables[ndx].storage == glu::STORAGE_PATCH_IN ||
1526 shader->getDefaultBlock().variables[ndx].storage == glu::STORAGE_UNIFORM)
1527 {
1528 writeVariableReadAccumulateExpression(usageBuf,
1529 "retValue",
1530 shader->getDefaultBlock().variables[ndx].name,
1531 shader->getType(),
1532 shader->getDefaultBlock().variables[ndx].storage,
1533 program,
1534 shader->getDefaultBlock().variables[ndx].varType);
1535 containsUserDefinedInputs = true;
1536 }
1537 }
1538
1539 for (int interfaceNdx = 0; interfaceNdx < (int)shader->getDefaultBlock().interfaceBlocks.size(); ++interfaceNdx)
1540 {
1541 const glu::InterfaceBlock& interface = shader->getDefaultBlock().interfaceBlocks[interfaceNdx];
1542 if (isReadableInterface(interface))
1543 {
1544 writeInterfaceReadAccumulateExpression(usageBuf,
1545 "retValue",
1546 interface,
1547 shader->getType(),
1548 program);
1549 containsUserDefinedInputs = true;
1550 }
1551 }
1552
1553 // Built-in-inputs
1554
1555 switch (shader->getType())
1556 {
1557 case glu::SHADERTYPE_VERTEX:
1558 // make readInputs to never be compile time constant
1559 if (!containsUserDefinedInputs)
1560 usageBuf << " retValue += vec4(float(gl_VertexID));\n";
1561 break;
1562
1563 case glu::SHADERTYPE_FRAGMENT:
1564 // make readInputs to never be compile time constant
1565 if (!containsUserDefinedInputs)
1566 usageBuf << " retValue += gl_FragCoord;\n";
1567 break;
1568 case glu::SHADERTYPE_GEOMETRY:
1569 // always use previous stage's output values so that previous stage won't be optimized out
1570 usageBuf << " retValue += gl_in[0].gl_Position;\n";
1571 break;
1572 case glu::SHADERTYPE_TESSELLATION_CONTROL:
1573 // always use previous stage's output values so that previous stage won't be optimized out
1574 usageBuf << " retValue += gl_in[0].gl_Position;\n";
1575 break;
1576 case glu::SHADERTYPE_TESSELLATION_EVALUATION:
1577 // always use previous stage's output values so that previous stage won't be optimized out
1578 usageBuf << " retValue += gl_in[0].gl_Position;\n";
1579 break;
1580
1581 case glu::SHADERTYPE_COMPUTE:
1582 // make readInputs to never be compile time constant
1583 if (!containsUserDefinedInputs)
1584 usageBuf << " retValue += vec4(float(gl_NumWorkGroups.x));\n";
1585 break;
1586 default:
1587 DE_ASSERT(false);
1588 }
1589
1590 usageBuf << " return retValue;\n"
1591 "}\n\n";
1592
1593 usageBuf << "void writeOutputs(in highp vec4 dummyValue)\n"
1594 "{\n";
1595
1596 // User-defined outputs
1597
1598 for (int ndx = 0; ndx < (int)shader->getDefaultBlock().variables.size(); ++ndx)
1599 {
1600 if (shader->getDefaultBlock().variables[ndx].storage == glu::STORAGE_OUT ||
1601 shader->getDefaultBlock().variables[ndx].storage == glu::STORAGE_PATCH_OUT)
1602 {
1603 writeVariableWriteExpression(usageBuf,
1604 "dummyValue",
1605 shader->getDefaultBlock().variables[ndx].name,
1606 shader->getType(),
1607 shader->getDefaultBlock().variables[ndx].storage,
1608 program,
1609 shader->getDefaultBlock().variables[ndx].varType);
1610 containsUserDefinedOutputs = true;
1611 }
1612 }
1613
1614 for (int interfaceNdx = 0; interfaceNdx < (int)shader->getDefaultBlock().interfaceBlocks.size(); ++interfaceNdx)
1615 {
1616 const glu::InterfaceBlock& interface = shader->getDefaultBlock().interfaceBlocks[interfaceNdx];
1617 if (isWritableInterface(interface))
1618 {
1619 writeInterfaceWriteExpression(usageBuf, "dummyValue", interface, shader->getType(), program);
1620 containsUserDefinedOutputs = true;
1621 }
1622 }
1623
1624 // Builtin-outputs that must be written to
1625
1626 if (shader->getType() == glu::SHADERTYPE_VERTEX)
1627 usageBuf << " gl_Position = dummyValue;\n";
1628 else if (shader->getType() == glu::SHADERTYPE_GEOMETRY)
1629 usageBuf << " gl_Position = dummyValue;\n"
1630 " EmitVertex();\n";
1631 else if (shader->getType() == glu::SHADERTYPE_TESSELLATION_CONTROL)
1632 usageBuf << " gl_out[gl_InvocationID].gl_Position = dummyValue;\n"
1633 " gl_TessLevelOuter[0] = 2.8;\n"
1634 " gl_TessLevelOuter[1] = 2.8;\n"
1635 " gl_TessLevelOuter[2] = 2.8;\n"
1636 " gl_TessLevelOuter[3] = 2.8;\n"
1637 " gl_TessLevelInner[0] = 2.8;\n"
1638 " gl_TessLevelInner[1] = 2.8;\n";
1639 else if (shader->getType() == glu::SHADERTYPE_TESSELLATION_EVALUATION)
1640 usageBuf << " gl_Position = dummyValue;\n";
1641
1642 // Output to sink input data to
1643
1644 if (!containsUserDefinedOutputs)
1645 {
1646 if (shader->getType() == glu::SHADERTYPE_FRAGMENT)
1647 usageBuf << " gl_FragDepth = dot(dummyValue.xy, dummyValue.xw);\n";
1648 else if (shader->getType() == glu::SHADERTYPE_COMPUTE)
1649 usageBuf << " dummyOutputBlock.dummyValue = dummyValue;\n";
1650 }
1651
1652 usageBuf << "}\n\n"
1653 "void main()\n"
1654 "{\n"
1655 " writeOutputs(readInputs());\n"
1656 "}\n";
1657
1658 // Interface for dummy output
1659
1660 if (shader->getType() == glu::SHADERTYPE_COMPUTE && !containsUserDefinedOutputs)
1661 {
1662 sourceBuf << "writeonly buffer DummyOutputInterface\n"
1663 << "{\n"
1664 << " highp vec4 dummyValue;\n"
1665 << "} dummyOutputBlock;\n\n";
1666 }
1667
1668 sources << glu::ShaderSource(shader->getType(), sourceBuf.str() + usageBuf.str());
1669 }
1670
1671 if (program->isSeparable())
1672 sources << glu::ProgramSeparable(true);
1673
1674 for (int ndx = 0; ndx < (int)program->getTransformFeedbackVaryings().size(); ++ndx)
1675 sources << glu::TransformFeedbackVarying(program->getTransformFeedbackVaryings()[ndx]);
1676
1677 if (program->getTransformFeedbackMode())
1678 sources << glu::TransformFeedbackMode(program->getTransformFeedbackMode());
1679
1680 return sources;
1681 }
1682
findProgramVariablePathByPathName(std::vector<VariablePathComponent> & typePath,const ProgramInterfaceDefinition::Program * program,const std::string & pathName,const VariableSearchFilter & filter)1683 bool findProgramVariablePathByPathName (std::vector<VariablePathComponent>& typePath, const ProgramInterfaceDefinition::Program* program, const std::string& pathName, const VariableSearchFilter& filter)
1684 {
1685 std::vector<VariablePathComponent> modifiedPath;
1686
1687 if (!traverseProgramVariablePath(modifiedPath, program, pathName, filter))
1688 return false;
1689
1690 // modify param only on success
1691 typePath.swap(modifiedPath);
1692 return true;
1693 }
1694
getShaderResourceUsage(const ProgramInterfaceDefinition::Program * program,const ProgramInterfaceDefinition::Shader * shader)1695 ProgramInterfaceDefinition::ShaderResourceUsage getShaderResourceUsage (const ProgramInterfaceDefinition::Program* program, const ProgramInterfaceDefinition::Shader* shader)
1696 {
1697 ProgramInterfaceDefinition::ShaderResourceUsage retVal;
1698
1699 retVal.numInputs = getNumTypeInstances(shader, glu::STORAGE_IN);
1700 retVal.numInputVectors = getNumVectors(shader, glu::STORAGE_IN);
1701 retVal.numInputComponents = getNumComponents(shader, glu::STORAGE_IN);
1702
1703 retVal.numOutputs = getNumTypeInstances(shader, glu::STORAGE_OUT);
1704 retVal.numOutputVectors = getNumVectors(shader, glu::STORAGE_OUT);
1705 retVal.numOutputComponents = getNumComponents(shader, glu::STORAGE_OUT);
1706
1707 retVal.numPatchInputComponents = getNumComponents(shader, glu::STORAGE_PATCH_IN);
1708 retVal.numPatchOutputComponents = getNumComponents(shader, glu::STORAGE_PATCH_OUT);
1709
1710 retVal.numDefaultBlockUniformComponents = getNumDefaultBlockComponents(shader, glu::STORAGE_UNIFORM);
1711 retVal.numCombinedUniformComponents = getNumComponents(shader, glu::STORAGE_UNIFORM);
1712 retVal.numUniformVectors = getNumVectors(shader, glu::STORAGE_UNIFORM);
1713
1714 retVal.numSamplers = getNumTypeInstances(shader, glu::STORAGE_UNIFORM, glu::isDataTypeSampler);
1715 retVal.numImages = getNumTypeInstances(shader, glu::STORAGE_UNIFORM, glu::isDataTypeImage);
1716
1717 retVal.numAtomicCounterBuffers = getNumAtomicCounterBuffers(shader);
1718 retVal.numAtomicCounters = getNumTypeInstances(shader, glu::STORAGE_UNIFORM, glu::isDataTypeAtomicCounter);
1719
1720 retVal.numUniformBlocks = getNumShaderBlocks(shader, glu::STORAGE_UNIFORM);
1721 retVal.numShaderStorageBlocks = getNumShaderBlocks(shader, glu::STORAGE_BUFFER);
1722
1723 // add builtins
1724 switch (shader->getType())
1725 {
1726 case glu::SHADERTYPE_VERTEX:
1727 // gl_Position is not counted
1728 break;
1729
1730 case glu::SHADERTYPE_FRAGMENT:
1731 // nada
1732 break;
1733
1734 case glu::SHADERTYPE_GEOMETRY:
1735 // gl_Position in (point mode => size 1)
1736 retVal.numInputs += 1;
1737 retVal.numInputVectors += 1;
1738 retVal.numInputComponents += 4;
1739
1740 // gl_Position out
1741 retVal.numOutputs += 1;
1742 retVal.numOutputVectors += 1;
1743 retVal.numOutputComponents += 4;
1744 break;
1745
1746 case glu::SHADERTYPE_TESSELLATION_CONTROL:
1747 // gl_Position in is read up to gl_InstanceID
1748 retVal.numInputs += 1 * program->getTessellationNumOutputPatchVertices();
1749 retVal.numInputVectors += 1 * program->getTessellationNumOutputPatchVertices();
1750 retVal.numInputComponents += 4 * program->getTessellationNumOutputPatchVertices();
1751
1752 // gl_Position out, size = num patch out vertices
1753 retVal.numOutputs += 1 * program->getTessellationNumOutputPatchVertices();
1754 retVal.numOutputVectors += 1 * program->getTessellationNumOutputPatchVertices();
1755 retVal.numOutputComponents += 4 * program->getTessellationNumOutputPatchVertices();
1756 break;
1757
1758 case glu::SHADERTYPE_TESSELLATION_EVALUATION:
1759 // gl_Position in is read up to gl_InstanceID
1760 retVal.numInputs += 1 * program->getTessellationNumOutputPatchVertices();
1761 retVal.numInputVectors += 1 * program->getTessellationNumOutputPatchVertices();
1762 retVal.numInputComponents += 4 * program->getTessellationNumOutputPatchVertices();
1763
1764 // gl_Position out
1765 retVal.numOutputs += 1;
1766 retVal.numOutputVectors += 1;
1767 retVal.numOutputComponents += 4;
1768 break;
1769
1770 case glu::SHADERTYPE_COMPUTE:
1771 // nada
1772 break;
1773
1774 default:
1775 DE_ASSERT(false);
1776 break;
1777 }
1778 return retVal;
1779 }
1780
getCombinedProgramResourceUsage(const ProgramInterfaceDefinition::Program * program)1781 ProgramInterfaceDefinition::ProgramResourceUsage getCombinedProgramResourceUsage (const ProgramInterfaceDefinition::Program* program)
1782 {
1783 ProgramInterfaceDefinition::ProgramResourceUsage retVal;
1784 int numVertexOutputComponents = 0;
1785 int numFragmentInputComponents = 0;
1786 int numVertexOutputVectors = 0;
1787 int numFragmentInputVectors = 0;
1788
1789 retVal.uniformBufferMaxBinding = -1; // max binding is inclusive upper bound. Allow 0 bindings by using negative value
1790 retVal.uniformBufferMaxSize = 0;
1791 retVal.numUniformBlocks = 0;
1792 retVal.numCombinedVertexUniformComponents = 0;
1793 retVal.numCombinedFragmentUniformComponents = 0;
1794 retVal.numCombinedGeometryUniformComponents = 0;
1795 retVal.numCombinedTessControlUniformComponents = 0;
1796 retVal.numCombinedTessEvalUniformComponents = 0;
1797 retVal.shaderStorageBufferMaxBinding = -1; // see above
1798 retVal.shaderStorageBufferMaxSize = 0;
1799 retVal.numShaderStorageBlocks = 0;
1800 retVal.numVaryingComponents = 0;
1801 retVal.numVaryingVectors = 0;
1802 retVal.numCombinedSamplers = 0;
1803 retVal.atomicCounterBufferMaxBinding = -1; // see above
1804 retVal.atomicCounterBufferMaxSize = 0;
1805 retVal.numAtomicCounterBuffers = 0;
1806 retVal.numAtomicCounters = 0;
1807 retVal.maxImageBinding = -1; // see above
1808 retVal.numCombinedImages = 0;
1809 retVal.numCombinedOutputResources = 0;
1810 retVal.numXFBInterleavedComponents = 0;
1811 retVal.numXFBSeparateAttribs = 0;
1812 retVal.numXFBSeparateComponents = 0;
1813 retVal.fragmentOutputMaxBinding = -1; // see above
1814
1815 for (int shaderNdx = 0; shaderNdx < (int)program->getShaders().size(); ++shaderNdx)
1816 {
1817 const ProgramInterfaceDefinition::Shader* const shader = program->getShaders()[shaderNdx];
1818
1819 retVal.uniformBufferMaxBinding = de::max(retVal.uniformBufferMaxBinding, getMaxBufferBinding(shader, glu::STORAGE_UNIFORM));
1820 retVal.uniformBufferMaxSize = de::max(retVal.uniformBufferMaxSize, getBufferMaxSize(shader, glu::STORAGE_UNIFORM));
1821 retVal.numUniformBlocks += getNumShaderBlocks(shader, glu::STORAGE_UNIFORM);
1822
1823 switch (shader->getType())
1824 {
1825 case glu::SHADERTYPE_VERTEX: retVal.numCombinedVertexUniformComponents += getNumComponents(shader, glu::STORAGE_UNIFORM); break;
1826 case glu::SHADERTYPE_FRAGMENT: retVal.numCombinedFragmentUniformComponents += getNumComponents(shader, glu::STORAGE_UNIFORM); break;
1827 case glu::SHADERTYPE_GEOMETRY: retVal.numCombinedGeometryUniformComponents += getNumComponents(shader, glu::STORAGE_UNIFORM); break;
1828 case glu::SHADERTYPE_TESSELLATION_CONTROL: retVal.numCombinedTessControlUniformComponents += getNumComponents(shader, glu::STORAGE_UNIFORM); break;
1829 case glu::SHADERTYPE_TESSELLATION_EVALUATION: retVal.numCombinedTessEvalUniformComponents += getNumComponents(shader, glu::STORAGE_UNIFORM); break;
1830 default: break;
1831 }
1832
1833 retVal.shaderStorageBufferMaxBinding = de::max(retVal.shaderStorageBufferMaxBinding, getMaxBufferBinding(shader, glu::STORAGE_BUFFER));
1834 retVal.shaderStorageBufferMaxSize = de::max(retVal.shaderStorageBufferMaxSize, getBufferMaxSize(shader, glu::STORAGE_BUFFER));
1835 retVal.numShaderStorageBlocks += getNumShaderBlocks(shader, glu::STORAGE_BUFFER);
1836
1837 if (shader->getType() == glu::SHADERTYPE_VERTEX)
1838 {
1839 numVertexOutputComponents += getNumComponents(shader, glu::STORAGE_OUT);
1840 numVertexOutputVectors += getNumVectors(shader, glu::STORAGE_OUT);
1841 }
1842 else if (shader->getType() == glu::SHADERTYPE_FRAGMENT)
1843 {
1844 numFragmentInputComponents += getNumComponents(shader, glu::STORAGE_IN);
1845 numFragmentInputVectors += getNumVectors(shader, glu::STORAGE_IN);
1846 }
1847
1848 retVal.numCombinedSamplers += getNumTypeInstances(shader, glu::STORAGE_UNIFORM, glu::isDataTypeSampler);
1849
1850 retVal.atomicCounterBufferMaxBinding = de::max(retVal.atomicCounterBufferMaxBinding, getAtomicCounterMaxBinding(shader));
1851 retVal.atomicCounterBufferMaxSize = de::max(retVal.atomicCounterBufferMaxSize, getAtomicCounterMaxBufferSize(shader));
1852 retVal.numAtomicCounterBuffers += getNumAtomicCounterBuffers(shader);
1853 retVal.numAtomicCounters += getNumTypeInstances(shader, glu::STORAGE_UNIFORM, glu::isDataTypeAtomicCounter);
1854 retVal.maxImageBinding = de::max(retVal.maxImageBinding, getUniformMaxBinding(shader, glu::isDataTypeImage));
1855 retVal.numCombinedImages += getNumTypeInstances(shader, glu::STORAGE_UNIFORM, glu::isDataTypeImage);
1856
1857 retVal.numCombinedOutputResources += getNumTypeInstances(shader, glu::STORAGE_UNIFORM, glu::isDataTypeImage);
1858 retVal.numCombinedOutputResources += getNumShaderBlocks(shader, glu::STORAGE_BUFFER);
1859
1860 if (shader->getType() == glu::SHADERTYPE_FRAGMENT)
1861 {
1862 retVal.numCombinedOutputResources += getNumVectors(shader, glu::STORAGE_OUT);
1863 retVal.fragmentOutputMaxBinding = de::max(retVal.fragmentOutputMaxBinding, getFragmentOutputMaxLocation(shader));
1864 }
1865 }
1866
1867 if (program->getTransformFeedbackMode() == GL_INTERLEAVED_ATTRIBS)
1868 retVal.numXFBInterleavedComponents = getNumXFBComponents(program);
1869 else if (program->getTransformFeedbackMode() == GL_SEPARATE_ATTRIBS)
1870 {
1871 retVal.numXFBSeparateAttribs = (int)program->getTransformFeedbackVaryings().size();
1872 retVal.numXFBSeparateComponents = getNumMaxXFBOutputComponents(program);
1873 }
1874
1875 // legacy limits
1876 retVal.numVaryingComponents = de::max(numVertexOutputComponents, numFragmentInputComponents);
1877 retVal.numVaryingVectors = de::max(numVertexOutputVectors, numFragmentInputVectors);
1878
1879 return retVal;
1880 }
1881
1882 } // Functional
1883 } // gles31
1884 } // deqp
1885