Lines Matching refs:glu
54 VariableSearchFilter VariableSearchFilter::createShaderTypeFilter (glu::ShaderType type)
56 DE_ASSERT(type < glu::SHADERTYPE_LAST);
63 VariableSearchFilter VariableSearchFilter::createStorageFilter (glu::Storage storage)
65 DE_ASSERT(storage < glu::STORAGE_LAST);
72 VariableSearchFilter VariableSearchFilter::createShaderTypeStorageFilter (glu::ShaderType type, glu::Storage storage)
95 DE_ASSERT(shader->getType() < glu::SHADERTYPE_LAST);
99 bool VariableSearchFilter::matchesFilter (const glu::VariableDeclaration& variable) const
101 DE_ASSERT(variable.storage < glu::STORAGE_LAST);
105 bool VariableSearchFilter::matchesFilter (const glu::InterfaceBlock& block) const
107 DE_ASSERT(block.storage < glu::STORAGE_LAST);
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)
155 glu::ShaderType getProgramTransformFeedbackStage (const ProgramInterfaceDefinition::Program* program)
157 if (program->hasStage(glu::SHADERTYPE_GEOMETRY))
158 return glu::SHADERTYPE_GEOMETRY;
160 if (program->hasStage(glu::SHADERTYPE_TESSELLATION_EVALUATION))
161 return glu::SHADERTYPE_TESSELLATION_EVALUATION;
163 if (program->hasStage(glu::SHADERTYPE_VERTEX))
164 return glu::SHADERTYPE_VERTEX;
167 return glu::SHADERTYPE_LAST;
170 void generateVariableTypeResourceNames (std::vector<std::string>& resources, const std::string& name, const glu::VarType& type, deUint32 resourceNameGenerationFlags)
181 const glu::StructType* structType = type.getStructPtr();
221 if (shader->getVersion() > glu::GLSL_VERSION_440)
227 if (shader->getType() == glu::SHADERTYPE_GEOMETRY)
231 else if (shader->getType() == glu::SHADERTYPE_TESSELLATION_CONTROL ||
232 shader->getType() == glu::SHADERTYPE_TESSELLATION_EVALUATION)
247 glu::ShaderType type = shader->getType();
248 auto isCoreGL = (shader->getVersion() > glu::GLSL_VERSION_440);
252 case glu::SHADERTYPE_VERTEX:
257 case glu::SHADERTYPE_FRAGMENT:
260 case glu::SHADERTYPE_GEOMETRY:
273 case glu::SHADERTYPE_TESSELLATION_CONTROL:
285 case glu::SHADERTYPE_TESSELLATION_EVALUATION:
297 case glu::SHADERTYPE_COMPUTE:
310 bool operator() (const glu::StructType* type) { return type->hasTypeName() && (deStringEqual(m_name, type->getTypeName()) == DE_TRUE); }
315 static void collectNamedStructureDefinitions (std::vector<const glu::StructType*>& dst, const glu::VarType& type)
326 std::vector<const glu::StructType*>::iterator where = std::find_if(dst.begin(), dst.end(), StructNameEqualPredicate(type.getStructPtr()->getTypeName()));
348 std::vector<const glu::StructType*> namedStructs;
367 buf << glu::indent(1) << glu::declare(namedStructs[structNdx]->getMember(memberNdx).getType(), namedStructs[structNdx]->getMember(memberNdx).getName(), 1) << ";\n";
376 static void writeInterfaceBlock (std::ostringstream& buf, const glu::InterfaceBlock& interfaceBlock)
380 if (interfaceBlock.layout != glu::Layout())
383 buf << glu::getStorageName(interfaceBlock.storage) << " " << interfaceBlock.interfaceName << "\n"
387 buf << glu::indent(1) << interfaceBlock.variables[ndx] << ";\n";
400 static bool isReadableInterface (const glu::InterfaceBlock& interface)
402 return interface.storage == glu::STORAGE_UNIFORM ||
403 interface.storage == glu::STORAGE_IN ||
404 interface.storage == glu::STORAGE_PATCH_IN ||
405 (interface.storage == glu::STORAGE_BUFFER && (interface.memoryAccessQualifierFlags & glu::MEMORYACCESSQUALIFIER_WRITEONLY_BIT) == 0);
408 static bool isWritableInterface (const glu::InterfaceBlock& interface)
410 return interface.storage == glu::STORAGE_OUT ||
411 interface.storage == glu::STORAGE_PATCH_OUT ||
412 (interface.storage == glu::STORAGE_BUFFER && (interface.memoryAccessQualifierFlags & glu::MEMORYACCESSQUALIFIER_READONLY_BIT) == 0);
419 glu::ShaderType shaderType,
420 glu::Storage storage,
422 const glu::VarType& varType)
428 if (glu::isDataTypeScalar(varType.getBasicType()))
430 else if (glu::isDataTypeVector(varType.getBasicType()))
432 else if (glu::isDataTypeMatrix(varType.getBasicType()))
434 else if (glu::isDataTypeSamplerMultisample(varType.getBasicType()))
436 else if (glu::isDataTypeSampler(varType.getBasicType()))
438 else if (glu::isDataTypeImage(varType.getBasicType()))
440 else if (varType.getBasicType() == glu::TYPE_UINT_ATOMIC_COUNTER)
460 if (varType.getArraySize() != glu::VarType::UNSIZED_ARRAY)
471 else if (storage == glu::STORAGE_BUFFER)
484 DE_ASSERT(storage == glu::STORAGE_IN);
486 if (shaderType == glu::SHADERTYPE_GEOMETRY)
497 else if (shaderType == glu::SHADERTYPE_TESSELLATION_CONTROL)
508 else if (shaderType == glu::SHADERTYPE_TESSELLATION_EVALUATION)
533 const glu::InterfaceBlock& block,
534 glu::ShaderType shaderType,
588 glu::ShaderType shaderType,
589 glu::Storage storage,
591 const glu::VarType& varType)
597 if (glu::isDataTypeScalar(varType.getBasicType()))
598 buf << glu::getDataTypeName(varType.getBasicType()) << "(" << sourceVec4Name << ".y)";
599 else if (glu::isDataTypeVector(varType.getBasicType()) || glu::isDataTypeMatrix(varType.getBasicType()))
600 buf << glu::getDataTypeName(varType.getBasicType()) << "(" << glu::getDataTypeName(glu::getDataTypeScalarType(varType.getBasicType())) << "(" << sourceVec4Name << ".y))";
619 if (varType.getArraySize() != glu::VarType::UNSIZED_ARRAY)
630 else if (storage == glu::STORAGE_BUFFER)
643 DE_ASSERT(storage == glu::STORAGE_OUT);
645 if (shaderType == glu::SHADERTYPE_TESSELLATION_CONTROL)
666 const glu::InterfaceBlock& block,
667 glu::ShaderType shaderType,
718 static bool traverseVariablePath (std::vector<VariablePathComponent>& typePath, const char* subPath, const glu::VarType& type)
720 glu::VarTokenizer tokenizer(subPath);
724 if (tokenizer.getToken() == glu::VarTokenizer::TOKEN_END)
727 if (type.isStructType() && tokenizer.getToken() == glu::VarTokenizer::TOKEN_PERIOD)
732 if (tokenizer.getToken() != glu::VarTokenizer::TOKEN_IDENTIFIER)
742 else if (type.isArrayType() && tokenizer.getToken() == glu::VarTokenizer::TOKEN_LEFT_BRACKET)
747 if (tokenizer.getToken() != glu::VarTokenizer::TOKEN_NUMBER)
751 if (tokenizer.getToken() != glu::VarTokenizer::TOKEN_RIGHT_BRACKET)
760 static bool traverseVariablePath (std::vector<VariablePathComponent>& typePath, const std::string& path, const glu::VariableDeclaration& var)
762 if (glu::parseVariableName(path.c_str()) != var.name)
779 const std::string blockName = glu::parseVariableName(path.c_str());
791 const std::string blockMemeberName = glu::parseVariableName(blockMemberPath.c_str());
807 const std::string blockMemeberName = glu::parseVariableName(path.c_str());
845 static bool containsSubType (const glu::VarType& complexType, glu::DataType basicType)
869 static int getNumShaderBlocks (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage)
895 if (containsSubType(shader->getDefaultBlock().variables[ndx].varType, glu::TYPE_UINT_ATOMIC_COUNTER))
906 static int accumulateComplexType (const glu::VarType& complexType, const DataTypeMap& dTypeMap)
912 const int arraySize = (complexType.getArraySize() == glu::VarType::UNSIZED_ARRAY) ? (1) : (complexType.getArraySize());
958 static bool unusedTrueConstantTypeFilter (glu::DataType d)
967 InstanceCounter (bool (*predicate)(glu::DataType))
972 int operator() (glu::DataType t) const
978 bool (*const m_predicate)(glu::DataType);
984 InterfaceBlockStorageFilter (glu::Storage storage)
989 bool operator() (const glu::InterfaceBlock& b) const
995 const glu::Storage m_storage;
1001 VariableDeclarationStorageFilter (glu::Storage storage)
1006 bool operator() (const glu::VariableDeclaration& d) const
1012 const glu::Storage m_storage;
1015 static int getNumTypeInstances (const glu::VarType& complexType, bool (*predicate)(glu::DataType))
1020 static int getNumTypeInstances (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage, bool (*predicate)(glu::DataType))
1025 static int getNumTypeInstances (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage)
1030 static int accumulateShaderStorage (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage, int (*typeMap)(glu::DataType))
1035 static int getNumDataTypeComponents (glu::DataType type)
1037 if (glu::isDataTypeScalarOrVector(type) || glu::isDataTypeMatrix(type))
1038 return glu::getDataTypeScalarSize(type);
1043 static int getNumDataTypeVectors (glu::DataType type)
1045 if (glu::isDataTypeScalar(type))
1047 else if (glu::isDataTypeVector(type))
1049 else if (glu::isDataTypeMatrix(type))
1050 return glu::getDataTypeMatrixNumColumns(type);
1055 static int getNumComponents (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage)
1060 static int getNumVectors (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage)
1065 static int getNumDefaultBlockComponents (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage)
1076 static int getMaxBufferBinding (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage)
1097 static int getBufferTypeSize (glu::DataType type, glu::MatrixOrder order)
1102 if (glu::isDataTypeScalarOrVector(type))
1104 else if (glu::isDataTypeMatrix(type) && order == glu::MATRIXORDER_ROW_MAJOR)
1105 numVectors = glu::getDataTypeMatrixNumRows(type);
1106 else if (glu::isDataTypeMatrix(type) && order != glu::MATRIXORDER_ROW_MAJOR)
1107 numVectors = glu::getDataTypeMatrixNumColumns(type);
1114 static int getBufferVariableSize (const glu::VarType& type, glu::MatrixOrder order)
1120 const int arraySize = (type.getArraySize() == glu::VarType::UNSIZED_ARRAY) ? (1) : (type.getArraySize());
1137 static int getBufferSize (const glu::InterfaceBlock& block, glu::MatrixOrder blockOrder)
1142 size += getBufferVariableSize(block.variables[ndx].varType, (block.variables[ndx].layout.matrixOrder == glu::MATRIXORDER_LAST) ? (blockOrder) : (block.variables[ndx].layout.matrixOrder));
1147 static int getBufferMaxSize (const ProgramInterfaceDefinition::Shader* shader, glu::Storage storage)
1164 if (containsSubType(shader->getDefaultBlock().variables[ndx].varType, glu::TYPE_UINT_ATOMIC_COUNTER))
1174 static int getUniformMaxBinding (const ProgramInterfaceDefinition::Shader* shader, bool (*predicate)(glu::DataType))
1196 if (containsSubType(shader->getDefaultBlock().variables[ndx].varType, glu::TYPE_UINT_ATOMIC_COUNTER))
1200 const int size = offset + 4 * getNumTypeInstances(shader->getDefaultBlock().variables[ndx].varType, glu::isDataTypeAtomicCounter);
1226 if (!traverseProgramVariablePath(path, program, name, VariableSearchFilter::createShaderTypeStorageFilter(getProgramTransformFeedbackStage(program), glu::STORAGE_OUT)))
1254 DE_ASSERT(shader->getType() == glu::SHADERTYPE_FRAGMENT);
1260 if (shader->getDefaultBlock().variables[ndx].storage == glu::STORAGE_OUT)
1283 std::vector<std::string> getProgramInterfaceBlockMemberResourceList (const glu::InterfaceBlock& interfaceBlock)
1286 const bool isTopLevelBufferVariable = (interfaceBlock.storage == glu::STORAGE_BUFFER);
1315 const glu::Storage storage = (interface == PROGRAMINTERFACE_UNIFORM) ? (glu::STORAGE_UNIFORM) : (glu::STORAGE_BUFFER);
1330 const glu::InterfaceBlock& interfaceBlock = shader->getDefaultBlock().interfaceBlocks[interfaceNdx];
1344 const glu::Storage storage = (interface == PROGRAMINTERFACE_UNIFORM_BLOCK) ? (glu::STORAGE_UNIFORM) : (glu::STORAGE_BUFFER);
1351 const glu::InterfaceBlock& interfaceBlock = shader->getDefaultBlock().interfaceBlocks[interfaceNdx];
1382 const glu::Storage queryStorage = (interface == PROGRAMINTERFACE_PROGRAM_INPUT) ? (glu::STORAGE_IN) : (glu::STORAGE_OUT);
1383 const glu::Storage queryPatchStorage = (interface == PROGRAMINTERFACE_PROGRAM_INPUT) ? (glu::STORAGE_PATCH_IN) : (glu::STORAGE_PATCH_OUT);
1384 const glu::ShaderType shaderType = (interface == PROGRAMINTERFACE_PROGRAM_INPUT) ? (program->getFirstStage()) : (program->getLastStage());
1395 const glu::Storage variableStorage = shader->getDefaultBlock().variables[variableNdx].storage;
1405 const glu::InterfaceBlock& interfaceBlock = shader->getDefaultBlock().interfaceBlocks[interfaceNdx];
1417 if (shaderType == glu::SHADERTYPE_VERTEX && resources.empty())
1419 else if (shaderType == glu::SHADERTYPE_FRAGMENT && resources.empty())
1421 else if (shaderType == glu::SHADERTYPE_GEOMETRY)
1423 else if (shaderType == glu::SHADERTYPE_TESSELLATION_CONTROL)
1428 else if (shaderType == glu::SHADERTYPE_TESSELLATION_EVALUATION)
1430 else if (shaderType == glu::SHADERTYPE_COMPUTE && resources.empty())
1435 if (shaderType == glu::SHADERTYPE_VERTEX)
1437 else if (shaderType == glu::SHADERTYPE_FRAGMENT && resources.empty())
1439 else if (shaderType == glu::SHADERTYPE_GEOMETRY)
1441 else if (shaderType == glu::SHADERTYPE_TESSELLATION_CONTROL)
1447 else if (shaderType == glu::SHADERTYPE_TESSELLATION_EVALUATION)
1456 const glu::ShaderType xfbStage = getProgramTransformFeedbackStage(program);
1468 if (!traverseProgramVariablePath(path, program, varyingName, VariableSearchFilter::createShaderTypeStorageFilter(xfbStage, glu::STORAGE_OUT)))
1520 glu::ProgramSources generateProgramInterfaceProgramSources (const ProgramInterfaceDefinition::Program* program)
1522 glu::ProgramSources sources;
1534 sourceBuf << glu::getGLSLVersionDeclaration(shader->getVersion()) << "\n"
1567 if (shader->getDefaultBlock().variables[ndx].storage == glu::STORAGE_IN ||
1568 shader->getDefaultBlock().variables[ndx].storage == glu::STORAGE_PATCH_IN ||
1569 shader->getDefaultBlock().variables[ndx].storage == glu::STORAGE_UNIFORM)
1584 const glu::InterfaceBlock& interface = shader->getDefaultBlock().interfaceBlocks[interfaceNdx];
1600 case glu::SHADERTYPE_VERTEX:
1606 case glu::SHADERTYPE_FRAGMENT:
1611 case glu::SHADERTYPE_GEOMETRY:
1615 case glu::SHADERTYPE_TESSELLATION_CONTROL:
1619 case glu::SHADERTYPE_TESSELLATION_EVALUATION:
1624 case glu::SHADERTYPE_COMPUTE:
1643 if (shader->getDefaultBlock().variables[ndx].storage == glu::STORAGE_OUT ||
1644 shader->getDefaultBlock().variables[ndx].storage == glu::STORAGE_PATCH_OUT)
1659 const glu::InterfaceBlock& interface = shader->getDefaultBlock().interfaceBlocks[interfaceNdx];
1669 if (shader->getType() == glu::SHADERTYPE_VERTEX)
1671 else if (shader->getType() == glu::SHADERTYPE_GEOMETRY)
1674 else if (shader->getType() == glu::SHADERTYPE_TESSELLATION_CONTROL)
1682 else if (shader->getType() == glu::SHADERTYPE_TESSELLATION_EVALUATION)
1689 if (shader->getType() == glu::SHADERTYPE_FRAGMENT)
1691 else if (shader->getType() == glu::SHADERTYPE_COMPUTE)
1703 if (shader->getType() == glu::SHADERTYPE_COMPUTE && !containsUserDefinedOutputs)
1711 sources << glu::ShaderSource(shader->getType(), sourceBuf.str() + usageBuf.str());
1715 sources << glu::ProgramSeparable(true);
1718 sources << glu::TransformFeedbackVarying(program->getTransformFeedbackVaryings()[ndx]);
1721 sources << glu::TransformFeedbackMode(program->getTransformFeedbackMode());
1742 retVal.numInputs = getNumTypeInstances(shader, glu::STORAGE_IN);
1743 retVal.numInputVectors = getNumVectors(shader, glu::STORAGE_IN);
1744 retVal.numInputComponents = getNumComponents(shader, glu::STORAGE_IN);
1746 retVal.numOutputs = getNumTypeInstances(shader, glu::STORAGE_OUT);
1747 retVal.numOutputVectors = getNumVectors(shader, glu::STORAGE_OUT);
1748 retVal.numOutputComponents = getNumComponents(shader, glu::STORAGE_OUT);
1750 retVal.numPatchInputComponents = getNumComponents(shader, glu::STORAGE_PATCH_IN);
1751 retVal.numPatchOutputComponents = getNumComponents(shader, glu::STORAGE_PATCH_OUT);
1753 retVal.numDefaultBlockUniformComponents = getNumDefaultBlockComponents(shader, glu::STORAGE_UNIFORM);
1754 retVal.numCombinedUniformComponents = getNumComponents(shader, glu::STORAGE_UNIFORM);
1755 retVal.numUniformVectors = getNumVectors(shader, glu::STORAGE_UNIFORM);
1757 retVal.numSamplers = getNumTypeInstances(shader, glu::STORAGE_UNIFORM, glu::isDataTypeSampler);
1758 retVal.numImages = getNumTypeInstances(shader, glu::STORAGE_UNIFORM, glu::isDataTypeImage);
1761 retVal.numAtomicCounters = getNumTypeInstances(shader, glu::STORAGE_UNIFORM, glu::isDataTypeAtomicCounter);
1763 retVal.numUniformBlocks = getNumShaderBlocks(shader, glu::STORAGE_UNIFORM);
1764 retVal.numShaderStorageBlocks = getNumShaderBlocks(shader, glu::STORAGE_BUFFER);
1769 case glu::SHADERTYPE_VERTEX:
1773 case glu::SHADERTYPE_FRAGMENT:
1777 case glu::SHADERTYPE_GEOMETRY:
1789 case glu::SHADERTYPE_TESSELLATION_CONTROL:
1801 case glu::SHADERTYPE_TESSELLATION_EVALUATION:
1813 case glu::SHADERTYPE_COMPUTE:
1862 retVal.uniformBufferMaxBinding = de::max(retVal.uniformBufferMaxBinding, getMaxBufferBinding(shader, glu::STORAGE_UNIFORM));
1863 retVal.uniformBufferMaxSize = de::max(retVal.uniformBufferMaxSize, getBufferMaxSize(shader, glu::STORAGE_UNIFORM));
1864 retVal.numUniformBlocks += getNumShaderBlocks(shader, glu::STORAGE_UNIFORM);
1868 case glu::SHADERTYPE_VERTEX: retVal.numCombinedVertexUniformComponents += getNumComponents(shader, glu::STORAGE_UNIFORM); break;
1869 case glu::SHADERTYPE_FRAGMENT: retVal.numCombinedFragmentUniformComponents += getNumComponents(shader, glu::STORAGE_UNIFORM); break;
1870 case glu::SHADERTYPE_GEOMETRY: retVal.numCombinedGeometryUniformComponents += getNumComponents(shader, glu::STORAGE_UNIFORM); break;
1871 case glu::SHADERTYPE_TESSELLATION_CONTROL: retVal.numCombinedTessControlUniformComponents += getNumComponents(shader, glu::STORAGE_UNIFORM); break;
1872 case glu::SHADERTYPE_TESSELLATION_EVALUATION: retVal.numCombinedTessEvalUniformComponents += getNumComponents(shader, glu::STORAGE_UNIFORM); break;
1876 retVal.shaderStorageBufferMaxBinding = de::max(retVal.shaderStorageBufferMaxBinding, getMaxBufferBinding(shader, glu::STORAGE_BUFFER));
1877 retVal.shaderStorageBufferMaxSize = de::max(retVal.shaderStorageBufferMaxSize, getBufferMaxSize(shader, glu::STORAGE_BUFFER));
1878 retVal.numShaderStorageBlocks += getNumShaderBlocks(shader, glu::STORAGE_BUFFER);
1880 if (shader->getType() == glu::SHADERTYPE_VERTEX)
1882 numVertexOutputComponents += getNumComponents(shader, glu::STORAGE_OUT);
1883 numVertexOutputVectors += getNumVectors(shader, glu::STORAGE_OUT);
1885 else if (shader->getType() == glu::SHADERTYPE_FRAGMENT)
1887 numFragmentInputComponents += getNumComponents(shader, glu::STORAGE_IN);
1888 numFragmentInputVectors += getNumVectors(shader, glu::STORAGE_IN);
1891 retVal.numCombinedSamplers += getNumTypeInstances(shader, glu::STORAGE_UNIFORM, glu::isDataTypeSampler);
1896 retVal.numAtomicCounters += getNumTypeInstances(shader, glu::STORAGE_UNIFORM, glu::isDataTypeAtomicCounter);
1897 retVal.maxImageBinding = de::max(retVal.maxImageBinding, getUniformMaxBinding(shader, glu::isDataTypeImage));
1898 retVal.numCombinedImages += getNumTypeInstances(shader, glu::STORAGE_UNIFORM, glu::isDataTypeImage);
1900 retVal.numCombinedOutputResources += getNumTypeInstances(shader, glu::STORAGE_UNIFORM, glu::isDataTypeImage);
1901 retVal.numCombinedOutputResources += getNumShaderBlocks(shader, glu::STORAGE_BUFFER);
1903 if (shader->getType() == glu::SHADERTYPE_FRAGMENT)
1905 retVal.numCombinedOutputResources += getNumVectors(shader, glu::STORAGE_OUT);