xref: /third_party/vk-gl-cts/modules/gles31/functional/es31fProgramInterfaceQueryTests.cpp

56 static int getTypeSize (glu::DataType type)
58 	if (type == glu::TYPE_FLOAT)
60 	else if (type == glu::TYPE_INT || type == glu::TYPE_UINT)
62 	else if (type == glu::TYPE_BOOL)
69 static int getVarTypeSize (const glu::VarType& type)
72 		return glu::getDataTypeScalarSize(type.getBasicType()) * getTypeSize(glu::getDataTypeScalarType(type.getBasicType()));
82 		if (type.getArraySize() == glu::VarType::UNSIZED_ARRAY)
164 static glu::ShaderType getShaderMaskFirstStage (deUint32 mask)
166 	if (mask & (1u << glu::SHADERTYPE_COMPUTE))
167 		return glu::SHADERTYPE_COMPUTE;
169 	if (mask & (1u << glu::SHADERTYPE_VERTEX))
170 		return glu::SHADERTYPE_VERTEX;
172 	if (mask & (1u << glu::SHADERTYPE_TESSELLATION_CONTROL))
173 		return glu::SHADERTYPE_TESSELLATION_CONTROL;
175 	if (mask & (1u << glu::SHADERTYPE_TESSELLATION_EVALUATION))
176 		return glu::SHADERTYPE_TESSELLATION_EVALUATION;
178 	if (mask & (1u << glu::SHADERTYPE_GEOMETRY))
179 		return glu::SHADERTYPE_GEOMETRY;
181 	if (mask & (1u << glu::SHADERTYPE_FRAGMENT))
182 		return glu::SHADERTYPE_FRAGMENT;
185 	return glu::SHADERTYPE_LAST;
188 static glu::ShaderType getShaderMaskLastStage (deUint32 mask)
190 	if (mask & (1u << glu::SHADERTYPE_FRAGMENT))
191 		return glu::SHADERTYPE_FRAGMENT;
193 	if (mask & (1u << glu::SHADERTYPE_GEOMETRY))
194 		return glu::SHADERTYPE_GEOMETRY;
196 	if (mask & (1u << glu::SHADERTYPE_TESSELLATION_EVALUATION))
197 		return glu::SHADERTYPE_TESSELLATION_EVALUATION;
199 	if (mask & (1u << glu::SHADERTYPE_TESSELLATION_CONTROL))
200 		return glu::SHADERTYPE_TESSELLATION_CONTROL;
202 	if (mask & (1u << glu::SHADERTYPE_VERTEX))
203 		return glu::SHADERTYPE_VERTEX;
205 	if (mask & (1u << glu::SHADERTYPE_COMPUTE))
206 		return glu::SHADERTYPE_COMPUTE;
209 	return glu::SHADERTYPE_LAST;
215 	return contextSupports(ctxType, glu::ApiType::es(3, 2)) ||
216 		   contextSupports(ctxType, glu::ApiType::core(4, 5));
221 	const glu::GLSLVersion				glslVersion			= glu::getContextTypeGLSLVersion(context.getRenderContext().getType());
224 	specializationMap["GLSL_VERSION_DECL"] = glu::getGLSLVersionDeclaration(glslVersion);
281 	Shader (const SharedPtr& enclosingNode, glu::ShaderType type, glu::GLSLVersion version)
287 		DE_ASSERT(type < glu::SHADERTYPE_LAST);
290 	const glu::ShaderType	m_type;
291 	const glu::GLSLVersion	m_version;
309 	StorageQualifier (const SharedPtr& enclosing, glu::Storage storage)
317 	const glu::Storage	m_storage;
323 	Variable (const SharedPtr& enclosing, glu::DataType dataType)
336 	const glu::DataType	m_dataType;
405 	LayoutQualifier (const SharedPtr& enclosing, const glu::Layout& layout)
416 	const glu::Layout m_layout;
422 	InterpolationQualifier (const SharedPtr& enclosing, const glu::Interpolation& interpolation)
433 	const glu::Interpolation m_interpolation;
439 				ShaderSet			(const SharedPtr& enclosing, glu::GLSLVersion version);
440 				ShaderSet			(const SharedPtr& enclosing, glu::GLSLVersion version, deUint32 stagesPresentBits, deUint32 stagesReferencingBits);
442 	void		setStage			(glu::ShaderType type, bool referencing);
443 	bool		isStagePresent		(glu::ShaderType stage) const;
444 	bool		isStageReferencing	(glu::ShaderType stage) const;
448 	const glu::GLSLVersion	m_version;
450 	bool		m_stagePresent[glu::SHADERTYPE_LAST];
451 	bool		m_stageReferencing[glu::SHADERTYPE_LAST];
454 ShaderSet::ShaderSet (const SharedPtr& enclosing, glu::GLSLVersion version)
465 					  glu::GLSLVersion	version,
471 	for (deUint32 stageNdx = 0; stageNdx < glu::SHADERTYPE_LAST; ++stageNdx)
484 void ShaderSet::setStage (glu::ShaderType type, bool referencing)
486 	DE_ASSERT(type < glu::SHADERTYPE_LAST);
491 bool ShaderSet::isStagePresent (glu::ShaderType stage) const
493 	DE_ASSERT(stage < glu::SHADERTYPE_LAST);
497 bool ShaderSet::isStageReferencing (glu::ShaderType stage) const
499 	DE_ASSERT(stage < glu::SHADERTYPE_LAST);
506 	for (deUint32 stage = 0; stage < glu::SHADERTYPE_LAST; ++stage)
528 static glu::Precision getDataTypeDefaultPrecision (const glu::DataType& type)
530 	if (glu::isDataTypeBoolOrBVec(type))
531 		return glu::PRECISION_LAST;
532 	else if (glu::isDataTypeScalarOrVector(type) || glu::isDataTypeMatrix(type))
533 		return glu::PRECISION_HIGHP;
534 	else if (glu::isDataTypeSampler(type))
535 		return glu::PRECISION_HIGHP;
536 	else if (glu::isDataTypeImage(type))
537 		return glu::PRECISION_HIGHP;
538 	else if (type == glu::TYPE_UINT_ATOMIC_COUNTER)
539 		return glu::PRECISION_HIGHP;
542 	return glu::PRECISION_LAST;
563 		const glu::DataType							basicType				= static_cast<const ResourceDefinition::Variable*>(resource)->m_dataType;
565 		glu::VariableDeclaration					variable				(glu::VarType(basicType, getDataTypeDefaultPrecision(basicType)), "target");
566 		glu::InterfaceBlock							interfaceBlock;
572 		if (glu::isDataTypeImage(basicType))
574 			variable.memoryAccessQualifierBits |= glu::MEMORYACCESSQUALIFIER_READONLY_BIT;
577 			if (basicType >= glu::TYPE_IMAGE_2D && basicType <= glu::TYPE_IMAGE_3D)
578 				variable.layout.format = glu::FORMATLAYOUT_RGBA8;
579 			else if (basicType >= glu::TYPE_INT_IMAGE_2D && basicType <= glu::TYPE_INT_IMAGE_3D)
580 				variable.layout.format = glu::FORMATLAYOUT_RGBA8I;
581 			else if (basicType >= glu::TYPE_UINT_IMAGE_2D && basicType <= glu::TYPE_UINT_IMAGE_3D)
582 				variable.layout.format = glu::FORMATLAYOUT_RGBA8UI;
588 		if (basicType == glu::TYPE_UINT_ATOMIC_COUNTER)
601 					DE_ASSERT(variable.storage == glu::STORAGE_LAST);
606 					DE_ASSERT(interfaceBlock.storage == glu::STORAGE_LAST);
615 				glu::Layout*								targetLayout	= DE_NULL;
635 				if (qualifier->m_layout.format != glu::FORMATLAYOUT_LAST)
638 				if (qualifier->m_layout.matrixOrder != glu::MATRIXORDER_LAST)
668 					arraySize = glu::VarType::UNSIZED_ARRAY;
673 					variable.varType = glu::VarType(variable.varType, arraySize);
688 				DE_ASSERT(variable.interpolation == glu::INTERPOLATION_LAST);
689 				DE_ASSERT(variable.layout == glu::Layout());
691 				DE_ASSERT(variable.storage == glu::STORAGE_LAST);
694 					glu::StructType* structPtr = new glu::StructType(("StructType" + de::toString(structNdx++)).c_str());
697 					variable = glu::VariableDeclaration(glu::VarType(structPtr), "target");
748 				for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; ++shaderType)
750 					if (shaderDef->isStagePresent((glu::ShaderType)shaderType))
752 						ProgramInterfaceDefinition::Shader* shader = program->addShader((glu::ShaderType)shaderType, shaderDef->m_version);
754 						if (shaderDef->isStageReferencing((glu::ShaderType)shaderType))
826 				for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; ++shaderType)
827 					if (shaderDef->isStagePresent((glu::ShaderType)shaderType))
828 						program->addShader((glu::ShaderType)shaderType, shaderDef->m_version);
865 	if (program->hasStage(glu::SHADERTYPE_GEOMETRY))
867 	if (program->hasStage(glu::SHADERTYPE_TESSELLATION_CONTROL) || program->hasStage(glu::SHADERTYPE_TESSELLATION_EVALUATION))
873 static void checkAndLogProgram (const glu::ShaderProgram& program, const ProgramInterfaceDefinition::Program* programDefinition, const glw::Functions& gl, tcu::TestLog& log)
934 	if ((m_programDefinition->hasStage(glu::SHADERTYPE_TESSELLATION_CONTROL) || m_programDefinition->hasStage(glu::SHADERTYPE_TESSELLATION_EVALUATION)) &&
939 	if (m_programDefinition->hasStage(glu::SHADERTYPE_GEOMETRY) &&
961 	const glu::ShaderProgram program(m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_programDefinition));
1001 	m_testCtx.getLog() << tcu::TestLog::Message << "Querying " << glu::getProgramInterfaceName(programInterface) << " interface:" << tcu::TestLog::EndMessage;
1211 				if (storageDef->m_storage == glu::STORAGE_PATCH_IN ||
1212 					storageDef->m_storage == glu::STORAGE_PATCH_OUT)
1272 		const glu::ShaderType firstStage = getShaderMaskFirstStage(stageBits);
1273 		return	firstStage == glu::SHADERTYPE_TESSELLATION_CONTROL		||
1274 				firstStage == glu::SHADERTYPE_TESSELLATION_EVALUATION	||
1275 				firstStage == glu::SHADERTYPE_GEOMETRY;
1279 		const glu::ShaderType lastStage = getShaderMaskLastStage(stageBits);
1280 		return	lastStage == glu::SHADERTYPE_TESSELLATION_CONTROL;
1362 		return convertGLTypeNameToTestName(glu::getDataTypeName(variable->m_dataType));
1388 				uniformType = std::string(" ") + glu::getStorageName(storageDef->m_storage);
1389 				structureDescriptor << "\n\tdeclared as \"" << glu::getStorageName(storageDef->m_storage) << "\"";
1405 		buf	<< "Querying properties of " << glu::getDataTypeName(varDef->m_dataType) << uniformType << " variable.\n"
1407 			<< "\t" << glu::getDataTypeName(varDef->m_dataType)
1458 	const glu::ShaderProgram	program			(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(specializeShader(m_context, computeSource)));
1584 	const glu::ShaderProgram	program			(m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(specializeShader(m_context, computeSource)));
1670 											InterfaceBlockBaseCase		(Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType);
1678 	const glu::Storage						m_storage;
1683 InterfaceBlockBaseCase::InterfaceBlockBaseCase (Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType)
1689 	DE_ASSERT(storage == glu::STORAGE_UNIFORM || storage == glu::STORAGE_BUFFER);
1699 	const glu::GLSLVersion				glslVersion	= glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
1703 	shader = m_program->addShader(glu::SHADERTYPE_COMPUTE, glslVersion);
1707 		glu::InterfaceBlock precedingInterfaceBlock;
1714 		precedingInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), "precedingMember"));
1717 		if (m_storage == glu::STORAGE_BUFFER)
1718 			precedingInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY), "precedingMemberUnsizedArray"));
1720 			precedingInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), 2), "precedingMemberArray"));
1727 		glu::InterfaceBlock targetInterfaceBlock;
1743 			targetInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), "blockMemberBasic"));
1748 			targetInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), 3), "blockMemberArray"));
1753 			glu::StructType* structPtr = new glu::StructType("StructType");
1754 			structPtr->addMember("structMemberBasic", glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP));
1755 			structPtr->addMember("structMemberArray", glu::VarType(glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), 2));
1757 			targetInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(structPtr), 2), "blockMemberStruct"));
1761 		if (m_storage == glu::STORAGE_BUFFER)
1762 			targetInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY), "blockMemberUnsizedArray"));
1769 		glu::InterfaceBlock trailingInterfaceBlock;
1775 		trailingInterfaceBlock.variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), "trailingMember"));
1792 											InterfaceBlockActiveVariablesTestCase	(Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType);
1798 InterfaceBlockActiveVariablesTestCase::InterfaceBlockActiveVariablesTestCase (Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType)
1805 	const ProgramInterface			programInterface				= (m_storage == glu::STORAGE_UNIFORM) ? (PROGRAMINTERFACE_UNIFORM_BLOCK) :
1806 																	  (m_storage == glu::STORAGE_BUFFER) ? (PROGRAMINTERFACE_SHADER_STORAGE_BLOCK) :
1809 	const glw::GLenum				programMemberInterfaceValue		= (m_storage == glu::STORAGE_UNIFORM) ? (GL_UNIFORM) :
1810 																	  (m_storage == glu::STORAGE_BUFFER) ? (GL_BUFFER_VARIABLE) :
1813 	glu::ShaderProgram				program							(m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program));
1972 			glu::InterfaceBlock*		block		= DE_NULL;
1973 			const std::string			blockName	= glu::parseVariableName(blockNames[blockNdx].c_str());
2060 											InterfaceBlockDataSizeTestCase	(Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType);
2065 	int										getBlockMinDataSize				(const glu::InterfaceBlock& block) const;
2068 InterfaceBlockDataSizeTestCase::InterfaceBlockDataSizeTestCase (Context& context, const char* name, const char* description, glu::Storage storage, CaseType caseType)
2075 	const ProgramInterface			programInterface		= (m_storage == glu::STORAGE_UNIFORM) ? (PROGRAMINTERFACE_UNIFORM_BLOCK) :
2076 															  (m_storage == glu::STORAGE_BUFFER) ? (PROGRAMINTERFACE_SHADER_STORAGE_BLOCK) :
2080 	glu::ShaderProgram				program					(m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program));
2134 	const std::string blockName = glu::parseVariableName(blockFullName.c_str());
2180 	glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
2183 	shader = m_program->addShader(glu::SHADERTYPE_COMPUTE, glslVersion);
2186 		glu::VariableDeclaration decl(glu::VarType(glu::TYPE_UINT_ATOMIC_COUNTER, glu::PRECISION_LAST), "binding1_counter1", glu::STORAGE_UNIFORM);
2191 		glu::VariableDeclaration decl(glu::VarType(glu::TYPE_UINT_ATOMIC_COUNTER, glu::PRECISION_LAST), "binding1_counter2", glu::STORAGE_UNIFORM);
2198 		glu::VariableDeclaration decl(glu::VarType(glu::TYPE_UINT_ATOMIC_COUNTER, glu::PRECISION_LAST), "binding2_counter1", glu::STORAGE_UNIFORM);
2219 			glu::isDataTypeAtomicCounter(m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.getBasicType()))
2236 			glu::isDataTypeAtomicCounter(m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.getBasicType()))
2260 			glu::isDataTypeAtomicCounter(m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.getBasicType()) &&
2276 			glu::isDataTypeAtomicCounter(m_program->getShaders()[0]->getDefaultBlock().variables[ndx].varType.getBasicType()) &&
2305 	const glu::ShaderProgram program(m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program));
2352 	const glu::ShaderProgram	program							(m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program));
2572 	const glu::ShaderProgram	program							(m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program));
2625 	const glu::ShaderProgram	program							(m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program));
2721 	const deUint32				geometryMask		= (1 << glu::SHADERTYPE_GEOMETRY);
2722 	const deUint32				tessellationMask	= (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION);
2723 	glu::VariableDeclaration	atomicVar			(glu::VarType(glu::TYPE_UINT_ATOMIC_COUNTER, glu::PRECISION_LAST), "targetCounter", glu::STORAGE_UNIFORM);
2724 	const glu::GLSLVersion		glslVersion			= glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
2737 	for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; ++shaderType)
2740 			m_program->addShader((glu::ShaderType)shaderType, glslVersion)->getDefaultBlock().variables.push_back(atomicVar);
2742 			m_program->addShader((glu::ShaderType)shaderType, glslVersion);
2745 	if (m_program->hasStage(glu::SHADERTYPE_GEOMETRY))
2747 	if (m_program->hasStage(glu::SHADERTYPE_TESSELLATION_CONTROL) || m_program->hasStage(glu::SHADERTYPE_TESSELLATION_EVALUATION))
2761 	const glu::RenderContext& rc = m_context.getRenderContext();
2762 	const bool isES32orGL45 = glu::contextSupports(rc.getType(), glu::ApiType::es(3, 2)) ||
2763 							  glu::contextSupports(rc.getType(), glu::ApiType::core(4, 5));
2768 		glu::ShaderType	shaderType;
2772 		{ GL_REFERENCED_BY_VERTEX_SHADER,			glu::SHADERTYPE_VERTEX,						DE_NULL												},
2773 		{ GL_REFERENCED_BY_FRAGMENT_SHADER,			glu::SHADERTYPE_FRAGMENT,					DE_NULL												},
2774 		{ GL_REFERENCED_BY_COMPUTE_SHADER,			glu::SHADERTYPE_COMPUTE,					DE_NULL												},
2775 		{ GL_REFERENCED_BY_TESS_CONTROL_SHADER,		glu::SHADERTYPE_TESSELLATION_CONTROL,		(isES32orGL45 ? DE_NULL : "GL_EXT_tessellation_shader")	},
2776 		{ GL_REFERENCED_BY_TESS_EVALUATION_SHADER,	glu::SHADERTYPE_TESSELLATION_EVALUATION,	(isES32orGL45 ? DE_NULL : "GL_EXT_tessellation_shader")	},
2777 		{ GL_REFERENCED_BY_GEOMETRY_SHADER,			glu::SHADERTYPE_GEOMETRY,					(isES32orGL45 ? DE_NULL : "GL_EXT_geometry_shader")		},
2781 	const glu::ShaderProgram	program		(rc, generateProgramInterfaceProgramSources(m_program));
2796 			m_testCtx.getLog() << tcu::TestLog::Message << "Verifying " << glu::getProgramResourcePropertyName(prop) << ", expecting " << glu::getBooleanName(expected) << tcu::TestLog::EndMessage;
2808 			m_testCtx.getLog() << tcu::TestLog::Message << glu::getProgramResourcePropertyName(prop) << " = " << glu::getBooleanStr(value) << tcu::TestLog::EndMessage;
2840 											ProgramInputOutputReferencedByCase	(Context& context, const char* name, const char* description, glu::Storage targetStorage, CaseType caseType);
2849 	const glu::Storage						m_targetStorage;
2853 ProgramInputOutputReferencedByCase::ProgramInputOutputReferencedByCase (Context& context, const char* name, const char* description, glu::Storage targetStorage, CaseType caseType)
2883 	glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
2892 		const bool						isInputCase			= (m_targetStorage == glu::STORAGE_IN || m_targetStorage == glu::STORAGE_PATCH_IN);
2893 		const bool						perPatchStorage		= (m_targetStorage == glu::STORAGE_PATCH_IN || m_targetStorage == glu::STORAGE_PATCH_OUT);
2895 		const glu::VariableDeclaration	targetDecl			(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), varName, m_targetStorage);
2896 		const glu::ShaderType			shaderType			= (m_caseType == CASE_SEPARABLE_VERTEX)		? (glu::SHADERTYPE_VERTEX)
2897 															: (m_caseType == CASE_SEPARABLE_FRAGMENT)	? (glu::SHADERTYPE_FRAGMENT)
2898 															: (m_caseType == CASE_SEPARABLE_GEOMETRY)	? (glu::SHADERTYPE_GEOMETRY)
2899 															: (m_caseType == CASE_SEPARABLE_TESS_CTRL)	? (glu::SHADERTYPE_TESSELLATION_CONTROL)
2900 															: (m_caseType == CASE_SEPARABLE_TESS_EVAL)	? (glu::SHADERTYPE_TESSELLATION_EVALUATION)
2901 															:											  (glu::SHADERTYPE_LAST);
2902 		const bool						arrayedInterface	= (isInputCase) ? ((shaderType == glu::SHADERTYPE_GEOMETRY)					||
2903 																			   (shaderType == glu::SHADERTYPE_TESSELLATION_CONTROL)		||
2904 																			   (shaderType == glu::SHADERTYPE_TESSELLATION_EVALUATION))
2905 																			: (shaderType == glu::SHADERTYPE_TESSELLATION_CONTROL);
2911 			const glu::VariableDeclaration targetDeclArr(glu::VarType(targetDecl.varType, glu::VarType::UNSIZED_ARRAY), varName, m_targetStorage);
2924 		ProgramInterfaceDefinition::Shader*	vertex		= m_program->addShader(glu::SHADERTYPE_VERTEX, glslVersion);
2925 		ProgramInterfaceDefinition::Shader*	fragment	= m_program->addShader(glu::SHADERTYPE_FRAGMENT, glslVersion);
2929 		vertex->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP),
2931 																			   glu::STORAGE_IN));
2932 		vertex->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP),
2934 																			   glu::STORAGE_OUT,
2935 																			   glu::INTERPOLATION_LAST,
2936 																			   glu::Layout(1)));
2938 		fragment->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP),
2940 																				 glu::STORAGE_OUT,
2941 																				 glu::INTERPOLATION_LAST,
2942 																				 glu::Layout(0)));
2943 		fragment->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP),
2945 																				 glu::STORAGE_IN,
2946 																				 glu::INTERPOLATION_LAST,
2947 																				 glu::Layout(1)));
2951 			ProgramInterfaceDefinition::Shader* tessCtrl = m_program->addShader(glu::SHADERTYPE_TESSELLATION_CONTROL, glslVersion);
2952 			ProgramInterfaceDefinition::Shader* tessEval = m_program->addShader(glu::SHADERTYPE_TESSELLATION_EVALUATION, glslVersion);
2954 			tessCtrl->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY),
2956 																					 glu::STORAGE_IN,
2957 																					 glu::INTERPOLATION_LAST,
2958 																					 glu::Layout(1)));
2959 			tessCtrl->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY),
2961 																					 glu::STORAGE_OUT,
2962 																					 glu::INTERPOLATION_LAST,
2963 																					 glu::Layout(1)));
2965 			tessEval->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY),
2967 																					 glu::STORAGE_IN,
2968 																					 glu::INTERPOLATION_LAST,
2969 																					 glu::Layout(1)));
2970 			tessEval->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP),
2972 																					 glu::STORAGE_OUT,
2973 																					 glu::INTERPOLATION_LAST,
2974 																					 glu::Layout(1)));
2979 			ProgramInterfaceDefinition::Shader* geometry = m_program->addShader(glu::SHADERTYPE_GEOMETRY, glslVersion);
2981 			geometry->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY),
2983 																					 glu::STORAGE_IN,
2984 																					 glu::INTERPOLATION_LAST,
2985 																					 glu::Layout(1)));
2986 			geometry->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP),
2988 																					 glu::STORAGE_OUT,
2989 																					 glu::INTERPOLATION_LAST,
2990 																					 glu::Layout(1)));
2996 	if (m_program->hasStage(glu::SHADERTYPE_GEOMETRY))
2998 	if (m_program->hasStage(glu::SHADERTYPE_TESSELLATION_CONTROL) || m_program->hasStage(glu::SHADERTYPE_TESSELLATION_EVALUATION))
3015 		glu::ShaderType	shaderType;
3019 		{ GL_REFERENCED_BY_VERTEX_SHADER,			glu::SHADERTYPE_VERTEX,						DE_NULL							},
3020 		{ GL_REFERENCED_BY_FRAGMENT_SHADER,			glu::SHADERTYPE_FRAGMENT,					DE_NULL							},
3021 		{ GL_REFERENCED_BY_COMPUTE_SHADER,			glu::SHADERTYPE_COMPUTE,					DE_NULL							},
3022 		{ GL_REFERENCED_BY_TESS_CONTROL_SHADER,		glu::SHADERTYPE_TESSELLATION_CONTROL,		"GL_EXT_tessellation_shader"	},
3023 		{ GL_REFERENCED_BY_TESS_EVALUATION_SHADER,	glu::SHADERTYPE_TESSELLATION_EVALUATION,	"GL_EXT_tessellation_shader"	},
3024 		{ GL_REFERENCED_BY_GEOMETRY_SHADER,			glu::SHADERTYPE_GEOMETRY,					"GL_EXT_geometry_shader"		},
3027 	const bool					isInputCase						= (m_targetStorage == glu::STORAGE_IN || m_targetStorage == glu::STORAGE_PATCH_IN);
3029 	const glu::ShaderProgram	program							(m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_program));
3059 			m_testCtx.getLog() << tcu::TestLog::Message << "Verifying " << glu::getProgramResourcePropertyName(prop) << ", expecting " << ((expected) ? ("TRUE") : ("FALSE")) << tcu::TestLog::EndMessage;
3071 			m_testCtx.getLog() << tcu::TestLog::Message << glu::getProgramResourcePropertyName(prop) << " = " << glu::getBooleanStr(value) << tcu::TestLog::EndMessage;
3107 	const glu::ShaderProgram program(m_context.getRenderContext(), generateProgramInterfaceProgramSources(m_programDefinition));
3153 int InterfaceBlockDataSizeTestCase::getBlockMinDataSize (const glu::InterfaceBlock& block) const
3163 static bool isDataTypeLayoutQualified (glu::DataType type)
3165 	return glu::isDataTypeImage(type) || glu::isDataTypeAtomicCounter(type);
3173 		glu::DataType	dataType;
3176 		{ 0,	glu::TYPE_FLOAT			},
3177 		{ 1,	glu::TYPE_INT			},
3178 		{ 1,	glu::TYPE_UINT			},
3179 		{ 1,	glu::TYPE_BOOL			},
3181 		{ 3,	glu::TYPE_FLOAT_VEC2	},
3182 		{ 1,	glu::TYPE_FLOAT_VEC3	},
3183 		{ 1,	glu::TYPE_FLOAT_VEC4	},
3185 		{ 3,	glu::TYPE_INT_VEC2		},
3186 		{ 2,	glu::TYPE_INT_VEC3		},
3187 		{ 3,	glu::TYPE_INT_VEC4		},
3189 		{ 3,	glu::TYPE_UINT_VEC2		},
3190 		{ 2,	glu::TYPE_UINT_VEC3		},
3191 		{ 3,	glu::TYPE_UINT_VEC4		},
3193 		{ 3,	glu::TYPE_BOOL_VEC2		},
3194 		{ 2,	glu::TYPE_BOOL_VEC3		},
3195 		{ 3,	glu::TYPE_BOOL_VEC4		},
3197 		{ 2,	glu::TYPE_FLOAT_MAT2	},
3198 		{ 3,	glu::TYPE_FLOAT_MAT2X3	},
3199 		{ 3,	glu::TYPE_FLOAT_MAT2X4	},
3200 		{ 2,	glu::TYPE_FLOAT_MAT3X2	},
3201 		{ 2,	glu::TYPE_FLOAT_MAT3	},
3202 		{ 3,	glu::TYPE_FLOAT_MAT3X4	},
3203 		{ 2,	glu::TYPE_FLOAT_MAT4X2	},
3204 		{ 3,	glu::TYPE_FLOAT_MAT4X3	},
3205 		{ 2,	glu::TYPE_FLOAT_MAT4	},
3233 		glu::DataType	dataType;
3236 		{ 0,	glu::TYPE_SAMPLER_2D					},
3237 		{ 2,	glu::TYPE_SAMPLER_CUBE					},
3238 		{ 1,	glu::TYPE_SAMPLER_2D_ARRAY				},
3239 		{ 1,	glu::TYPE_SAMPLER_3D					},
3240 		{ 2,	glu::TYPE_SAMPLER_2D_SHADOW				},
3241 		{ 3,	glu::TYPE_SAMPLER_CUBE_SHADOW			},
3242 		{ 3,	glu::TYPE_SAMPLER_2D_ARRAY_SHADOW		},
3243 		{ 1,	glu::TYPE_INT_SAMPLER_2D				},
3244 		{ 3,	glu::TYPE_INT_SAMPLER_CUBE				},
3245 		{ 3,	glu::TYPE_INT_SAMPLER_2D_ARRAY			},
3246 		{ 3,	glu::TYPE_INT_SAMPLER_3D				},
3247 		{ 2,	glu::TYPE_UINT_SAMPLER_2D				},
3248 		{ 3,	glu::TYPE_UINT_SAMPLER_CUBE				},
3249 		{ 3,	glu::TYPE_UINT_SAMPLER_2D_ARRAY			},
3250 		{ 3,	glu::TYPE_UINT_SAMPLER_3D				},
3251 		{ 2,	glu::TYPE_SAMPLER_2D_MULTISAMPLE		},
3252 		{ 2,	glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE	},
3253 		{ 3,	glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE	},
3254 		{ 1,	glu::TYPE_IMAGE_2D						},
3255 		{ 3,	glu::TYPE_IMAGE_CUBE					},
3256 		{ 3,	glu::TYPE_IMAGE_2D_ARRAY				},
3257 		{ 3,	glu::TYPE_IMAGE_3D						},
3258 		{ 3,	glu::TYPE_INT_IMAGE_2D					},
3259 		{ 3,	glu::TYPE_INT_IMAGE_CUBE				},
3260 		{ 1,	glu::TYPE_INT_IMAGE_2D_ARRAY			},
3261 		{ 3,	glu::TYPE_INT_IMAGE_3D					},
3262 		{ 2,	glu::TYPE_UINT_IMAGE_2D					},
3263 		{ 3,	glu::TYPE_UINT_IMAGE_CUBE				},
3264 		{ 3,	glu::TYPE_UINT_IMAGE_2D_ARRAY			},
3265 		{ 3,	glu::TYPE_UINT_IMAGE_3D					},
3266 		{ 1,	glu::TYPE_UINT_ATOMIC_COUNTER			},
3373 	const ResourceDefinition::Node::SharedPtr uniform		(new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_UNIFORM));
3423 		const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(parentStructure, glu::TYPE_FLOAT_VEC4));
3442 static void generateBufferBackedVariableAggregateTypeCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, ProgramInterface interface, ProgramResourcePropFlags targetProp, glu::DataType dataType, const std::string& nameSuffix, int depth)
3494 			generateBufferBackedVariableAggregateTypeCases(context, parentStructure, blockGroup, queryTarget.interface, PROGRAMRESOURCEPROP_ARRAY_SIZE, glu::TYPE_FLOAT, "", 3);
3500 		generateBufferBackedVariableAggregateTypeCases(context, parentStructure, targetGroup, queryTarget.interface, PROGRAMRESOURCEPROP_ARRAY_SIZE, glu::TYPE_FLOAT, "", 2);
3504 static void generateBufferBackedArrayStrideTypeAggregateSubCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, const std::string& namePrefix, ProgramInterface interface, glu::DataType type, int expandLevel)
3525 static void generateBufferBackedArrayStrideTypeAggregateCases (Context& context, const ResourceDefinition::Node::SharedPtr& parentStructure, tcu::TestCaseGroup* const targetGroup, ProgramInterface interface, glu::DataType type, int expandLevel, bool includeBaseCase)
3529 	const std::string							namePrefix		= glu::getDataTypeName(type);
3539 		if (!glu::isDataTypeAtomicCounter(type))
3573 				generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_SAMPLER_2D, 1, false);
3578 				const ResourceDefinition::Node::SharedPtr layout(new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, 0)));
3579 				generateBufferBackedArrayStrideTypeAggregateCases(context, layout, blockGroup, queryTarget.interface, glu::TYPE_UINT_ATOMIC_COUNTER, 1, false);
3583 			generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_FLOAT, 2, false);
3586 			generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_BOOL, 1, false);
3589 			generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_BOOL_VEC3, 2, false);
3592 			generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_FLOAT_VEC3, 2, false);
3595 			generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, blockGroup, queryTarget.interface, glu::TYPE_INT_VEC3, 2, false);
3622 static void generateUniformBlockBlockIndexContents (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion)
3625 	const ResourceDefinition::Node::SharedPtr	shader			(new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
3627 	const ResourceDefinition::Node::SharedPtr	uniform			(new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_UNIFORM));
3628 	const ResourceDefinition::Node::SharedPtr	binding			(new ResourceDefinition::LayoutQualifier(uniform, glu::Layout(-1, 0)));
3632 		const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(uniform, glu::TYPE_FLOAT_VEC4));
3640 		const ResourceDefinition::Node::SharedPtr	variable	(new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4));
3648 		const ResourceDefinition::Node::SharedPtr	variable	(new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4));
3657 		const ResourceDefinition::Node::SharedPtr	variable		(new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4));
3677 			const ResourceDefinition::Node::SharedPtr	variable			(new ResourceDefinition::Variable(arrayElement, glu::TYPE_UINT_ATOMIC_COUNTER));
3678 			const ResourceDefinition::Node::SharedPtr	elementvariable		(new ResourceDefinition::Variable(arrayArrayElement, glu::TYPE_UINT_ATOMIC_COUNTER));
3699 		generateBufferBackedVariableAggregateTypeCases(context, parentStructure, targetGroup, PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_NAME_LENGTH, glu::TYPE_FLOAT, "", 2);
3701 		generateBufferBackedVariableAggregateTypeCases(context, parentStructure, targetGroup, PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_NAME_LENGTH, glu::TYPE_FLOAT, "", 1);
3762 				const ResourceDefinition::Node::SharedPtr offset			(new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, -1, 4)));
3764 				const ResourceDefinition::Node::SharedPtr elementVariable	(new ResourceDefinition::Variable(arrayElement, glu::TYPE_UINT_ATOMIC_COUNTER));
3774 				const ResourceDefinition::Node::SharedPtr memberVariable	(new ResourceDefinition::Variable(structMember, glu::TYPE_FLOAT));
3775 				const ResourceDefinition::Node::SharedPtr elementVariable	(new ResourceDefinition::Variable(arrayElement, glu::TYPE_FLOAT));
3803 				const ResourceDefinition::Node::SharedPtr memberVariable	(new ResourceDefinition::Variable(structMember, glu::TYPE_FLOAT));
3804 				const ResourceDefinition::Node::SharedPtr elementVariable	(new ResourceDefinition::Variable(arrayElement, glu::TYPE_FLOAT));
3824 		glu::DataType	type;
3827 		{ 0,	glu::TYPE_FLOAT_MAT2	},
3828 		{ 1,	glu::TYPE_FLOAT_MAT2X3	},
3829 		{ 2,	glu::TYPE_FLOAT_MAT2X4	},
3830 		{ 2,	glu::TYPE_FLOAT_MAT3X2	},
3831 		{ 1,	glu::TYPE_FLOAT_MAT3	},
3832 		{ 0,	glu::TYPE_FLOAT_MAT3X4	},
3833 		{ 2,	glu::TYPE_FLOAT_MAT4X2	},
3834 		{ 1,	glu::TYPE_FLOAT_MAT4X3	},
3835 		{ 0,	glu::TYPE_FLOAT_MAT4	},
3906 		glu::MatrixOrder	order;
3909 		{ "no_qualifier",	glu::MATRIXORDER_LAST			},
3910 		{ "row_major",		glu::MATRIXORDER_ROW_MAJOR		},
3911 		{ "column_major",	glu::MATRIXORDER_COLUMN_MAJOR	},
3919 		if (qualifiers[qualifierNdx].order == glu::MATRIXORDER_LAST || parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK)
3926 			if (qualifiers[qualifierNdx].order != glu::MATRIXORDER_LAST)
3928 				glu::Layout layout;
3933 			if (extendedBasicTypeCases && qualifiers[qualifierNdx].order == glu::MATRIXORDER_LAST)
3951 					generateBufferBackedVariableAggregateTypeCases(context, subStructure, blockGroup, queryTarget.interface, PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR, glu::TYPE_FLOAT_MAT3X2, "", 1);
3956 				generateBufferBackedVariableAggregateTypeCases(context, subStructure, qualifierGroup, queryTarget.interface, PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR, glu::TYPE_FLOAT_MAT3X2, "", 1);
3967 		glu::MatrixOrder	order;
3970 		{ "no_qualifier",	glu::MATRIXORDER_LAST			},
3971 		{ "row_major",		glu::MATRIXORDER_ROW_MAJOR		},
3972 		{ "column_major",	glu::MATRIXORDER_COLUMN_MAJOR	},
3980 		if (qualifiers[qualifierNdx].order == glu::MATRIXORDER_LAST || parentStructure->getType() == ResourceDefinition::Node::TYPE_INTERFACE_BLOCK)
3987 			if (qualifiers[qualifierNdx].order != glu::MATRIXORDER_LAST)
3989 				glu::Layout layout;
3998 				if (qualifiers[qualifierNdx].order == glu::MATRIXORDER_LAST)
4016 					generateBufferBackedVariableAggregateTypeCases(context, subStructure, blockGroup, queryTarget.interface, PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR, glu::TYPE_FLOAT_MAT3X2, "", 1);
4020 				generateBufferBackedVariableAggregateTypeCases(context, subStructure, qualifierGroup, queryTarget.interface, PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR, glu::TYPE_FLOAT_MAT3X2, "", 1);
4034 		glu::MatrixOrder	order;
4037 		{ "default_block",				"Default block",			false,	true,	true,	glu::MATRIXORDER_LAST			},
4038 		{ "named_block",				"Named uniform block",		true,	true,	true,	glu::MATRIXORDER_LAST			},
4039 		{ "named_block_row_major",		"Named uniform block",		true,	true,	false,	glu::MATRIXORDER_ROW_MAJOR		},
4040 		{ "named_block_col_major",		"Named uniform block",		true,	true,	false,	glu::MATRIXORDER_COLUMN_MAJOR	},
4041 		{ "unnamed_block",				"Unnamed uniform block",	true,	false,	false,	glu::MATRIXORDER_LAST			},
4042 		{ "unnamed_block_row_major",	"Unnamed uniform block",	true,	false,	false,	glu::MATRIXORDER_ROW_MAJOR		},
4043 		{ "unnamed_block_col_major",	"Unnamed uniform block",	true,	false,	false,	glu::MATRIXORDER_COLUMN_MAJOR	},
4047 	const ResourceDefinition::Node::SharedPtr uniform		(new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_UNIFORM));
4057 		if (children[childNdx].order != glu::MATRIXORDER_LAST)
4059 			glu::Layout layout;
4079 		const ResourceDefinition::Node::SharedPtr	variable		(new ResourceDefinition::Variable(parentStructure, glu::TYPE_FLOAT));
4082 		const ResourceDefinition::Node::SharedPtr	variableArray	(new ResourceDefinition::Variable(arrayElement, glu::TYPE_FLOAT));
4083 		const ResourceDefinition::Node::SharedPtr	variableStruct	(new ResourceDefinition::Variable(structMember, glu::TYPE_FLOAT));
4095 		const ResourceDefinition::Node::SharedPtr	layout			(new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, 0)));
4096 		const ResourceDefinition::Node::SharedPtr	variable		(new ResourceDefinition::Variable(layout, glu::TYPE_SAMPLER_2D));
4099 		const ResourceDefinition::Node::SharedPtr	variableArray	(new ResourceDefinition::Variable(arrayElement, glu::TYPE_SAMPLER_2D));
4100 		const ResourceDefinition::Node::SharedPtr	variableStruct	(new ResourceDefinition::Variable(structMember, glu::TYPE_SAMPLER_2D));
4111 		const ResourceDefinition::Node::SharedPtr	layout			(new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, 0)));
4112 		const ResourceDefinition::Node::SharedPtr	variable		(new ResourceDefinition::Variable(layout, glu::TYPE_UINT_ATOMIC_COUNTER));
4114 		const ResourceDefinition::Node::SharedPtr	variableArray	(new ResourceDefinition::Variable(arrayElement, glu::TYPE_UINT_ATOMIC_COUNTER));
4126 			const ResourceDefinition::Node::SharedPtr	variableArrayStruct	(new ResourceDefinition::Variable(arrayElement, glu::TYPE_FLOAT));
4135 			const ResourceDefinition::Node::SharedPtr	variableArrayStruct	(new ResourceDefinition::Variable(arrayStructMember, glu::TYPE_FLOAT));
4144 			const ResourceDefinition::Node::SharedPtr	variableArrayStruct	(new ResourceDefinition::Variable(subArrayElement, glu::TYPE_FLOAT));
4153 			const ResourceDefinition::Node::SharedPtr	variableArrayStruct	(new ResourceDefinition::Variable(subStructMember, glu::TYPE_FLOAT));
4164 				const ResourceDefinition::Node::SharedPtr	variableArray	(new ResourceDefinition::Variable(arrayElement, glu::TYPE_FLOAT));
4172 				const ResourceDefinition::Node::SharedPtr	variableArray	(new ResourceDefinition::Variable(structMember, glu::TYPE_FLOAT));
4185 	const ResourceDefinition::Node::SharedPtr	uniform				(new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_UNIFORM));
4229 static void generateReferencedByShaderCaseBlocks (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion, void (*generateBlockContent)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, int expandLevel))
4234 		glu::ShaderType	stage;
4238 		{ "compute",				glu::SHADERTYPE_COMPUTE,					3	},
4239 		{ "separable_vertex",		glu::SHADERTYPE_VERTEX,						2	},
4240 		{ "separable_fragment",		glu::SHADERTYPE_FRAGMENT,					2	},
4241 		{ "separable_tess_ctrl",	glu::SHADERTYPE_TESSELLATION_CONTROL,		2	},
4242 		{ "separable_tess_eval",	glu::SHADERTYPE_TESSELLATION_EVALUATION,	2	},
4243 		{ "separable_geometry",		glu::SHADERTYPE_GEOMETRY,					2	},
4255 			(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT),
4261 			(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION),
4267 			(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_GEOMETRY),
4273 			(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION) | (1 << glu::SHADERTYPE_GEOMETRY),
4282 		const bool									programSeparable	= (singleStageCases[ndx].stage != glu::SHADERTYPE_COMPUTE);
4310 		for (int selectedStageBit = 0; selectedStageBit < glu::SHADERTYPE_LAST; ++selectedStageBit)
4319 				const char*									stageName	= (selectedStageBit == glu::SHADERTYPE_VERTEX)					? ("vertex")
4320 																		: (selectedStageBit == glu::SHADERTYPE_FRAGMENT)				? ("fragment")
4321 																		: (selectedStageBit == glu::SHADERTYPE_GEOMETRY)				? ("geo")
4322 																		: (selectedStageBit == glu::SHADERTYPE_TESSELLATION_CONTROL)	? ("tess_ctrl")
4323 																		: (selectedStageBit == glu::SHADERTYPE_TESSELLATION_EVALUATION)	? ("tess_eval")
4336 static glu::DataType generateRandomDataType (de::Random& rnd, bool excludeOpaqueTypes)
4338 	static const glu::DataType s_types[] =
4340 		glu::TYPE_FLOAT,
4341 		glu::TYPE_INT,
4342 		glu::TYPE_UINT,
4343 		glu::TYPE_BOOL,
4344 		glu::TYPE_FLOAT_VEC2,
4345 		glu::TYPE_FLOAT_VEC3,
4346 		glu::TYPE_FLOAT_VEC4,
4347 		glu::TYPE_INT_VEC2,
4348 		glu::TYPE_INT_VEC3,
4349 		glu::TYPE_INT_VEC4,
4350 		glu::TYPE_UINT_VEC2,
4351 		glu::TYPE_UINT_VEC3,
4352 		glu::TYPE_UINT_VEC4,
4353 		glu::TYPE_BOOL_VEC2,
4354 		glu::TYPE_BOOL_VEC3,
4355 		glu::TYPE_BOOL_VEC4,
4356 		glu::TYPE_FLOAT_MAT2,
4357 		glu::TYPE_FLOAT_MAT2X3,
4358 		glu::TYPE_FLOAT_MAT2X4,
4359 		glu::TYPE_FLOAT_MAT3X2,
4360 		glu::TYPE_FLOAT_MAT3,
4361 		glu::TYPE_FLOAT_MAT3X4,
4362 		glu::TYPE_FLOAT_MAT4X2,
4363 		glu::TYPE_FLOAT_MAT4X3,
4364 		glu::TYPE_FLOAT_MAT4,
4366 		glu::TYPE_SAMPLER_2D,
4367 		glu::TYPE_SAMPLER_CUBE,
4368 		glu::TYPE_SAMPLER_2D_ARRAY,
4369 		glu::TYPE_SAMPLER_3D,
4370 		glu::TYPE_SAMPLER_2D_SHADOW,
4371 		glu::TYPE_SAMPLER_CUBE_SHADOW,
4372 		glu::TYPE_SAMPLER_2D_ARRAY_SHADOW,
4373 		glu::TYPE_INT_SAMPLER_2D,
4374 		glu::TYPE_INT_SAMPLER_CUBE,
4375 		glu::TYPE_INT_SAMPLER_2D_ARRAY,
4376 		glu::TYPE_INT_SAMPLER_3D,
4377 		glu::TYPE_UINT_SAMPLER_2D,
4378 		glu::TYPE_UINT_SAMPLER_CUBE,
4379 		glu::TYPE_UINT_SAMPLER_2D_ARRAY,
4380 		glu::TYPE_UINT_SAMPLER_3D,
4381 		glu::TYPE_SAMPLER_2D_MULTISAMPLE,
4382 		glu::TYPE_INT_SAMPLER_2D_MULTISAMPLE,
4383 		glu::TYPE_UINT_SAMPLER_2D_MULTISAMPLE,
4384 		glu::TYPE_IMAGE_2D,
4385 		glu::TYPE_IMAGE_CUBE,
4386 		glu::TYPE_IMAGE_2D_ARRAY,
4387 		glu::TYPE_IMAGE_3D,
4388 		glu::TYPE_INT_IMAGE_2D,
4389 		glu::TYPE_INT_IMAGE_CUBE,
4390 		glu::TYPE_INT_IMAGE_2D_ARRAY,
4391 		glu::TYPE_INT_IMAGE_3D,
4392 		glu::TYPE_UINT_IMAGE_2D,
4393 		glu::TYPE_UINT_IMAGE_CUBE,
4394 		glu::TYPE_UINT_IMAGE_2D_ARRAY,
4395 		glu::TYPE_UINT_IMAGE_3D,
4396 		glu::TYPE_UINT_ATOMIC_COUNTER
4401 		const glu::DataType type = s_types[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_types)-1)];
4404 			glu::isDataTypeScalarOrVector(type)	||
4405 			glu::isDataTypeMatrix(type))
4412 																			 glu::DataType								baseType,
4413 																			 const glu::Layout&							layout,
4435 static ResourceDefinition::Node::SharedPtr generateRandomCoreShaderSet (de::Random& rnd, glu::GLSLVersion glslVersion)
4441 		return ResourceDefinition::Node::SharedPtr(new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
4451 			shaderSet->setStage(glu::SHADERTYPE_VERTEX, true);
4452 			shaderSet->setStage(glu::SHADERTYPE_FRAGMENT, rnd.getBool());
4456 			shaderSet->setStage(glu::SHADERTYPE_VERTEX, rnd.getBool());
4457 			shaderSet->setStage(glu::SHADERTYPE_FRAGMENT, true);
4466 		const glu::ShaderType						shaderType	= (rnd.getBool()) ? (glu::SHADERTYPE_VERTEX) : (glu::SHADERTYPE_FRAGMENT);
4472 static ResourceDefinition::Node::SharedPtr generateRandomExtShaderSet (de::Random& rnd, glu::GLSLVersion glslVersion)
4480 		shaderSet->setStage(glu::SHADERTYPE_VERTEX, rnd.getBool());
4481 		shaderSet->setStage(glu::SHADERTYPE_FRAGMENT, rnd.getBool());
4487 			shaderSet->setStage(glu::SHADERTYPE_GEOMETRY, true);
4491 				shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_CONTROL, rnd.getBool());
4492 				shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_EVALUATION, rnd.getBool());
4497 			shaderSet->setStage(glu::SHADERTYPE_GEOMETRY, rnd.getBool());
4501 				shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_CONTROL, true);
4502 				shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_EVALUATION, rnd.getBool());
4506 				shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_CONTROL, rnd.getBool());
4507 				shaderSet->setStage(glu::SHADERTYPE_TESSELLATION_EVALUATION, true);
4518 		const glu::ShaderType						shaderType	= (selector == 0) ? (glu::SHADERTYPE_GEOMETRY)
4519 																: (selector == 1) ? (glu::SHADERTYPE_TESSELLATION_CONTROL)
4520 																: (selector == 2) ? (glu::SHADERTYPE_TESSELLATION_EVALUATION)
4521 																:					(glu::SHADERTYPE_LAST);
4527 static ResourceDefinition::Node::SharedPtr generateRandomShaderSet (de::Random& rnd, glu::GLSLVersion glslVersion, bool onlyExtensionStages)
4535 static glu::Layout generateRandomUniformBlockLayout (de::Random& rnd)
4537 	glu::Layout layout;
4543 		layout.matrixOrder = (rnd.getBool()) ? (glu::MATRIXORDER_COLUMN_MAJOR) : (glu::MATRIXORDER_ROW_MAJOR);
4548 static glu::Layout generateRandomBufferBlockLayout (de::Random& rnd)
4553 static glu::Layout generateRandomVariableLayout (de::Random& rnd, glu::DataType type, bool interfaceBlockMember)
4555 	glu::Layout layout;
4557 	if ((glu::isDataTypeAtomicCounter(type) || glu::isDataTypeImage(type) || glu::isDataTypeSampler(type)) && rnd.getBool())
4560 	if (glu::isDataTypeAtomicCounter(type) && rnd.getBool())
4563 	if (glu::isDataTypeMatrix(type) && interfaceBlockMember && rnd.getBool())
4564 		layout.matrixOrder = (rnd.getBool()) ? (glu::MATRIXORDER_COLUMN_MAJOR) : (glu::MATRIXORDER_ROW_MAJOR);
4569 static void generateUniformRandomCase (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion, int index, bool onlyExtensionStages)
4574 	const glu::DataType							type				= generateRandomDataType(rnd, interfaceBlock);
4575 	const glu::Layout							layout				= generateRandomVariableLayout(rnd, type, interfaceBlock);
4577 	const ResourceDefinition::Node::SharedPtr	uniform				(new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_UNIFORM));
4598 static void generateUniformCaseRandomCases (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion)
4623 	glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
4625 	const ResourceDefinition::Node::SharedPtr	computeShader	(new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
4729 static void generateBufferBackedInterfaceResourceBasicBlockTypes (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion, glu::Storage storage, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup* const, ProgramInterface interface, const char* blockName))
4732 	const ResourceDefinition::Node::SharedPtr	shader				(new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
4735 	const ResourceDefinition::Node::SharedPtr	binding				(new ResourceDefinition::LayoutQualifier(storageQualifier, glu::Layout(-1, 1)));
4736 	const ProgramInterface						programInterface	= (storage == glu::STORAGE_UNIFORM) ? (PROGRAMINTERFACE_UNIFORM_BLOCK) : (PROGRAMINTERFACE_SHADER_STORAGE_BLOCK);
4741 		const ResourceDefinition::Node::SharedPtr unusedVariable(new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
4749 		const ResourceDefinition::Node::SharedPtr unusedVariable(new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
4758 		const ResourceDefinition::Node::SharedPtr unusedVariable(new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
4767 		const ResourceDefinition::Node::SharedPtr unusedVariable(new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
4773 static void generateBufferBackedInterfaceResourceBufferBindingCases (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion, glu::Storage storage)
4776 	const ResourceDefinition::Node::SharedPtr	shader				(new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
4785 		const ResourceDefinition::Node::SharedPtr	binding				(new ResourceDefinition::LayoutQualifier(storageQualifier, glu::Layout(-1, bindingNdx)));
4786 		const ProgramInterface						programInterface	= (storage == glu::STORAGE_UNIFORM) ? (PROGRAMINTERFACE_UNIFORM_BLOCK) : (PROGRAMINTERFACE_SHADER_STORAGE_BLOCK);
4791 			const ResourceDefinition::Node::SharedPtr unusedVariable(new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
4799 			const ResourceDefinition::Node::SharedPtr unusedVariable(new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
4808 			const ResourceDefinition::Node::SharedPtr unusedVariable(new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
4815 template <glu::Storage Storage>
4818 	const ProgramInterface						programInterface	= (Storage == glu::STORAGE_UNIFORM) ? (PROGRAMINTERFACE_UNIFORM_BLOCK) :
4819 																      (Storage == glu::STORAGE_BUFFER) ? (PROGRAMINTERFACE_SHADER_STORAGE_BLOCK) :
4831 		const ResourceDefinition::Node::SharedPtr unusedVariable(new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
4839 		const ResourceDefinition::Node::SharedPtr unusedVariable(new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
4848 		const ResourceDefinition::Node::SharedPtr unusedVariable(new ResourceDefinition::Variable(block, glu::TYPE_BOOL_VEC3));
4854 static void generateBufferBackedInterfaceResourceActiveVariablesCase (Context& context, tcu::TestCaseGroup* targetGroup, glu::Storage storage)
4861 static void generateBufferBackedInterfaceResourceBufferDataSizeCases (Context& context, tcu::TestCaseGroup* targetGroup, glu::Storage storage)
4871 						BufferBackedBlockInterfaceTestGroup	(Context& context, glu::Storage interfaceBlockStorage);
4875 	static const char*	getGroupName						(glu::Storage storage);
4876 	static const char*	getGroupDescription					(glu::Storage storage);
4878 	const glu::Storage	m_storage;
4881 BufferBackedBlockInterfaceTestGroup::BufferBackedBlockInterfaceTestGroup(Context& context, glu::Storage storage)
4885 	DE_ASSERT(storage == glu::STORAGE_BUFFER || storage == glu::STORAGE_UNIFORM);
4890 	const glu::GLSLVersion	glslVersion	= glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
4932 		if (m_storage == glu::STORAGE_UNIFORM)
4933 			generateReferencedByShaderCaseBlocks(m_context, blockGroup, glslVersion, generateBufferBlockReferencedByShaderSingleBlockContentCases<glu::STORAGE_UNIFORM>);
4934 		else if (m_storage == glu::STORAGE_BUFFER)
4935 			generateReferencedByShaderCaseBlocks(m_context, blockGroup, glslVersion, generateBufferBlockReferencedByShaderSingleBlockContentCases<glu::STORAGE_BUFFER>);
4941 const char* BufferBackedBlockInterfaceTestGroup::getGroupName (glu::Storage storage)
4945 		case glu::STORAGE_UNIFORM:	return "uniform_block";
4946 		case glu::STORAGE_BUFFER:	return "shader_storage_block";
4953 const char* BufferBackedBlockInterfaceTestGroup::getGroupDescription (glu::Storage storage)
4957 		case glu::STORAGE_UNIFORM:	return "Uniform block interface";
4958 		case glu::STORAGE_BUFFER:	return "Shader storage block interface";
4987 			(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT)
4991 			(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION)
4995 			(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_GEOMETRY)
4999 			(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION) | (1 << glu::SHADERTYPE_GEOMETRY),
5016 	addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_compute",				"",	false,	(1 << glu::SHADERTYPE_COMPUTE),										(1 << glu::SHADERTYPE_COMPUTE)));
5017 	addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_separable_vertex",		"",	true,	(1 << glu::SHADERTYPE_VERTEX),										(1 << glu::SHADERTYPE_VERTEX)));
5018 	addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_separable_fragment",	"",	true,	(1 << glu::SHADERTYPE_FRAGMENT),									(1 << glu::SHADERTYPE_FRAGMENT)));
5019 	addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_separable_geometry",	"",	true,	(1 << glu::SHADERTYPE_GEOMETRY),									(1 << glu::SHADERTYPE_GEOMETRY)));
5020 	addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_separable_tess_ctrl",	"",	true,	(1 << glu::SHADERTYPE_TESSELLATION_CONTROL),						(1 << glu::SHADERTYPE_TESSELLATION_CONTROL)));
5021 	addChild(new AtomicCounterReferencedByCase(m_context, "referenced_by_separable_tess_eval",	"",	true,	(1 << glu::SHADERTYPE_TESSELLATION_EVALUATION),						(1 << glu::SHADERTYPE_TESSELLATION_EVALUATION)));
5027 		for (deUint32 stageNdx = 0; stageNdx < glu::SHADERTYPE_LAST; ++stageNdx)
5034 				const char*			stageName	= (stageNdx == glu::SHADERTYPE_VERTEX)					? ("vertex")
5035 												: (stageNdx == glu::SHADERTYPE_FRAGMENT)				? ("fragment")
5036 												: (stageNdx == glu::SHADERTYPE_GEOMETRY)				? ("geo")
5037 												: (stageNdx == glu::SHADERTYPE_TESSELLATION_CONTROL)	? ("tess_ctrl")
5038 												: (stageNdx == glu::SHADERTYPE_TESSELLATION_EVALUATION)	? ("tess_eval")
5048 static void generateProgramInputOutputShaderCaseBlocks (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion, bool withCompute, bool inputCase, bool isGL45, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, deUint32, bool))
5053 		glu::ShaderType	stage;
5056 		{ "separable_vertex",		glu::SHADERTYPE_VERTEX					},
5057 		{ "separable_fragment",		glu::SHADERTYPE_FRAGMENT				},
5058 		{ "separable_tess_ctrl",	glu::SHADERTYPE_TESSELLATION_CONTROL	},
5059 		{ "separable_tess_eval",	glu::SHADERTYPE_TESSELLATION_EVALUATION	},
5060 		{ "separable_geometry",		glu::SHADERTYPE_GEOMETRY				},
5071 		shaderSetPtr->setStage(glu::SHADERTYPE_VERTEX, inputCase);
5072 		shaderSetPtr->setStage(glu::SHADERTYPE_FRAGMENT, !inputCase);
5076 		blockContentGenerator(context, defaultBlock, blockGroup, (1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT), isGL45);
5096 		const ResourceDefinition::Node::SharedPtr	shader			(new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
5101 		blockContentGenerator(context, defaultBlock, blockGroup, (1 << glu::SHADERTYPE_COMPUTE), isGL45);
5109 			glu::ShaderType		inputStage;
5110 			glu::Storage		inputStorage;
5112 			glu::ShaderType		outputStage;
5113 			glu::Storage		outputStorage;
5118 				glu::SHADERTYPE_FRAGMENT,
5119 				glu::STORAGE_IN,
5121 				glu::SHADERTYPE_VERTEX,
5122 				glu::STORAGE_OUT,
5126 				glu::SHADERTYPE_TESSELLATION_EVALUATION,
5127 				glu::STORAGE_PATCH_IN,
5129 				glu::SHADERTYPE_TESSELLATION_CONTROL,
5130 				glu::STORAGE_PATCH_OUT,
5143 			const glu::ShaderType						shaderType		= (inputCase) ? (ioBlockTypes[ndx].inputStage) : (ioBlockTypes[ndx].outputStage);
5144 			const glu::Storage							storageType		= (inputCase) ? (ioBlockTypes[ndx].inputStorage) : (ioBlockTypes[ndx].outputStorage);
5165 				const ResourceDefinition::Node::SharedPtr	layout		(new ResourceDefinition::LayoutQualifier(storage, glu::Layout(3)));
5212 																	? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_IN)))
5214 	const glu::ShaderType						firstStage		= getShaderMaskFirstStage(presentShadersMask);
5220 	if (firstStage == glu::SHADERTYPE_VERTEX)
5223 		const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(input, glu::TYPE_FLOAT_VEC4));
5226 	else if (firstStage == glu::SHADERTYPE_FRAGMENT || !inDefaultBlock)
5230 			const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(input, glu::TYPE_FLOAT_VEC4));
5236 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
5242 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5246 	else if (firstStage == glu::SHADERTYPE_TESSELLATION_CONTROL ||
5247 			 firstStage == glu::SHADERTYPE_GEOMETRY)
5254 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5260 	else if (firstStage == glu::SHADERTYPE_TESSELLATION_EVALUATION)
5263 		const ResourceDefinition::Node::SharedPtr patchInput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_IN));
5268 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5276 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(patchInput, glu::TYPE_FLOAT_VEC4));
5282 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
5288 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5292 	else if (firstStage == glu::SHADERTYPE_COMPUTE)
5313 																	? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_OUT)))
5315 	const glu::ShaderType						lastStage		= getShaderMaskLastStage(presentShadersMask);
5321 	if (lastStage == glu::SHADERTYPE_VERTEX						||
5322 		lastStage == glu::SHADERTYPE_GEOMETRY					||
5323 		lastStage == glu::SHADERTYPE_TESSELLATION_EVALUATION	||
5328 			const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(output, glu::TYPE_FLOAT_VEC4));
5334 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
5340 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5344 	else if (lastStage == glu::SHADERTYPE_FRAGMENT)
5348 			const ResourceDefinition::Node::SharedPtr variable(new ResourceDefinition::Variable(output, glu::TYPE_FLOAT_VEC4));
5354 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5358 	else if (lastStage == glu::SHADERTYPE_TESSELLATION_CONTROL)
5361 		const ResourceDefinition::Node::SharedPtr patchOutput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_OUT));
5366 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5374 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(patchOutput, glu::TYPE_FLOAT_VEC4));
5380 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
5386 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5390 	else if (lastStage == glu::SHADERTYPE_COMPUTE)
5445 																	? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_IN)))
5447 	const glu::ShaderType						firstStage		= getShaderMaskFirstStage(presentShadersMask);
5451 	if (firstStage == glu::SHADERTYPE_VERTEX)
5455 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(input, glu::TYPE_FLOAT_VEC4));
5460 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(input, glu::Layout(2)));
5461 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4));
5465 	else if (firstStage == glu::SHADERTYPE_FRAGMENT || !inDefaultBlock)
5469 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(input, glu::TYPE_FLOAT_VEC4));
5475 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(input, glu::Layout(2)));
5476 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4));
5482 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
5488 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(input, glu::Layout(2)));
5490 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
5496 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5502 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(input, glu::Layout(2)));
5504 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5508 	else if (firstStage == glu::SHADERTYPE_TESSELLATION_CONTROL ||
5509 			 firstStage == glu::SHADERTYPE_GEOMETRY)
5516 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5521 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(input, glu::Layout(2)));
5523 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5529 	else if (firstStage == glu::SHADERTYPE_TESSELLATION_EVALUATION)
5532 		const ResourceDefinition::Node::SharedPtr patchInput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_IN));
5537 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5542 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(input, glu::Layout(2)));
5544 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5552 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(patchInput, glu::TYPE_FLOAT_VEC4));
5557 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(patchInput, glu::Layout(2)));
5558 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4));
5564 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
5569 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(patchInput, glu::Layout(2)));
5571 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
5577 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5582 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(patchInput, glu::Layout(2)));
5584 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5588 	else if (firstStage == glu::SHADERTYPE_COMPUTE)
5601 																	? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_OUT)))
5603 	const glu::ShaderType						lastStage		= getShaderMaskLastStage(presentShadersMask);
5607 	if (lastStage == glu::SHADERTYPE_VERTEX						||
5608 		lastStage == glu::SHADERTYPE_GEOMETRY					||
5609 		lastStage == glu::SHADERTYPE_TESSELLATION_EVALUATION	||
5614 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(output, glu::TYPE_FLOAT_VEC4));
5620 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(output, glu::Layout(2)));
5621 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4));
5627 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
5633 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(output, glu::Layout(2)));
5635 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
5641 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5647 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(output, glu::Layout(2)));
5649 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5653 	else if (lastStage == glu::SHADERTYPE_FRAGMENT)
5657 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(output, glu::TYPE_FLOAT_VEC4));
5663 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(output, glu::Layout(2)));
5664 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4));
5670 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5676 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(output, glu::Layout(1)));
5678 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5682 	else if (lastStage == glu::SHADERTYPE_TESSELLATION_CONTROL)
5685 		const ResourceDefinition::Node::SharedPtr patchOutput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_OUT));
5690 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5695 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(output, glu::Layout(2)));
5697 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5705 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(patchOutput, glu::TYPE_FLOAT_VEC4));
5710 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(patchOutput, glu::Layout(2)));
5711 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(layout, glu::TYPE_FLOAT_VEC4));
5717 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
5722 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(patchOutput, glu::Layout(2)));
5724 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(structMbr, glu::TYPE_FLOAT_VEC4));
5730 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5735 			const ResourceDefinition::Node::SharedPtr layout	(new ResourceDefinition::LayoutQualifier(patchOutput, glu::Layout(2)));
5737 			const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
5741 	else if (lastStage == glu::SHADERTYPE_COMPUTE)
5749 static void generateProgramInputOutputReferencedByCases (Context& context, tcu::TestCaseGroup* targetGroup, glu::Storage storage)
5765 	if (storage == glu::STORAGE_IN)
5766 		targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_separable_tess_eval_patch_in", "", glu::STORAGE_PATCH_IN, ProgramInputOutputReferencedByCase::CASE_SEPARABLE_TESS_EVAL));
5767 	else if (storage == glu::STORAGE_OUT)
5768 		targetGroup->addChild(new ProgramInputOutputReferencedByCase(context, "referenced_by_separable_tess_ctrl_patch_out", "", glu::STORAGE_PATCH_OUT, ProgramInputOutputReferencedByCase::CASE_SEPARABLE_TESS_CTRL));
5778 		glu::DataType	type;
5783 		{ glu::TYPE_FLOAT,			false,		0	},
5784 		{ glu::TYPE_INT,			false,		1	},
5785 		{ glu::TYPE_UINT,			false,		1	},
5786 		{ glu::TYPE_FLOAT_VEC2,		false,		2	},
5787 		{ glu::TYPE_FLOAT_VEC3,		false,		1	},
5788 		{ glu::TYPE_FLOAT_VEC4,		false,		2	},
5789 		{ glu::TYPE_INT_VEC2,		false,		0	},
5790 		{ glu::TYPE_INT_VEC3,		false,		2	},
5791 		{ glu::TYPE_INT_VEC4,		false,		2	},
5792 		{ glu::TYPE_UINT_VEC2,		false,		2	},
5793 		{ glu::TYPE_UINT_VEC3,		false,		2	},
5794 		{ glu::TYPE_UINT_VEC4,		false,		0	},
5795 		{ glu::TYPE_FLOAT_MAT2,		true,		2	},
5796 		{ glu::TYPE_FLOAT_MAT2X3,	true,		2	},
5797 		{ glu::TYPE_FLOAT_MAT2X4,	true,		2	},
5798 		{ glu::TYPE_FLOAT_MAT3X2,	true,		0	},
5799 		{ glu::TYPE_FLOAT_MAT3,		true,		2	},
5800 		{ glu::TYPE_FLOAT_MAT3X4,	true,		2	},
5801 		{ glu::TYPE_FLOAT_MAT4X2,	true,		2	},
5802 		{ glu::TYPE_FLOAT_MAT4X3,	true,		2	},
5803 		{ glu::TYPE_FLOAT_MAT4,		true,		2	},
5824 																						? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_IN)))
5826 	const glu::ShaderType						firstStage							= getShaderMaskFirstStage(presentShadersMask);
5829 	if (firstStage == glu::SHADERTYPE_VERTEX)
5834 	else if (firstStage == glu::SHADERTYPE_FRAGMENT || !inDefaultBlock)
5836 		const ResourceDefinition::Node::SharedPtr flatShading(new ResourceDefinition::InterpolationQualifier(input, glu::INTERPOLATION_FLAT));
5859 	else if (firstStage == glu::SHADERTYPE_TESSELLATION_CONTROL ||
5860 			 firstStage == glu::SHADERTYPE_GEOMETRY)
5868 	else if (firstStage == glu::SHADERTYPE_TESSELLATION_EVALUATION)
5871 		const ResourceDefinition::Node::SharedPtr patchInput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_IN));
5908 	else if (firstStage == glu::SHADERTYPE_COMPUTE)
5921 																						? (ResourceDefinition::Node::SharedPtr(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_OUT)))
5923 	const glu::ShaderType						lastStage							= getShaderMaskLastStage(presentShadersMask);
5926 	if (lastStage == glu::SHADERTYPE_VERTEX						||
5927 		lastStage == glu::SHADERTYPE_GEOMETRY					||
5928 		lastStage == glu::SHADERTYPE_TESSELLATION_EVALUATION	||
5931 		const ResourceDefinition::Node::SharedPtr flatShading(new ResourceDefinition::InterpolationQualifier(output, glu::INTERPOLATION_FLAT));
5942 			const int									typeExpansionReducement	= (lastStage != glu::SHADERTYPE_VERTEX) ? (1) : (0); // lesser expansions on other stages
5951 			const int									typeExpansionReducement	= (lastStage != glu::SHADERTYPE_VERTEX) ? (1) : (0); // lesser expansions on other stages
5958 	else if (lastStage == glu::SHADERTYPE_FRAGMENT)
5974 	else if (lastStage == glu::SHADERTYPE_TESSELLATION_CONTROL)
5977 		const ResourceDefinition::Node::SharedPtr patchOutput(new ResourceDefinition::StorageQualifier(parentStructure, glu::STORAGE_PATCH_OUT));
6014 	else if (lastStage == glu::SHADERTYPE_COMPUTE)
6040 	const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
6074 		generateProgramInputOutputReferencedByCases(m_context, blockGroup, glu::STORAGE_IN);
6110 	const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
6144 		generateProgramInputOutputReferencedByCases(m_context, blockGroup, glu::STORAGE_OUT);
6162 static void generateTransformFeedbackShaderCaseBlocks (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, bool))
6174 			(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT),
6175 			(1 << glu::SHADERTYPE_VERTEX),
6180 			(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION),
6181 			(1 << glu::SHADERTYPE_TESSELLATION_EVALUATION),
6186 			(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_GEOMETRY),
6187 			(1 << glu::SHADERTYPE_GEOMETRY),
6192 			(1 << glu::SHADERTYPE_VERTEX) | (1 << glu::SHADERTYPE_FRAGMENT) | (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION) | (1 << glu::SHADERTYPE_GEOMETRY),
6193 			(1 << glu::SHADERTYPE_GEOMETRY),
6200 		glu::ShaderType	stage;
6204 		{ "separable_vertex",		glu::SHADERTYPE_VERTEX,						false	},
6205 		{ "separable_tess_eval",	glu::SHADERTYPE_TESSELLATION_EVALUATION,	true	},
6206 		{ "separable_geometry",		glu::SHADERTYPE_GEOMETRY,					true	},
6238 	const ResourceDefinition::Node::SharedPtr	output			(new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_OUT));
6250 		const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4));
6257 		const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4));
6264 		const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
6271 		const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4));
6280 	const ResourceDefinition::Node::SharedPtr	output			(new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_OUT));
6292 		const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4));
6299 		const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4));
6306 		const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(arrayElem, glu::TYPE_FLOAT_VEC4));
6313 		const ResourceDefinition::Node::SharedPtr variable	(new ResourceDefinition::Variable(xfbTarget, glu::TYPE_FLOAT_VEC4));
6322 		glu::DataType	type;
6326 		{ glu::TYPE_FLOAT,			true	},
6327 		{ glu::TYPE_INT,			true	},
6328 		{ glu::TYPE_UINT,			true	},
6330 		{ glu::TYPE_FLOAT_VEC2,		false	},
6331 		{ glu::TYPE_FLOAT_VEC3,		true	},
6332 		{ glu::TYPE_FLOAT_VEC4,		false	},
6334 		{ glu::TYPE_INT_VEC2,		false	},
6335 		{ glu::TYPE_INT_VEC3,		true	},
6336 		{ glu::TYPE_INT_VEC4,		false	},
6338 		{ glu::TYPE_UINT_VEC2,		true	},
6339 		{ glu::TYPE_UINT_VEC3,		false	},
6340 		{ glu::TYPE_UINT_VEC4,		false	},
6342 		{ glu::TYPE_FLOAT_MAT2,		false	},
6343 		{ glu::TYPE_FLOAT_MAT2X3,	false	},
6344 		{ glu::TYPE_FLOAT_MAT2X4,	false	},
6345 		{ glu::TYPE_FLOAT_MAT3X2,	false	},
6346 		{ glu::TYPE_FLOAT_MAT3,		false	},
6347 		{ glu::TYPE_FLOAT_MAT3X4,	true	},
6348 		{ glu::TYPE_FLOAT_MAT4X2,	false	},
6349 		{ glu::TYPE_FLOAT_MAT4X3,	false	},
6350 		{ glu::TYPE_FLOAT_MAT4,		false	},
6366 	const ResourceDefinition::Node::SharedPtr	output			(new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_OUT));
6367 	const ResourceDefinition::Node::SharedPtr	flatShading		(new ResourceDefinition::InterpolationQualifier(output, glu::INTERPOLATION_FLAT));
6424 	const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
6455 static void generateBufferVariableBufferCaseBlocks (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*))
6458 	const ResourceDefinition::Node::SharedPtr	shader			(new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
6460 	const ResourceDefinition::Node::SharedPtr	bufferStorage	(new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER));
6461 	const ResourceDefinition::Node::SharedPtr	binding			(new ResourceDefinition::LayoutQualifier(bufferStorage, glu::Layout(-1, 0)));
6524 	generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, aggregateGroup, queryTarget.interface, glu::TYPE_FLOAT, (extendedCases && sizedArray) ? (2) : (1), !extendedCases);
6527 	generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, aggregateGroup, queryTarget.interface, glu::TYPE_BOOL, (extendedCases && sizedArray) ? (1) : (0), !extendedCases);
6530 	generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, aggregateGroup, queryTarget.interface, glu::TYPE_BOOL_VEC3, (extendedCases && sizedArray) ? (2) : (1), !extendedCases);
6533 	generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, aggregateGroup, queryTarget.interface, glu::TYPE_FLOAT_VEC4, (extendedCases && sizedArray) ? (2) : (1), !extendedCases);
6536 	generateBufferBackedArrayStrideTypeAggregateCases(context, parentStructure, aggregateGroup, queryTarget.interface, glu::TYPE_INT_VEC2, (extendedCases && sizedArray) ? (2) : (1), !extendedCases);
6573 static void generateBufferVariableBlockIndexCases (Context& context, glu::GLSLVersion glslVersion, tcu::TestCaseGroup* const targetGroup)
6576 	const ResourceDefinition::Node::SharedPtr	shader			(new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
6578 	const ResourceDefinition::Node::SharedPtr	bufferStorage	(new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER));
6579 	const ResourceDefinition::Node::SharedPtr	binding			(new ResourceDefinition::LayoutQualifier(bufferStorage, glu::Layout(-1, 0)));
6584 		const ResourceDefinition::Node::SharedPtr	variable	(new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4));
6592 		const ResourceDefinition::Node::SharedPtr	variable	(new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4));
6601 		const ResourceDefinition::Node::SharedPtr	variable		(new ResourceDefinition::Variable(buffer, glu::TYPE_FLOAT_VEC4));
6607 static void generateBufferVariableMatrixCaseBlocks (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, bool))
6615 		glu::MatrixOrder	order;
6618 		{ "named_block",				"Named uniform block",		true,	true,	glu::MATRIXORDER_LAST			},
6619 		{ "named_block_row_major",		"Named uniform block",		true,	false,	glu::MATRIXORDER_ROW_MAJOR		},
6620 		{ "named_block_col_major",		"Named uniform block",		true,	false,	glu::MATRIXORDER_COLUMN_MAJOR	},
6621 		{ "unnamed_block",				"Unnamed uniform block",	false,	false,	glu::MATRIXORDER_LAST			},
6622 		{ "unnamed_block_row_major",	"Unnamed uniform block",	false,	false,	glu::MATRIXORDER_ROW_MAJOR		},
6623 		{ "unnamed_block_col_major",	"Unnamed uniform block",	false,	false,	glu::MATRIXORDER_COLUMN_MAJOR	},
6627 	const ResourceDefinition::Node::SharedPtr	shader			(new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
6629 	const ResourceDefinition::Node::SharedPtr	buffer			(new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER));
6638 		if (children[childNdx].order != glu::MATRIXORDER_LAST)
6640 			glu::Layout layout;
6655 	static const glu::DataType variableTypes[] =
6657 		glu::TYPE_FLOAT,
6658 		glu::TYPE_INT_VEC3,
6659 		glu::TYPE_FLOAT_MAT2,
6660 		glu::TYPE_FLOAT_MAT2X3,
6661 		glu::TYPE_FLOAT_MAT2X4,
6662 		glu::TYPE_FLOAT_MAT3X2,
6663 		glu::TYPE_FLOAT_MAT3,
6664 		glu::TYPE_FLOAT_MAT3X4,
6665 		glu::TYPE_FLOAT_MAT4X2,
6666 		glu::TYPE_FLOAT_MAT4X3,
6667 		glu::TYPE_FLOAT_MAT4,
6680 	generateBufferBackedVariableAggregateTypeCases(context, parentStructure, targetGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, targetProp, glu::TYPE_FLOAT_MAT3X2, "", 2);
6685 		const ResourceDefinition::Node::SharedPtr	variable	(new ResourceDefinition::Variable(unsized, glu::TYPE_FLOAT_MAT3X2));
6711 		const ResourceDefinition::Node::SharedPtr matrixOrder(new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, -1, -1, glu::FORMATLAYOUT_LAST, glu::MATRIXORDER_COLUMN_MAJOR)));
6720 		const ResourceDefinition::Node::SharedPtr matrixOrder(new ResourceDefinition::LayoutQualifier(parentStructure, glu::Layout(-1, -1, -1, glu::FORMATLAYOUT_LAST, glu::MATRIXORDER_ROW_MAJOR)));
6735 		generateBufferBackedVariableAggregateTypeCases(context, parentStructure, blockGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_NAME_LENGTH, glu::TYPE_FLOAT, "", 3);
6744 		generateBufferBackedVariableAggregateTypeCases(context, unsized, blockGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_NAME_LENGTH, glu::TYPE_FLOAT, "", 2);
6755 		generateBufferBackedVariableAggregateTypeCases(context, parentStructure, blockGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_OFFSET, glu::TYPE_FLOAT, "", 3);
6764 		generateBufferBackedVariableAggregateTypeCases(context, unsized, blockGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_OFFSET, glu::TYPE_FLOAT, "", 2);
6774 	const ResourceDefinition::Node::SharedPtr	storage			(new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER));
6813 	generateBufferBackedVariableAggregateTypeCases(context, parentStructure, targetGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, TargetProp, glu::TYPE_FLOAT_VEC4, "", 3);
6819 		generateBufferBackedVariableAggregateTypeCases(context, unsized, targetGroup, PROGRAMINTERFACE_BUFFER_VARIABLE, TargetProp, glu::TYPE_FLOAT_VEC4, "_unsized_array", 2);
6828 		glu::DataType	dataType;
6831 		{ 0,	glu::TYPE_FLOAT			},
6832 		{ 1,	glu::TYPE_INT			},
6833 		{ 1,	glu::TYPE_UINT			},
6834 		{ 1,	glu::TYPE_BOOL			},
6836 		{ 3,	glu::TYPE_FLOAT_VEC2	},
6837 		{ 1,	glu::TYPE_FLOAT_VEC3	},
6838 		{ 1,	glu::TYPE_FLOAT_VEC4	},
6840 		{ 3,	glu::TYPE_INT_VEC2		},
6841 		{ 2,	glu::TYPE_INT_VEC3		},
6842 		{ 3,	glu::TYPE_INT_VEC4		},
6844 		{ 3,	glu::TYPE_UINT_VEC2		},
6845 		{ 2,	glu::TYPE_UINT_VEC3		},
6846 		{ 3,	glu::TYPE_UINT_VEC4		},
6848 		{ 3,	glu::TYPE_BOOL_VEC2		},
6849 		{ 2,	glu::TYPE_BOOL_VEC3		},
6850 		{ 3,	glu::TYPE_BOOL_VEC4		},
6852 		{ 2,	glu::TYPE_FLOAT_MAT2	},
6853 		{ 3,	glu::TYPE_FLOAT_MAT2X3	},
6854 		{ 3,	glu::TYPE_FLOAT_MAT2X4	},
6855 		{ 2,	glu::TYPE_FLOAT_MAT3X2	},
6856 		{ 2,	glu::TYPE_FLOAT_MAT3	},
6857 		{ 3,	glu::TYPE_FLOAT_MAT3X4	},
6858 		{ 2,	glu::TYPE_FLOAT_MAT4X2	},
6859 		{ 3,	glu::TYPE_FLOAT_MAT4X3	},
6860 		{ 2,	glu::TYPE_FLOAT_MAT4	},
6909 static void generateBufferVariableTypeBlock (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion)
6912 	const ResourceDefinition::Node::SharedPtr	shader			(new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
6914 	const ResourceDefinition::Node::SharedPtr	buffer			(new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER));
6920 static void generateBufferVariableRandomCase (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion, int index, bool onlyExtensionStages)
6924 	const glu::DataType							type				= generateRandomDataType(rnd, true);
6925 	const glu::Layout							layout				= generateRandomVariableLayout(rnd, type, true);
6928 	const ResourceDefinition::Node::SharedPtr	buffer				(new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER));
6941 static void generateBufferVariableRandomCases (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion)
6966 	const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
7092 	addChild(new BufferBackedBlockInterfaceTestGroup(m_context, glu::STORAGE_UNIFORM));
7110 	addChild(new BufferBackedBlockInterfaceTestGroup(m_context, glu::STORAGE_BUFFER));

Indexes created Thu Nov 07 10:32:03 CST 2024