Home | History | Annotate | Download | only in vulkan
      1 /*-------------------------------------------------------------------------
      2  * Vulkan Conformance Tests
      3  * ------------------------
      4  *
      5  * Copyright (c) 2015 Google Inc.
      6  *
      7  * Licensed under the Apache License, Version 2.0 (the "License");
      8  * you may not use this file except in compliance with the License.
      9  * You may obtain a copy of the License at
     10  *
     11  *      http://www.apache.org/licenses/LICENSE-2.0
     12  *
     13  * Unless required by applicable law or agreed to in writing, software
     14  * distributed under the License is distributed on an "AS IS" BASIS,
     15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     16  * See the License for the specific language governing permissions and
     17  * limitations under the License.
     18  *
     19  *//*!
     20  * \file
     21  * \brief ShaderLibrary Vulkan implementation
     22  *//*--------------------------------------------------------------------*/
     23 
     24 #include "vktShaderLibrary.hpp"
     25 #include "vktTestCase.hpp"
     26 
     27 #include "vkPrograms.hpp"
     28 #include "vkRef.hpp"
     29 #include "vkRefUtil.hpp"
     30 #include "vkMemUtil.hpp"
     31 #include "vkQueryUtil.hpp"
     32 #include "vkBuilderUtil.hpp"
     33 #include "vkTypeUtil.hpp"
     34 
     35 #include "gluShaderLibrary.hpp"
     36 #include "gluShaderUtil.hpp"
     37 
     38 #include "tcuStringTemplate.hpp"
     39 #include "tcuTexture.hpp"
     40 #include "tcuTestLog.hpp"
     41 #include "tcuVector.hpp"
     42 #include "tcuVectorUtil.hpp"
     43 
     44 #include "deStringUtil.hpp"
     45 #include "deArrayUtil.hpp"
     46 #include "deMemory.h"
     47 
     48 #include <sstream>
     49 #include <map>
     50 
     51 namespace vkt
     52 {
     53 
     54 using std::string;
     55 using std::vector;
     56 using std::map;
     57 using std::pair;
     58 using std::ostringstream;
     59 
     60 using de::MovePtr;
     61 using de::UniquePtr;
     62 
     63 using glu::ShaderType;
     64 using glu::ProgramSources;
     65 using glu::DataType;
     66 
     67 using glu::sl::ShaderCaseSpecification;
     68 using glu::sl::ProgramSpecializationParams;
     69 using glu::sl::RequiredExtension;
     70 using glu::sl::Value;
     71 using glu::sl::ValueBlock;
     72 
     73 using tcu::TestStatus;
     74 using tcu::StringTemplate;
     75 using tcu::Vec2;
     76 using tcu::ConstPixelBufferAccess;
     77 using tcu::TextureFormat;
     78 using tcu::TestLog;
     79 
     80 using vk::SourceCollections;
     81 using vk::Move;
     82 using vk::Unique;
     83 
     84 namespace
     85 {
     86 
     87 enum
     88 {
     89 	REFERENCE_UNIFORM_BINDING	= 0,
     90 	USER_UNIFORM_BINDING		= 1
     91 };
     92 
     93 string getShaderName (ShaderType shaderType, size_t progNdx)
     94 {
     95 	ostringstream str;
     96 	str << glu::getShaderTypeName(shaderType);
     97 	if (progNdx > 0)
     98 		str << "_" << progNdx;
     99 	return str.str();
    100 }
    101 
    102 void genUniformBlock (ostringstream& out, const string& blockName, const string& instanceName, int setNdx, int bindingNdx, const vector<Value>& uniforms)
    103 {
    104 	out << "layout(";
    105 
    106 	if (setNdx != 0)
    107 		out << "set = " << setNdx << ", ";
    108 
    109 	out << "binding = " << bindingNdx << ", std140) uniform " << blockName << "\n"
    110 		<< "{\n";
    111 
    112 	for (vector<Value>::const_iterator val = uniforms.begin(); val != uniforms.end(); ++val)
    113 		out << "\t" << glu::declare(val->type, val->name, 1) << ";\n";
    114 
    115 	out << "}";
    116 
    117 	if (!instanceName.empty())
    118 		out << " " << instanceName;
    119 
    120 	out << ";\n";
    121 }
    122 
    123 void declareReferenceBlock (ostringstream& out, const ValueBlock& valueBlock)
    124 {
    125 	if (!valueBlock.outputs.empty())
    126 		genUniformBlock(out, "Reference", "ref", 0, REFERENCE_UNIFORM_BINDING, valueBlock.outputs);
    127 }
    128 
    129 void declareUniforms (ostringstream& out, const ValueBlock& valueBlock)
    130 {
    131 	if (!valueBlock.uniforms.empty())
    132 		genUniformBlock(out, "Uniforms", "", 0, USER_UNIFORM_BINDING, valueBlock.uniforms);
    133 }
    134 
    135 DataType getTransportType (DataType valueType)
    136 {
    137 	if (isDataTypeBoolOrBVec(valueType))
    138 		return glu::getDataTypeUintVec(getDataTypeScalarSize(valueType));
    139 	else
    140 		return valueType;
    141 }
    142 
    143 int getNumTransportLocations (DataType valueType)
    144 {
    145 	return isDataTypeMatrix(valueType) ? getDataTypeMatrixNumColumns(valueType) : 1;
    146 }
    147 
    148 // This functions builds a matching vertex shader for a 'both' case, when
    149 // the fragment shader is being tested.
    150 // We need to build attributes and varyings for each 'input'.
    151 string genVertexShader (const ShaderCaseSpecification& spec)
    152 {
    153 	ostringstream	res;
    154 	int				curInputLoc		= 0;
    155 	int				curOutputLoc	= 0;
    156 
    157 	res << glu::getGLSLVersionDeclaration(spec.targetVersion) << "\n";
    158 
    159 	// Declarations (position + attribute/varying for each input).
    160 	res << "precision highp float;\n";
    161 	res << "precision highp int;\n";
    162 	res << "\n";
    163 	res << "layout(location = 0) in highp vec4 dEQP_Position;\n";
    164 	curInputLoc += 1;
    165 
    166 	for (size_t ndx = 0; ndx < spec.values.inputs.size(); ndx++)
    167 	{
    168 		const Value&		val					= spec.values.inputs[ndx];
    169 		const DataType		valueType			= val.type.getBasicType();
    170 		const DataType		transportType		= getTransportType(valueType);
    171 		const char* const	transportTypeStr	= getDataTypeName(transportType);
    172 		const int			numLocs				= getNumTransportLocations(valueType);
    173 
    174 		res << "layout(location = " << curInputLoc << ") in " << transportTypeStr << " a_" << val.name << ";\n";
    175 		res << "layout(location = " << curOutputLoc << ") flat out " << transportTypeStr << " " << (transportType != valueType ? "v_" : "") << val.name << ";\n";
    176 
    177 		curInputLoc		+= numLocs;
    178 		curOutputLoc	+= numLocs;
    179 	}
    180 	res << "\n";
    181 
    182 	// Main function.
    183 	// - gl_Position = dEQP_Position;
    184 	// - for each input: write attribute directly to varying
    185 	res << "void main()\n";
    186 	res << "{\n";
    187 	res << "	gl_Position = dEQP_Position;\n";
    188 	for (size_t ndx = 0; ndx < spec.values.inputs.size(); ndx++)
    189 	{
    190 		const Value&	val		= spec.values.inputs[ndx];
    191 		const string&	name	= val.name;
    192 
    193 		res << "	" << (getTransportType(val.type.getBasicType()) != val.type.getBasicType() ? "v_" : "")
    194 			<< name << " = a_" << name << ";\n";
    195 	}
    196 
    197 	res << "}\n";
    198 	return res.str();
    199 }
    200 
    201 void genCompareOp (ostringstream& output, const char* dstVec4Var, const ValueBlock& valueBlock, const char* checkVarName)
    202 {
    203 	bool isFirstOutput = true;
    204 
    205 	for (size_t ndx = 0; ndx < valueBlock.outputs.size(); ndx++)
    206 	{
    207 		const Value&	val		= valueBlock.outputs[ndx];
    208 
    209 		// Check if we're only interested in one variable (then skip if not the right one).
    210 		if (checkVarName && val.name != checkVarName)
    211 			continue;
    212 
    213 		// Prefix.
    214 		if (isFirstOutput)
    215 		{
    216 			output << "bool RES = ";
    217 			isFirstOutput = false;
    218 		}
    219 		else
    220 			output << "RES = RES && ";
    221 
    222 		// Generate actual comparison.
    223 		if (getDataTypeScalarType(val.type.getBasicType()) == glu::TYPE_FLOAT)
    224 			output << "isOk(" << val.name << ", ref." << val.name << ", 0.05);\n";
    225 		else
    226 			output << "isOk(" << val.name << ", ref." << val.name << ");\n";
    227 	}
    228 
    229 	if (isFirstOutput)
    230 		output << dstVec4Var << " = vec4(1.0);\n";
    231 	else
    232 		output << dstVec4Var << " = vec4(RES, RES, RES, 1.0);\n";
    233 }
    234 
    235 string genFragmentShader (const ShaderCaseSpecification& spec)
    236 {
    237 	ostringstream	shader;
    238 	ostringstream	setup;
    239 	int				curInLoc	= 0;
    240 
    241 	shader << glu::getGLSLVersionDeclaration(spec.targetVersion) << "\n";
    242 
    243 	shader << "precision highp float;\n";
    244 	shader << "precision highp int;\n";
    245 	shader << "\n";
    246 
    247 	shader << "layout(location = 0) out mediump vec4 dEQP_FragColor;\n";
    248 	shader << "\n";
    249 
    250 	genCompareFunctions(shader, spec.values, false);
    251 	shader << "\n";
    252 
    253 	// Declarations (varying, reference for each output).
    254 	for (size_t ndx = 0; ndx < spec.values.outputs.size(); ndx++)
    255 	{
    256 		const Value&		val					= spec.values.outputs[ndx];
    257 		const DataType		valueType			= val.type.getBasicType();
    258 		const char*	const	valueTypeStr		= getDataTypeName(valueType);
    259 		const DataType		transportType		= getTransportType(valueType);
    260 		const char* const	transportTypeStr	= getDataTypeName(transportType);
    261 		const int			numLocs				= getNumTransportLocations(valueType);
    262 
    263 		shader << "layout(location = " << curInLoc << ") flat in " << transportTypeStr << " " << (valueType != transportType ? "v_" : "") << val.name << ";\n";
    264 
    265 		if (valueType != transportType)
    266 			setup << "	" << valueTypeStr << " " << val.name << " = " << valueTypeStr << "(v_" << val.name << ");\n";
    267 
    268 		curInLoc += numLocs;
    269 	}
    270 
    271 	declareReferenceBlock(shader, spec.values);
    272 
    273 	shader << "\n";
    274 	shader << "void main()\n";
    275 	shader << "{\n";
    276 
    277 	shader << setup.str();
    278 
    279 	shader << "	";
    280 	genCompareOp(shader, "dEQP_FragColor", spec.values, DE_NULL);
    281 
    282 	shader << "}\n";
    283 	return shader.str();
    284 }
    285 
    286 // Specialize a shader for the vertex shader test case.
    287 string specializeVertexShader (const ShaderCaseSpecification& spec, const string& src)
    288 {
    289 	ostringstream		decl;
    290 	ostringstream		setup;
    291 	ostringstream		output;
    292 	int					curInputLoc		= 0;
    293 	int					curOutputLoc	= 0;
    294 
    295 	// generated from "both" case
    296 	DE_ASSERT(spec.caseType == glu::sl::CASETYPE_VERTEX_ONLY);
    297 
    298 	// Output (write out position).
    299 	output << "gl_Position = dEQP_Position;\n";
    300 
    301 	// Declarations (position + attribute for each input, varying for each output).
    302 	decl << "layout(location = 0) in highp vec4 dEQP_Position;\n";
    303 	curInputLoc += 1;
    304 
    305 	for (size_t ndx = 0; ndx < spec.values.inputs.size(); ndx++)
    306 	{
    307 		const Value&		val					= spec.values.inputs[ndx];
    308 		const DataType		valueType			= val.type.getBasicType();
    309 		const char*	const	valueTypeStr		= getDataTypeName(valueType);
    310 		const DataType		transportType		= getTransportType(valueType);
    311 		const char* const	transportTypeStr	= getDataTypeName(transportType);
    312 		const int			numLocs				= getNumTransportLocations(valueType);
    313 
    314 		decl << "layout(location = " << curInputLoc << ") in ";
    315 
    316 		curInputLoc += numLocs;
    317 
    318 		if (valueType == transportType)
    319 			decl << transportTypeStr << " " << val.name << ";\n";
    320 		else
    321 		{
    322 			decl << transportTypeStr << " a_" << val.name << ";\n";
    323 			setup << valueTypeStr << " " << val.name << " = " << valueTypeStr << "(a_" << val.name << ");\n";
    324 		}
    325 	}
    326 
    327 	declareUniforms(decl, spec.values);
    328 
    329 	for (size_t ndx = 0; ndx < spec.values.outputs.size(); ndx++)
    330 	{
    331 		const Value&		val					= spec.values.outputs[ndx];
    332 		const DataType		valueType			= val.type.getBasicType();
    333 		const char*	const	valueTypeStr		= getDataTypeName(valueType);
    334 		const DataType		transportType		= getTransportType(valueType);
    335 		const char* const	transportTypeStr	= getDataTypeName(transportType);
    336 		const int			numLocs				= getNumTransportLocations(valueType);
    337 
    338 		decl << "layout(location = " << curOutputLoc << ") flat out ";
    339 
    340 		curOutputLoc += numLocs;
    341 
    342 		if (valueType == transportType)
    343 			decl << transportTypeStr << " " << val.name << ";\n";
    344 		else
    345 		{
    346 			decl << transportTypeStr << " v_" << val.name << ";\n";
    347 			decl << valueTypeStr << " " << val.name << ";\n";
    348 
    349 			output << "v_" << val.name << " = " << transportTypeStr << "(" << val.name << ");\n";
    350 		}
    351 	}
    352 
    353 	// Shader specialization.
    354 	map<string, string> params;
    355 	params.insert(pair<string, string>("DECLARATIONS", decl.str()));
    356 	params.insert(pair<string, string>("SETUP", setup.str()));
    357 	params.insert(pair<string, string>("OUTPUT", output.str()));
    358 	params.insert(pair<string, string>("POSITION_FRAG_COLOR", "gl_Position"));
    359 
    360 	StringTemplate	tmpl	(src);
    361 	const string	baseSrc	= tmpl.specialize(params);
    362 	const string	withExt	= injectExtensionRequirements(baseSrc, spec.programs[0].requiredExtensions, glu::SHADERTYPE_VERTEX);
    363 
    364 	return withExt;
    365 }
    366 
    367 // Specialize a shader for the fragment shader test case.
    368 string specializeFragmentShader (const ShaderCaseSpecification& spec, const string& src)
    369 {
    370 	ostringstream		decl;
    371 	ostringstream		setup;
    372 	ostringstream		output;
    373 	int					curInputLoc	= 0;
    374 
    375 	// generated from "both" case
    376 	DE_ASSERT(spec.caseType == glu::sl::CASETYPE_FRAGMENT_ONLY);
    377 
    378 	genCompareFunctions(decl, spec.values, false);
    379 	genCompareOp(output, "dEQP_FragColor", spec.values, DE_NULL);
    380 
    381 	decl << "layout(location = 0) out mediump vec4 dEQP_FragColor;\n";
    382 
    383 	for (size_t ndx = 0; ndx < spec.values.inputs.size(); ndx++)
    384 	{
    385 		const Value&		val					= spec.values.inputs[ndx];
    386 		const DataType		valueType			= val.type.getBasicType();
    387 		const char*	const	valueTypeStr		= getDataTypeName(valueType);
    388 		const DataType		transportType		= getTransportType(valueType);
    389 		const char* const	transportTypeStr	= getDataTypeName(transportType);
    390 		const int			numLocs				= getNumTransportLocations(valueType);
    391 
    392 		decl << "layout(location = " << curInputLoc << ") flat in ";
    393 
    394 		curInputLoc += numLocs;
    395 
    396 		if (valueType == transportType)
    397 			decl << transportTypeStr << " " << val.name << ";\n";
    398 		else
    399 		{
    400 			decl << transportTypeStr << " v_" << val.name << ";\n";
    401 			setup << valueTypeStr << " " << val.name << " = " << valueTypeStr << "(v_" << val.name << ");\n";
    402 		}
    403 	}
    404 
    405 	declareUniforms(decl, spec.values);
    406 	declareReferenceBlock(decl, spec.values);
    407 
    408 	for (size_t ndx = 0; ndx < spec.values.outputs.size(); ndx++)
    409 	{
    410 		const Value&		val				= spec.values.outputs[ndx];
    411 		const DataType		basicType		= val.type.getBasicType();
    412 		const char* const	refTypeStr		= getDataTypeName(basicType);
    413 
    414 		decl << refTypeStr << " " << val.name << ";\n";
    415 	}
    416 
    417 	// Shader specialization.
    418 	map<string, string> params;
    419 	params.insert(pair<string, string>("DECLARATIONS", decl.str()));
    420 	params.insert(pair<string, string>("SETUP", setup.str()));
    421 	params.insert(pair<string, string>("OUTPUT", output.str()));
    422 	params.insert(pair<string, string>("POSITION_FRAG_COLOR", "dEQP_FragColor"));
    423 
    424 	StringTemplate	tmpl	(src);
    425 	const string	baseSrc	= tmpl.specialize(params);
    426 	const string	withExt	= injectExtensionRequirements(baseSrc, spec.programs[0].requiredExtensions, glu::SHADERTYPE_FRAGMENT);
    427 
    428 	return withExt;
    429 }
    430 
    431 map<string, string> generateVertexSpecialization (const ProgramSpecializationParams& specParams)
    432 {
    433 	ostringstream			decl;
    434 	ostringstream			setup;
    435 	map<string, string>		params;
    436 	int						curInputLoc		= 0;
    437 
    438 	decl << "layout(location = 0) in highp vec4 dEQP_Position;\n";
    439 	curInputLoc += 1;
    440 
    441 	for (size_t ndx = 0; ndx < specParams.caseSpec.values.inputs.size(); ndx++)
    442 	{
    443 		const Value&		val					= specParams.caseSpec.values.inputs[ndx];
    444 		const DataType		valueType			= val.type.getBasicType();
    445 		const char*	const	valueTypeStr		= getDataTypeName(valueType);
    446 		const DataType		transportType		= getTransportType(valueType);
    447 		const char* const	transportTypeStr	= getDataTypeName(transportType);
    448 		const int			numLocs				= getNumTransportLocations(valueType);
    449 
    450 		decl << "layout(location = " << curInputLoc << ") in ";
    451 
    452 		curInputLoc += numLocs;
    453 
    454 		if (valueType == transportType)
    455 			decl << transportTypeStr << " " << val.name << ";\n";
    456 		else
    457 		{
    458 			decl << transportTypeStr << " a_" << val.name << ";\n";
    459 			setup << valueTypeStr << " " << val.name << " = " << valueTypeStr << "(a_" << val.name << ");\n";
    460 		}
    461 	}
    462 
    463 	declareUniforms(decl, specParams.caseSpec.values);
    464 
    465 	params.insert(pair<string, string>("VERTEX_DECLARATIONS",	decl.str()));
    466 	params.insert(pair<string, string>("VERTEX_SETUP",			setup.str()));
    467 	params.insert(pair<string, string>("VERTEX_OUTPUT",			string("gl_Position = dEQP_Position;\n")));
    468 
    469 	return params;
    470 }
    471 
    472 map<string, string> generateFragmentSpecialization (const ProgramSpecializationParams& specParams)
    473 {
    474 	ostringstream		decl;
    475 	ostringstream		output;
    476 	map<string, string>	params;
    477 
    478 	genCompareFunctions(decl, specParams.caseSpec.values, false);
    479 	genCompareOp(output, "dEQP_FragColor", specParams.caseSpec.values, DE_NULL);
    480 
    481 	decl << "layout(location = 0) out mediump vec4 dEQP_FragColor;\n";
    482 
    483 	for (size_t ndx = 0; ndx < specParams.caseSpec.values.outputs.size(); ndx++)
    484 	{
    485 		const Value&		val			= specParams.caseSpec.values.outputs[ndx];
    486 		const char*	const	refTypeStr	= getDataTypeName(val.type.getBasicType());
    487 
    488 		decl << refTypeStr << " " << val.name << ";\n";
    489 	}
    490 
    491 	declareReferenceBlock(decl, specParams.caseSpec.values);
    492 	declareUniforms(decl, specParams.caseSpec.values);
    493 
    494 	params.insert(pair<string, string>("FRAGMENT_DECLARATIONS",	decl.str()));
    495 	params.insert(pair<string, string>("FRAGMENT_OUTPUT",		output.str()));
    496 	params.insert(pair<string, string>("FRAG_COLOR",			"dEQP_FragColor"));
    497 
    498 	return params;
    499 }
    500 
    501 map<string, string> generateGeometrySpecialization (const ProgramSpecializationParams& specParams)
    502 {
    503 	ostringstream		decl;
    504 	map<string, string>	params;
    505 
    506 	decl << "layout (triangles) in;\n";
    507 	decl << "layout (triangle_strip, max_vertices=3) out;\n";
    508 	decl << "\n";
    509 
    510 	declareUniforms(decl, specParams.caseSpec.values);
    511 
    512 	params.insert(pair<string, string>("GEOMETRY_DECLARATIONS",		decl.str()));
    513 
    514 	return params;
    515 }
    516 
    517 map<string, string> generateTessControlSpecialization (const ProgramSpecializationParams& specParams)
    518 {
    519 	ostringstream		decl;
    520 	ostringstream		output;
    521 	map<string, string>	params;
    522 
    523 	decl << "layout (vertices=3) out;\n";
    524 	decl << "\n";
    525 
    526 	declareUniforms(decl, specParams.caseSpec.values);
    527 
    528 	output <<	"gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
    529 				"gl_TessLevelInner[0] = 2.0;\n"
    530 				"gl_TessLevelInner[1] = 2.0;\n"
    531 				"gl_TessLevelOuter[0] = 2.0;\n"
    532 				"gl_TessLevelOuter[1] = 2.0;\n"
    533 				"gl_TessLevelOuter[2] = 2.0;\n"
    534 				"gl_TessLevelOuter[3] = 2.0;";
    535 
    536 	params.insert(pair<string, string>("TESSELLATION_CONTROL_DECLARATIONS",	decl.str()));
    537 	params.insert(pair<string, string>("TESSELLATION_CONTROL_OUTPUT",		output.str()));
    538 	params.insert(pair<string, string>("GL_MAX_PATCH_VERTICES",				de::toString(specParams.maxPatchVertices)));
    539 
    540 	return params;
    541 }
    542 
    543 map<string, string> generateTessEvalSpecialization (const ProgramSpecializationParams& specParams)
    544 {
    545 	ostringstream		decl;
    546 	ostringstream		output;
    547 	map<string, string>	params;
    548 
    549 	decl << "layout (triangles) in;\n";
    550 	decl << "\n";
    551 
    552 	declareUniforms(decl, specParams.caseSpec.values);
    553 
    554 	output <<	"gl_Position = gl_TessCoord[0] * gl_in[0].gl_Position + gl_TessCoord[1] * gl_in[1].gl_Position + gl_TessCoord[2] * gl_in[2].gl_Position;\n";
    555 
    556 	params.insert(pair<string, string>("TESSELLATION_EVALUATION_DECLARATIONS",	decl.str()));
    557 	params.insert(pair<string, string>("TESSELLATION_EVALUATION_OUTPUT",		output.str()));
    558 	params.insert(pair<string, string>("GL_MAX_PATCH_VERTICES",					de::toString(specParams.maxPatchVertices)));
    559 
    560 	return params;
    561 }
    562 
    563 void specializeShaderSources (ProgramSources&						dst,
    564 							  const ProgramSources&					src,
    565 							  const ProgramSpecializationParams&	specParams,
    566 							  glu::ShaderType						shaderType,
    567 							  map<string, string>					(*specializationGenerator) (const ProgramSpecializationParams& specParams))
    568 {
    569 	if (!src.sources[shaderType].empty())
    570 	{
    571 		const map<string, string>	tmplParams	= specializationGenerator(specParams);
    572 
    573 		for (size_t ndx = 0; ndx < src.sources[shaderType].size(); ++ndx)
    574 		{
    575 			const StringTemplate	tmpl			(src.sources[shaderType][ndx]);
    576 			const string			baseGLSLCode	= tmpl.specialize(tmplParams);
    577 			const string			sourceWithExts	= injectExtensionRequirements(baseGLSLCode, specParams.requiredExtensions, shaderType);
    578 
    579 			dst << glu::ShaderSource(shaderType, sourceWithExts);
    580 		}
    581 	}
    582 }
    583 
    584 void specializeProgramSources (glu::ProgramSources&					dst,
    585 							   const glu::ProgramSources&			src,
    586 							   const ProgramSpecializationParams&	specParams)
    587 {
    588 	specializeShaderSources(dst, src, specParams, glu::SHADERTYPE_VERTEX,					generateVertexSpecialization);
    589 	specializeShaderSources(dst, src, specParams, glu::SHADERTYPE_FRAGMENT,					generateFragmentSpecialization);
    590 	specializeShaderSources(dst, src, specParams, glu::SHADERTYPE_GEOMETRY,					generateGeometrySpecialization);
    591 	specializeShaderSources(dst, src, specParams, glu::SHADERTYPE_TESSELLATION_CONTROL,		generateTessControlSpecialization);
    592 	specializeShaderSources(dst, src, specParams, glu::SHADERTYPE_TESSELLATION_EVALUATION,	generateTessEvalSpecialization);
    593 
    594 	dst << glu::ProgramSeparable(src.separable);
    595 }
    596 
    597 struct ValueBufferLayout
    598 {
    599 	struct Entry
    600 	{
    601 		int		offset;
    602 		int		vecStride;	//! Applies to matrices only
    603 
    604 		Entry (void) : offset(0), vecStride(0) {}
    605 		Entry (int offset_, int vecStride_) : offset(offset_), vecStride(vecStride_) {}
    606 	};
    607 
    608 	vector<Entry>	entries;
    609 	int				size;
    610 
    611 	ValueBufferLayout (void) : size(0) {}
    612 };
    613 
    614 ValueBufferLayout computeStd140Layout (const vector<Value>& values)
    615 {
    616 	ValueBufferLayout layout;
    617 
    618 	layout.entries.resize(values.size());
    619 
    620 	for (size_t ndx = 0; ndx < values.size(); ++ndx)
    621 	{
    622 		const DataType	basicType	= values[ndx].type.getBasicType();
    623 		const bool		isMatrix	= isDataTypeMatrix(basicType);
    624 		const int		numVecs		= isMatrix ? getDataTypeMatrixNumColumns(basicType) : 1;
    625 		const DataType	vecType		= isMatrix ? glu::getDataTypeFloatVec(getDataTypeMatrixNumRows(basicType)) : basicType;
    626 		const int		vecSize		= getDataTypeScalarSize(vecType);
    627 		const int		alignment	= ((isMatrix || vecSize == 3) ? 4 : vecSize)*int(sizeof(deUint32));
    628 
    629 		layout.size			= deAlign32(layout.size, alignment);
    630 		layout.entries[ndx] = ValueBufferLayout::Entry(layout.size, alignment);
    631 		layout.size			+= alignment*(numVecs-1) + vecSize*int(sizeof(deUint32));
    632 	}
    633 
    634 	return layout;
    635 }
    636 
    637 ValueBufferLayout computeStd430Layout (const vector<Value>& values)
    638 {
    639 	ValueBufferLayout layout;
    640 
    641 	layout.entries.resize(values.size());
    642 
    643 	for (size_t ndx = 0; ndx < values.size(); ++ndx)
    644 	{
    645 		const DataType	basicType	= values[ndx].type.getBasicType();
    646 		const int		numVecs		= isDataTypeMatrix(basicType) ? getDataTypeMatrixNumColumns(basicType) : 1;
    647 		const DataType	vecType		= isDataTypeMatrix(basicType) ? glu::getDataTypeFloatVec(getDataTypeMatrixNumRows(basicType)) : basicType;
    648 		const int		vecSize		= getDataTypeScalarSize(vecType);
    649 		const int		alignment	= (vecSize == 3 ? 4 : vecSize)*int(sizeof(deUint32));
    650 
    651 		layout.size			= deAlign32(layout.size, alignment);
    652 		layout.entries[ndx] = ValueBufferLayout::Entry(layout.size, alignment);
    653 		layout.size			+= alignment*(numVecs-1) + vecSize*int(sizeof(deUint32));
    654 	}
    655 
    656 	return layout;
    657 }
    658 
    659 void copyToLayout (void* dst, const ValueBufferLayout::Entry& entryLayout, const Value& value, int arrayNdx)
    660 {
    661 	const DataType	basicType	= value.type.getBasicType();
    662 	const int		scalarSize	= getDataTypeScalarSize(basicType);
    663 	const int		numVecs		= isDataTypeMatrix(basicType) ? getDataTypeMatrixNumColumns(basicType) : 1;
    664 	const int		numComps	= isDataTypeMatrix(basicType) ? getDataTypeMatrixNumRows(basicType) : scalarSize;
    665 
    666 	DE_ASSERT(size_t((arrayNdx+1)*scalarSize) <= value.elements.size());
    667 
    668 	if (isDataTypeBoolOrBVec(basicType))
    669 	{
    670 		for (int vecNdx = 0; vecNdx < numVecs; vecNdx++)
    671 		{
    672 			for (int compNdx = 0; compNdx < numComps; compNdx++)
    673 			{
    674 				const deUint32 data = value.elements[arrayNdx*scalarSize + vecNdx*numComps + compNdx].bool32 ? ~0u : 0u;
    675 
    676 				deMemcpy((deUint8*)dst + entryLayout.offset + vecNdx*entryLayout.vecStride + compNdx * sizeof(deUint32),
    677 						 &data,
    678 						 sizeof(deUint32));
    679 			}
    680 		}
    681 	}
    682 	else
    683 	{
    684 		for (int vecNdx = 0; vecNdx < numVecs; vecNdx++)
    685 			deMemcpy((deUint8*)dst + entryLayout.offset + vecNdx*entryLayout.vecStride,
    686 					 &value.elements[arrayNdx*scalarSize + vecNdx*numComps],
    687 					 numComps*sizeof(deUint32));
    688 	}
    689 }
    690 
    691 void copyToLayout (void* dst, const ValueBufferLayout& layout, const vector<Value>& values, int arrayNdx)
    692 {
    693 	DE_ASSERT(layout.entries.size() == values.size());
    694 
    695 	for (size_t ndx = 0; ndx < values.size(); ndx++)
    696 		copyToLayout(dst, layout.entries[ndx], values[ndx], arrayNdx);
    697 }
    698 
    699 deUint32 getShaderStages (const ShaderCaseSpecification& spec)
    700 {
    701 	if (spec.caseType == glu::sl::CASETYPE_COMPLETE)
    702 	{
    703 		deUint32	stages	= 0u;
    704 
    705 		for (size_t progNdx = 0; progNdx < spec.programs.size(); progNdx++)
    706 		{
    707 			for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; shaderType++)
    708 			{
    709 				if (!spec.programs[progNdx].sources.sources[shaderType].empty())
    710 					stages |= (1u << shaderType);
    711 			}
    712 		}
    713 
    714 		return stages;
    715 	}
    716 	else
    717 		return (1u << glu::SHADERTYPE_VERTEX) | (1u << glu::SHADERTYPE_FRAGMENT);
    718 }
    719 
    720 class PipelineProgram
    721 {
    722 public:
    723 								PipelineProgram		(Context& context, const ShaderCaseSpecification& spec);
    724 
    725 	deUint32					getStages			(void) const					{ return m_stages;							}
    726 
    727 	bool						hasShader			(glu::ShaderType type) const	{ return (m_stages & (1u << type)) != 0;	}
    728 	vk::VkShaderModule			getShader			(glu::ShaderType type) const	{ return *m_shaderModules[type];			}
    729 
    730 private:
    731 	const deUint32				m_stages;
    732 	Move<vk::VkShaderModule>	m_shaderModules[glu::SHADERTYPE_LAST];
    733 };
    734 
    735 PipelineProgram::PipelineProgram (Context& context, const ShaderCaseSpecification& spec)
    736 	: m_stages(getShaderStages(spec))
    737 {
    738 	// \note Currently only a single source program is supported as framework lacks SPIR-V linking capability
    739 	TCU_CHECK_INTERNAL(spec.programs.size() == 1);
    740 
    741 	for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; shaderType++)
    742 	{
    743 		if ((m_stages & (1u << shaderType)) != 0)
    744 		{
    745 			m_shaderModules[shaderType]	= vk::createShaderModule(context.getDeviceInterface(), context.getDevice(),
    746 																 context.getBinaryCollection().get(getShaderName((glu::ShaderType)shaderType, 0)), 0u);
    747 		}
    748 	}
    749 }
    750 
    751 vector<vk::VkPipelineShaderStageCreateInfo> getPipelineShaderStageCreateInfo (const PipelineProgram& program)
    752 {
    753 	vector<vk::VkPipelineShaderStageCreateInfo>	infos;
    754 
    755 	for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; shaderType++)
    756 	{
    757 		if (program.hasShader((glu::ShaderType)shaderType))
    758 		{
    759 			const vk::VkPipelineShaderStageCreateInfo info =
    760 			{
    761 				vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,	// sType
    762 				DE_NULL,													// pNext
    763 				(vk::VkPipelineShaderStageCreateFlags)0,
    764 				vk::getVkShaderStage((glu::ShaderType)shaderType),			// stage
    765 				program.getShader((glu::ShaderType)shaderType),				// module
    766 				"main",
    767 				DE_NULL,													// pSpecializationInfo
    768 			};
    769 
    770 			infos.push_back(info);
    771 		}
    772 	}
    773 
    774 	return infos;
    775 }
    776 
    777 Move<vk::VkBuffer> createBuffer (Context& context, vk::VkDeviceSize size, vk::VkBufferUsageFlags usageFlags)
    778 {
    779 	const deUint32					queueFamilyIndex	= context.getUniversalQueueFamilyIndex();
    780 	const vk::VkBufferCreateInfo	params				=
    781 	{
    782 		vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,	// sType
    783 		DE_NULL,									// pNext
    784 		0u,											// flags
    785 		size,										// size
    786 		usageFlags,									// usage
    787 		vk::VK_SHARING_MODE_EXCLUSIVE,				// sharingMode
    788 		1u,											// queueFamilyCount
    789 		&queueFamilyIndex,							// pQueueFamilyIndices
    790 	};
    791 
    792 	return vk::createBuffer(context.getDeviceInterface(), context.getDevice(), &params);
    793 }
    794 
    795 Move<vk::VkImage> createImage2D (Context& context, deUint32 width, deUint32 height, vk::VkFormat format, vk::VkImageTiling tiling, vk::VkImageUsageFlags usageFlags)
    796 {
    797 	const deUint32					queueFamilyIndex	= context.getUniversalQueueFamilyIndex();
    798 	const vk::VkImageCreateInfo		params				=
    799 	{
    800 		vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,	// sType
    801 		DE_NULL,									// pNext
    802 		0u,											// flags
    803 		vk::VK_IMAGE_TYPE_2D,						// imageType
    804 		format,										// format
    805 		{ width, height, 1u },						// extent
    806 		1u,											// mipLevels
    807 		1u,											// arraySize
    808 		vk::VK_SAMPLE_COUNT_1_BIT,					// samples
    809 		tiling,										// tiling
    810 		usageFlags,									// usage
    811 		vk::VK_SHARING_MODE_EXCLUSIVE,				// sharingMode
    812 		1u,											// queueFamilyCount
    813 		&queueFamilyIndex,							// pQueueFamilyIndices
    814 		vk::VK_IMAGE_LAYOUT_UNDEFINED,				// initialLayout
    815 	};
    816 
    817 	return vk::createImage(context.getDeviceInterface(), context.getDevice(), &params);
    818 }
    819 
    820 Move<vk::VkImageView> createAttachmentView (Context& context, vk::VkImage image, vk::VkFormat format)
    821 {
    822 	const vk::VkImageViewCreateInfo	params				=
    823 	{
    824 		vk::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,		// sType
    825 		DE_NULL,											// pNext
    826 		0u,													// flags
    827 		image,												// image
    828 		vk::VK_IMAGE_VIEW_TYPE_2D,							// viewType
    829 		format,												// format
    830 		vk::makeComponentMappingRGBA(),						// channels
    831 		{
    832 			vk::VK_IMAGE_ASPECT_COLOR_BIT,						// aspectMask
    833 			0u,													// baseMipLevel
    834 			1u,													// mipLevels
    835 			0u,													// baseArrayLayer
    836 			1u,													// arraySize
    837 		},													// subresourceRange
    838 	};
    839 
    840 	return vk::createImageView(context.getDeviceInterface(), context.getDevice(), &params);
    841 }
    842 
    843 Move<vk::VkRenderPass> createRenderPass (Context& context, vk::VkFormat colorAttFormat)
    844 {
    845 	const vk::VkAttachmentDescription	colorAttDesc		=
    846 	{
    847 		0u,														// flags
    848 		colorAttFormat,											// format
    849 		vk::VK_SAMPLE_COUNT_1_BIT,								// samples
    850 		vk::VK_ATTACHMENT_LOAD_OP_CLEAR,						// loadOp
    851 		vk::VK_ATTACHMENT_STORE_OP_STORE,						// storeOp
    852 		vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE,					// stencilLoadOp
    853 		vk::VK_ATTACHMENT_STORE_OP_DONT_CARE,					// stencilStoreOp
    854 		vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,			// initialLayout
    855 		vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,			// finalLayout
    856 	};
    857 	const vk::VkAttachmentReference		colorAttRef			=
    858 	{
    859 		0u,														// attachment
    860 		vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,			// layout
    861 	};
    862 	const vk::VkAttachmentReference		dsAttRef			=
    863 	{
    864 		vk::VK_NO_ATTACHMENT,									// attachment
    865 		vk::VK_IMAGE_LAYOUT_GENERAL,							// layout
    866 	};
    867 	const vk::VkSubpassDescription		subpassDesc			=
    868 	{
    869 		(vk::VkSubpassDescriptionFlags)0,
    870 		vk::VK_PIPELINE_BIND_POINT_GRAPHICS,					// pipelineBindPoint
    871 		0u,														// inputCount
    872 		DE_NULL,												// pInputAttachments
    873 		1u,														// colorCount
    874 		&colorAttRef,											// pColorAttachments
    875 		DE_NULL,												// pResolveAttachments
    876 		&dsAttRef,												// depthStencilAttachment
    877 		0u,														// preserveCount
    878 		DE_NULL,												// pPreserveAttachments
    879 
    880 	};
    881 	const vk::VkRenderPassCreateInfo	renderPassParams	=
    882 	{
    883 		vk::VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,			// sType
    884 		DE_NULL,												// pNext
    885 		(vk::VkRenderPassCreateFlags)0,
    886 		1u,														// attachmentCount
    887 		&colorAttDesc,											// pAttachments
    888 		1u,														// subpassCount
    889 		&subpassDesc,											// pSubpasses
    890 		0u,														// dependencyCount
    891 		DE_NULL,												// pDependencies
    892 	};
    893 
    894 	return vk::createRenderPass(context.getDeviceInterface(), context.getDevice(), &renderPassParams);
    895 }
    896 
    897 vk::VkShaderStageFlags getVkStageFlags (deUint32 stages)
    898 {
    899 	vk::VkShaderStageFlags	vkStages	= 0u;
    900 
    901 	for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; shaderType++)
    902 	{
    903 		if ((stages & (1u << shaderType)) != 0)
    904 			vkStages |= vk::getVkShaderStage((glu::ShaderType)shaderType);
    905 	}
    906 
    907 	return vkStages;
    908 }
    909 
    910 Move<vk::VkDescriptorSetLayout> createDescriptorSetLayout (Context& context, deUint32 shaderStages)
    911 {
    912 	DE_STATIC_ASSERT(REFERENCE_UNIFORM_BINDING	== 0);
    913 	DE_STATIC_ASSERT(USER_UNIFORM_BINDING		== 1);
    914 
    915 	return vk::DescriptorSetLayoutBuilder()
    916 				.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, vk::VK_SHADER_STAGE_FRAGMENT_BIT)
    917 				.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, getVkStageFlags(shaderStages))
    918 				.build(context.getDeviceInterface(), context.getDevice());
    919 }
    920 
    921 Move<vk::VkPipelineLayout> createPipelineLayout (Context& context, vk::VkDescriptorSetLayout descriptorSetLayout)
    922 {
    923 	const vk::VkPipelineLayoutCreateInfo	params	=
    924 	{
    925 		vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,	// sType
    926 		DE_NULL,											// pNext
    927 		(vk::VkPipelineLayoutCreateFlags)0,
    928 		1u,													// descriptorSetCount
    929 		&descriptorSetLayout,								// pSetLayouts
    930 		0u,													// pushConstantRangeCount
    931 		DE_NULL,											// pPushConstantRanges
    932 	};
    933 
    934 	return vk::createPipelineLayout(context.getDeviceInterface(), context.getDevice(), &params);
    935 }
    936 
    937 vk::VkFormat getVecFormat (DataType scalarType, int scalarSize)
    938 {
    939 	switch (scalarType)
    940 	{
    941 		case glu::TYPE_FLOAT:
    942 		{
    943 			const vk::VkFormat vecFmts[] =
    944 			{
    945 				vk::VK_FORMAT_R32_SFLOAT,
    946 				vk::VK_FORMAT_R32G32_SFLOAT,
    947 				vk::VK_FORMAT_R32G32B32_SFLOAT,
    948 				vk::VK_FORMAT_R32G32B32A32_SFLOAT,
    949 			};
    950 			return de::getSizedArrayElement<4>(vecFmts, scalarSize-1);
    951 		}
    952 
    953 		case glu::TYPE_INT:
    954 		{
    955 			const vk::VkFormat vecFmts[] =
    956 			{
    957 				vk::VK_FORMAT_R32_SINT,
    958 				vk::VK_FORMAT_R32G32_SINT,
    959 				vk::VK_FORMAT_R32G32B32_SINT,
    960 				vk::VK_FORMAT_R32G32B32A32_SINT,
    961 			};
    962 			return de::getSizedArrayElement<4>(vecFmts, scalarSize-1);
    963 		}
    964 
    965 		case glu::TYPE_UINT:
    966 		{
    967 			const vk::VkFormat vecFmts[] =
    968 			{
    969 				vk::VK_FORMAT_R32_UINT,
    970 				vk::VK_FORMAT_R32G32_UINT,
    971 				vk::VK_FORMAT_R32G32B32_UINT,
    972 				vk::VK_FORMAT_R32G32B32A32_UINT,
    973 			};
    974 			return de::getSizedArrayElement<4>(vecFmts, scalarSize-1);
    975 		}
    976 
    977 		case glu::TYPE_BOOL:
    978 		{
    979 			const vk::VkFormat vecFmts[] =
    980 			{
    981 				vk::VK_FORMAT_R32_UINT,
    982 				vk::VK_FORMAT_R32G32_UINT,
    983 				vk::VK_FORMAT_R32G32B32_UINT,
    984 				vk::VK_FORMAT_R32G32B32A32_UINT,
    985 			};
    986 			return de::getSizedArrayElement<4>(vecFmts, scalarSize-1);
    987 		}
    988 
    989 		default:
    990 			DE_FATAL("Unknown scalar type");
    991 			return vk::VK_FORMAT_R8G8B8A8_UINT;
    992 	}
    993 }
    994 
    995 vector<vk::VkVertexInputAttributeDescription> getVertexAttributeDescriptions (const vector<Value>& inputValues, const ValueBufferLayout& layout)
    996 {
    997 	vector<vk::VkVertexInputAttributeDescription>	attribs;
    998 
    999 	// Position
   1000 	{
   1001 		const vk::VkVertexInputAttributeDescription	posDesc	=
   1002 		{
   1003 			0u,								// location
   1004 			0u,								// binding
   1005 			vk::VK_FORMAT_R32G32_SFLOAT,	// format
   1006 			0u,								// offset
   1007 		};
   1008 
   1009 		attribs.push_back(posDesc);
   1010 	}
   1011 
   1012 	// Input values
   1013 	for (size_t inputNdx = 0; inputNdx < inputValues.size(); inputNdx++)
   1014 	{
   1015 		const Value&					input		= inputValues[inputNdx];
   1016 		const ValueBufferLayout::Entry&	layoutEntry	= layout.entries[inputNdx];
   1017 		const DataType					basicType	= input.type.getBasicType();
   1018 		const int						numVecs		= isDataTypeMatrix(basicType)
   1019 													? getDataTypeMatrixNumColumns(basicType)
   1020 													: 1;
   1021 		const int						vecSize		= isDataTypeMatrix(basicType)
   1022 													? getDataTypeMatrixNumRows(basicType)
   1023 													: getDataTypeScalarSize(basicType);
   1024 		const DataType					scalarType	= getDataTypeScalarType(basicType);
   1025 		const vk::VkFormat				vecFmt		= getVecFormat(scalarType, vecSize);
   1026 
   1027 		for (int vecNdx = 0; vecNdx < numVecs; vecNdx++)
   1028 		{
   1029 			const deUint32								curLoc	= (deUint32)attribs.size();
   1030 			const deUint32								offset	= (deUint32)(layoutEntry.offset + layoutEntry.vecStride*vecNdx);
   1031 			const vk::VkVertexInputAttributeDescription	desc	=
   1032 			{
   1033 				curLoc,		// location
   1034 				1u,			// binding
   1035 				vecFmt,		// format
   1036 				offset,		// offset
   1037 			};
   1038 
   1039 			attribs.push_back(desc);
   1040 		}
   1041 	}
   1042 
   1043 	return attribs;
   1044 }
   1045 
   1046 Move<vk::VkPipeline> createPipeline (Context&					context,
   1047 									 const vector<Value>&		inputValues,
   1048 									 const ValueBufferLayout&	inputLayout,
   1049 									 const PipelineProgram&		program,
   1050 									 vk::VkRenderPass			renderPass,
   1051 									 vk::VkPipelineLayout		pipelineLayout,
   1052 									 tcu::UVec2					renderSize)
   1053 {
   1054 	const vector<vk::VkPipelineShaderStageCreateInfo>	shaderStageParams		(getPipelineShaderStageCreateInfo(program));
   1055 	const vector<vk::VkVertexInputAttributeDescription>	vertexAttribParams		(getVertexAttributeDescriptions(inputValues, inputLayout));
   1056 	const vk::VkPipelineDepthStencilStateCreateInfo		depthStencilParams		=
   1057 	{
   1058 		vk::VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,		// sType
   1059 		DE_NULL,															// pNext
   1060 		(vk::VkPipelineDepthStencilStateCreateFlags)0,
   1061 		vk::VK_FALSE,														// depthTestEnable
   1062 		vk::VK_FALSE,														// depthWriteEnable
   1063 		vk::VK_COMPARE_OP_ALWAYS,											// depthCompareOp
   1064 		vk::VK_FALSE,														// depthBoundsTestEnable
   1065 		vk::VK_FALSE,														// stencilTestEnable
   1066 		{
   1067 			vk::VK_STENCIL_OP_KEEP,												// stencilFailOp;
   1068 			vk::VK_STENCIL_OP_KEEP,												// stencilPassOp;
   1069 			vk::VK_STENCIL_OP_KEEP,												// stencilDepthFailOp;
   1070 			vk::VK_COMPARE_OP_ALWAYS,											// stencilCompareOp;
   1071 			0u,																	// stencilCompareMask
   1072 			0u,																	// stencilWriteMask
   1073 			0u,																	// stencilReference
   1074 		},																	// front;
   1075 		{
   1076 			vk::VK_STENCIL_OP_KEEP,												// stencilFailOp;
   1077 			vk::VK_STENCIL_OP_KEEP,												// stencilPassOp;
   1078 			vk::VK_STENCIL_OP_KEEP,												// stencilDepthFailOp;
   1079 			vk::VK_COMPARE_OP_ALWAYS,											// stencilCompareOp;
   1080 			0u,																	// stencilCompareMask
   1081 			0u,																	// stencilWriteMask
   1082 			0u,																	// stencilReference
   1083 		},																	// back;
   1084 		-1.0f,																// minDepthBounds
   1085 		+1.0f,																// maxDepthBounds
   1086 	};
   1087 	const vk::VkViewport								viewport0				=
   1088 	{
   1089 		0.0f,																// originX
   1090 		0.0f,																// originY
   1091 		(float)renderSize.x(),												// width
   1092 		(float)renderSize.y(),												// height
   1093 		0.0f,																// minDepth
   1094 		1.0f,																// maxDepth
   1095 	};
   1096 	const vk::VkRect2D									scissor0				=
   1097 	{
   1098 		{ 0u, 0u },															// offset
   1099 		{ renderSize.x(), renderSize.y() }									// extent
   1100 	};
   1101 	const vk::VkPipelineViewportStateCreateInfo			viewportParams			=
   1102 	{
   1103 		vk::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,			// sType
   1104 		DE_NULL,															// pNext
   1105 		(vk::VkPipelineViewportStateCreateFlags)0,
   1106 		1u,																	// viewportCount
   1107 		&viewport0,															// pViewports
   1108 		1u,																	// scissorCount
   1109 		&scissor0,															// pScissors
   1110 	};
   1111 	const vk::VkPipelineMultisampleStateCreateInfo		multisampleParams		=
   1112 	{
   1113 		vk::VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,		// sType
   1114 		DE_NULL,															// pNext
   1115 		(vk::VkPipelineMultisampleStateCreateFlags)0,
   1116 		vk::VK_SAMPLE_COUNT_1_BIT,											// rasterSamples
   1117 		DE_FALSE,															// sampleShadingEnable
   1118 		0.0f,																// minSampleShading
   1119 		DE_NULL,															// pSampleMask
   1120 		vk::VK_FALSE,														// alphaToCoverageEnable
   1121 		vk::VK_FALSE,														// alphaToOneEnable
   1122 	};
   1123 	const vk::VkPipelineRasterizationStateCreateInfo	rasterParams			=
   1124 	{
   1125 		vk::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,		// sType
   1126 		DE_NULL,															// pNext
   1127 		(vk::VkPipelineRasterizationStateCreateFlags)0,
   1128 		DE_TRUE,															// depthClipEnable
   1129 		DE_FALSE,															// rasterizerDiscardEnable
   1130 		vk::VK_POLYGON_MODE_FILL,											// fillMode
   1131 		vk::VK_CULL_MODE_NONE,												// cullMode;
   1132 		vk::VK_FRONT_FACE_COUNTER_CLOCKWISE,								// frontFace;
   1133 		vk::VK_FALSE,														// depthBiasEnable
   1134 		0.0f,																// depthBiasConstantFactor
   1135 		0.0f,																// depthBiasClamp
   1136 		0.0f,																// depthBiasSlopeFactor
   1137 		1.0f,																// lineWidth
   1138 	};
   1139 	const vk::VkPipelineInputAssemblyStateCreateInfo	inputAssemblyParams		=
   1140 	{
   1141 		vk::VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,	// sType
   1142 		DE_NULL,															// pNext
   1143 		(vk::VkPipelineInputAssemblyStateCreateFlags)0,
   1144 		vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,							// topology
   1145 		DE_FALSE,															// primitiveRestartEnable
   1146 	};
   1147 	const vk::VkVertexInputBindingDescription			vertexBindings[]		=
   1148 	{
   1149 		{
   1150 			0u,																	// binding
   1151 			(deUint32)sizeof(tcu::Vec2),										// stride
   1152 			vk::VK_VERTEX_INPUT_RATE_VERTEX,									// stepRate
   1153 		},
   1154 		{
   1155 			1u,																	// binding
   1156 			0u,																	// stride
   1157 			vk::VK_VERTEX_INPUT_RATE_INSTANCE,									// stepRate
   1158 		},
   1159 	};
   1160 	const vk::VkPipelineVertexInputStateCreateInfo		vertexInputStateParams	=
   1161 	{
   1162 		vk::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,		// sType
   1163 		DE_NULL,															// pNext
   1164 		(vk::VkPipelineVertexInputStateCreateFlags)0,
   1165 		(inputValues.empty() ? 1u : 2u),									// bindingCount
   1166 		vertexBindings,														// pVertexBindingDescriptions
   1167 		(deUint32)vertexAttribParams.size(),								// attributeCount
   1168 		&vertexAttribParams[0],												// pVertexAttributeDescriptions
   1169 	};
   1170 	const vk::VkColorComponentFlags						allCompMask				= vk::VK_COLOR_COMPONENT_R_BIT
   1171 																				| vk::VK_COLOR_COMPONENT_G_BIT
   1172 																				| vk::VK_COLOR_COMPONENT_B_BIT
   1173 																				| vk::VK_COLOR_COMPONENT_A_BIT;
   1174 	const vk::VkPipelineColorBlendAttachmentState		attBlendParams			=
   1175 	{
   1176 		vk::VK_FALSE,														// blendEnable
   1177 		vk::VK_BLEND_FACTOR_ONE,											// srcBlendColor
   1178 		vk::VK_BLEND_FACTOR_ZERO,											// destBlendColor
   1179 		vk::VK_BLEND_OP_ADD,												// blendOpColor
   1180 		vk::VK_BLEND_FACTOR_ONE,											// srcBlendAlpha
   1181 		vk::VK_BLEND_FACTOR_ZERO,											// destBlendAlpha
   1182 		vk::VK_BLEND_OP_ADD,												// blendOpAlpha
   1183 		allCompMask,														// componentWriteMask
   1184 	};
   1185 	const vk::VkPipelineColorBlendStateCreateInfo		blendParams				=
   1186 	{
   1187 		vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,		// sType
   1188 		DE_NULL,															// pNext
   1189 		(vk::VkPipelineColorBlendStateCreateFlags)0,
   1190 		vk::VK_FALSE,														// logicOpEnable
   1191 		vk::VK_LOGIC_OP_COPY,												// logicOp
   1192 		1u,																	// attachmentCount
   1193 		&attBlendParams,													// pAttachments
   1194 		{ 0.0f, 0.0f, 0.0f, 0.0f },											// blendConstants
   1195 	};
   1196 	const vk::VkGraphicsPipelineCreateInfo				pipelineParams			=
   1197 	{
   1198 		vk::VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,				// sType
   1199 		DE_NULL,															// pNext
   1200 		0u,																	// flags
   1201 		(deUint32)shaderStageParams.size(),									// stageCount
   1202 		&shaderStageParams[0],												// pStages
   1203 		&vertexInputStateParams,											// pVertexInputState
   1204 		&inputAssemblyParams,												// pInputAssemblyState
   1205 		DE_NULL,															// pTessellationState
   1206 		&viewportParams,													// pViewportState
   1207 		&rasterParams,														// pRasterState
   1208 		&multisampleParams,													// pMultisampleState
   1209 		&depthStencilParams,												// pDepthStencilState
   1210 		&blendParams,														// pColorBlendState
   1211 		(const vk::VkPipelineDynamicStateCreateInfo*)DE_NULL,				// pDynamicState
   1212 		pipelineLayout,														// layout
   1213 		renderPass,															// renderPass
   1214 		0u,																	// subpass
   1215 		DE_NULL,															// basePipelineHandle
   1216 		0u,																	// basePipelineIndex
   1217 	};
   1218 
   1219 	return vk::createGraphicsPipeline(context.getDeviceInterface(), context.getDevice(), DE_NULL, &pipelineParams);
   1220 }
   1221 
   1222 Move<vk::VkFramebuffer> createFramebuffer (Context& context, vk::VkRenderPass renderPass, vk::VkImageView colorAttView, int width, int height)
   1223 {
   1224 	const vk::VkFramebufferCreateInfo	framebufferParams	=
   1225 	{
   1226 		vk::VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,	// sType
   1227 		DE_NULL,										// pNext
   1228 		(vk::VkFramebufferCreateFlags)0,
   1229 		renderPass,										// renderPass
   1230 		1u,												// attachmentCount
   1231 		&colorAttView,									// pAttachments
   1232 		(deUint32)width,								// width
   1233 		(deUint32)height,								// height
   1234 		1u,												// layers
   1235 	};
   1236 
   1237 	return vk::createFramebuffer(context.getDeviceInterface(), context.getDevice(), &framebufferParams);
   1238 }
   1239 
   1240 Move<vk::VkCommandPool> createCommandPool (Context& context)
   1241 {
   1242 	const deUint32						queueFamilyIndex	= context.getUniversalQueueFamilyIndex();
   1243 	const vk::VkCommandPoolCreateInfo	params				=
   1244 	{
   1245 		vk::VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,		// sType
   1246 		DE_NULL,											// pNext
   1247 		(vk::VkCommandPoolCreateFlags)0,
   1248 		queueFamilyIndex,									// queueFamilyIndex
   1249 	};
   1250 
   1251 	return vk::createCommandPool(context.getDeviceInterface(), context.getDevice(), &params);
   1252 }
   1253 
   1254 Move<vk::VkDescriptorPool> createDescriptorPool (Context& context)
   1255 {
   1256 	return vk::DescriptorPoolBuilder()
   1257 				.addType(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 2u)
   1258 				.build(context.getDeviceInterface(), context.getDevice(), vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
   1259 }
   1260 
   1261 Move<vk::VkDescriptorSet> allocateDescriptorSet (Context& context, vk::VkDescriptorPool descriptorPool, vk::VkDescriptorSetLayout setLayout)
   1262 {
   1263 	const vk::VkDescriptorSetAllocateInfo	params	=
   1264 	{
   1265 		vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
   1266 		DE_NULL,
   1267 		descriptorPool,
   1268 		1u,
   1269 		&setLayout
   1270 	};
   1271 
   1272 	return vk::allocateDescriptorSet(context.getDeviceInterface(), context.getDevice(), &params);
   1273 }
   1274 
   1275 Move<vk::VkCommandBuffer> allocateCommandBuffer (Context& context, vk::VkCommandPool cmdPool)
   1276 {
   1277 	const vk::VkCommandBufferAllocateInfo	params	=
   1278 	{
   1279 		vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,	// sType
   1280 		DE_NULL,											// pNext
   1281 		cmdPool,											// commandPool
   1282 		vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY,				// level
   1283 		1u,													// bufferCount
   1284 	};
   1285 
   1286 	return vk::allocateCommandBuffer(context.getDeviceInterface(), context.getDevice(), &params);
   1287 }
   1288 
   1289 MovePtr<vk::Allocation> allocateAndBindMemory (Context& context, vk::VkBuffer buffer, vk::MemoryRequirement memReqs)
   1290 {
   1291 	const vk::DeviceInterface&		vkd		= context.getDeviceInterface();
   1292 	const vk::VkMemoryRequirements	bufReqs	= vk::getBufferMemoryRequirements(vkd, context.getDevice(), buffer);
   1293 	MovePtr<vk::Allocation>			memory	= context.getDefaultAllocator().allocate(bufReqs, memReqs);
   1294 
   1295 	vkd.bindBufferMemory(context.getDevice(), buffer, memory->getMemory(), memory->getOffset());
   1296 
   1297 	return memory;
   1298 }
   1299 
   1300 MovePtr<vk::Allocation> allocateAndBindMemory (Context& context, vk::VkImage image, vk::MemoryRequirement memReqs)
   1301 {
   1302 	const vk::DeviceInterface&		vkd		= context.getDeviceInterface();
   1303 	const vk::VkMemoryRequirements	imgReqs	= vk::getImageMemoryRequirements(vkd, context.getDevice(), image);
   1304 	MovePtr<vk::Allocation>			memory	= context.getDefaultAllocator().allocate(imgReqs, memReqs);
   1305 
   1306 	vkd.bindImageMemory(context.getDevice(), image, memory->getMemory(), memory->getOffset());
   1307 
   1308 	return memory;
   1309 }
   1310 
   1311 void writeValuesToMem (Context& context, const vk::Allocation& dst, const ValueBufferLayout& layout, const vector<Value>& values, int arrayNdx)
   1312 {
   1313 	copyToLayout(dst.getHostPtr(), layout, values, arrayNdx);
   1314 
   1315 	// \note Buffers are not allocated with coherency / uncached requirement so we need to manually flush CPU write caches
   1316 	flushMappedMemoryRange(context.getDeviceInterface(), context.getDevice(), dst.getMemory(), dst.getOffset(), (vk::VkDeviceSize)layout.size);
   1317 }
   1318 
   1319 class ShaderCaseInstance : public TestInstance
   1320 {
   1321 public:
   1322 													ShaderCaseInstance		(Context& context, const ShaderCaseSpecification& spec);
   1323 													~ShaderCaseInstance		(void);
   1324 
   1325 	TestStatus										iterate					(void);
   1326 
   1327 private:
   1328 	enum
   1329 	{
   1330 		RENDER_WIDTH		= 64,
   1331 		RENDER_HEIGHT		= 64,
   1332 
   1333 		POSITIONS_OFFSET	= 0,
   1334 		POSITIONS_SIZE		= (int)sizeof(Vec2)*4,
   1335 
   1336 		INDICES_OFFSET		= POSITIONS_SIZE,
   1337 		INDICES_SIZE		= (int)sizeof(deUint16)*6,
   1338 
   1339 		TOTAL_POS_NDX_SIZE	= POSITIONS_SIZE+INDICES_SIZE
   1340 	};
   1341 
   1342 	const ShaderCaseSpecification&					m_spec;
   1343 
   1344 	const Unique<vk::VkBuffer>						m_posNdxBuffer;
   1345 	const UniquePtr<vk::Allocation>					m_posNdxMem;
   1346 
   1347 	const ValueBufferLayout							m_inputLayout;
   1348 	const Unique<vk::VkBuffer>						m_inputBuffer;			// Input values (attributes). Can be NULL if no inputs present
   1349 	const UniquePtr<vk::Allocation>					m_inputMem;				// Input memory, can be NULL if no input buffer exists
   1350 
   1351 	const ValueBufferLayout							m_referenceLayout;
   1352 	const Unique<vk::VkBuffer>						m_referenceBuffer;		// Output (reference) values. Can be NULL if no outputs present
   1353 	const UniquePtr<vk::Allocation>					m_referenceMem;			// Output (reference) memory, can be NULL if no reference buffer exists
   1354 
   1355 	const ValueBufferLayout							m_uniformLayout;
   1356 	const Unique<vk::VkBuffer>						m_uniformBuffer;		// Uniform values. Can be NULL if no uniforms present
   1357 	const UniquePtr<vk::Allocation>					m_uniformMem;			// Uniform memory, can be NULL if no uniform buffer exists
   1358 
   1359 	const Unique<vk::VkBuffer>						m_readImageBuffer;
   1360 	const UniquePtr<vk::Allocation>					m_readImageMem;
   1361 
   1362 	const Unique<vk::VkImage>						m_rtImage;
   1363 	const UniquePtr<vk::Allocation>					m_rtMem;
   1364 	const Unique<vk::VkImageView>					m_rtView;
   1365 
   1366 	const Unique<vk::VkRenderPass>					m_renderPass;
   1367 	const Unique<vk::VkFramebuffer>					m_framebuffer;
   1368 	const PipelineProgram							m_program;
   1369 	const Unique<vk::VkDescriptorSetLayout>			m_descriptorSetLayout;
   1370 	const Unique<vk::VkPipelineLayout>				m_pipelineLayout;
   1371 	const Unique<vk::VkPipeline>					m_pipeline;
   1372 
   1373 	const Unique<vk::VkDescriptorPool>				m_descriptorPool;
   1374 	const Unique<vk::VkDescriptorSet>				m_descriptorSet;
   1375 
   1376 	const Unique<vk::VkCommandPool>					m_cmdPool;
   1377 	const Unique<vk::VkCommandBuffer>				m_cmdBuffer;
   1378 
   1379 	int												m_subCaseNdx;
   1380 };
   1381 
   1382 ShaderCaseInstance::ShaderCaseInstance (Context& context, const ShaderCaseSpecification& spec)
   1383 	: TestInstance			(context)
   1384 	, m_spec				(spec)
   1385 
   1386 	, m_posNdxBuffer		(createBuffer(context, (vk::VkDeviceSize)TOTAL_POS_NDX_SIZE, vk::VK_BUFFER_USAGE_INDEX_BUFFER_BIT|vk::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT))
   1387 	, m_posNdxMem			(allocateAndBindMemory(context, *m_posNdxBuffer, vk::MemoryRequirement::HostVisible))
   1388 
   1389 	, m_inputLayout			(computeStd430Layout(spec.values.inputs))
   1390 	, m_inputBuffer			(m_inputLayout.size > 0 ? createBuffer(context, (vk::VkDeviceSize)m_inputLayout.size, vk::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT) : Move<vk::VkBuffer>())
   1391 	, m_inputMem			(m_inputLayout.size > 0 ? allocateAndBindMemory(context, *m_inputBuffer, vk::MemoryRequirement::HostVisible) : MovePtr<vk::Allocation>())
   1392 
   1393 	, m_referenceLayout		(computeStd140Layout(spec.values.outputs))
   1394 	, m_referenceBuffer		(m_referenceLayout.size > 0 ? createBuffer(context, (vk::VkDeviceSize)m_referenceLayout.size, vk::VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) : Move<vk::VkBuffer>())
   1395 	, m_referenceMem		(m_referenceLayout.size > 0 ? allocateAndBindMemory(context, *m_referenceBuffer, vk::MemoryRequirement::HostVisible) : MovePtr<vk::Allocation>())
   1396 
   1397 	, m_uniformLayout		(computeStd140Layout(spec.values.uniforms))
   1398 	, m_uniformBuffer		(m_uniformLayout.size > 0 ? createBuffer(context, (vk::VkDeviceSize)m_uniformLayout.size, vk::VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) : Move<vk::VkBuffer>())
   1399 	, m_uniformMem			(m_uniformLayout.size > 0 ? allocateAndBindMemory(context, *m_uniformBuffer, vk::MemoryRequirement::HostVisible) : MovePtr<vk::Allocation>())
   1400 
   1401 	, m_readImageBuffer		(createBuffer(context, (vk::VkDeviceSize)(RENDER_WIDTH*RENDER_HEIGHT*4), vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT))
   1402 	, m_readImageMem		(allocateAndBindMemory(context, *m_readImageBuffer, vk::MemoryRequirement::HostVisible))
   1403 
   1404 	, m_rtImage				(createImage2D(context, RENDER_WIDTH, RENDER_HEIGHT, vk::VK_FORMAT_R8G8B8A8_UNORM, vk::VK_IMAGE_TILING_OPTIMAL, vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT))
   1405 	, m_rtMem				(allocateAndBindMemory(context, *m_rtImage, vk::MemoryRequirement::Any))
   1406 	, m_rtView				(createAttachmentView(context, *m_rtImage, vk::VK_FORMAT_R8G8B8A8_UNORM))
   1407 
   1408 	, m_renderPass			(createRenderPass(context, vk::VK_FORMAT_R8G8B8A8_UNORM))
   1409 	, m_framebuffer			(createFramebuffer(context, *m_renderPass, *m_rtView, RENDER_WIDTH, RENDER_HEIGHT))
   1410 	, m_program				(context, spec)
   1411 	, m_descriptorSetLayout	(createDescriptorSetLayout(context, m_program.getStages()))
   1412 	, m_pipelineLayout		(createPipelineLayout(context, *m_descriptorSetLayout))
   1413 	, m_pipeline			(createPipeline(context, spec.values.inputs, m_inputLayout, m_program, *m_renderPass, *m_pipelineLayout, tcu::UVec2(RENDER_WIDTH, RENDER_HEIGHT)))
   1414 
   1415 	, m_descriptorPool		(createDescriptorPool(context))
   1416 	, m_descriptorSet		(allocateDescriptorSet(context, *m_descriptorPool, *m_descriptorSetLayout))
   1417 
   1418 	, m_cmdPool				(createCommandPool(context))
   1419 	, m_cmdBuffer			(allocateCommandBuffer(context, *m_cmdPool))
   1420 
   1421 	, m_subCaseNdx			(0)
   1422 {
   1423 	const vk::DeviceInterface&	vkd					= context.getDeviceInterface();
   1424 	const deUint32				queueFamilyIndex	= context.getUniversalQueueFamilyIndex();
   1425 
   1426 	{
   1427 		const Vec2			s_positions[]	=
   1428 		{
   1429 			Vec2(-1.0f, -1.0f),
   1430 			Vec2(-1.0f, +1.0f),
   1431 			Vec2(+1.0f, -1.0f),
   1432 			Vec2(+1.0f, +1.0f)
   1433 		};
   1434 		const deUint16		s_indices[]		=
   1435 		{
   1436 			0, 1, 2,
   1437 			1, 3, 2
   1438 		};
   1439 
   1440 		DE_STATIC_ASSERT(sizeof(s_positions) == POSITIONS_SIZE);
   1441 		DE_STATIC_ASSERT(sizeof(s_indices) == INDICES_SIZE);
   1442 
   1443 		deMemcpy((deUint8*)m_posNdxMem->getHostPtr() + POSITIONS_OFFSET,	&s_positions[0],	sizeof(s_positions));
   1444 		deMemcpy((deUint8*)m_posNdxMem->getHostPtr() + INDICES_OFFSET,		&s_indices[0],		sizeof(s_indices));
   1445 
   1446 		flushMappedMemoryRange(m_context.getDeviceInterface(), context.getDevice(), m_posNdxMem->getMemory(), m_posNdxMem->getOffset(), sizeof(s_positions)+sizeof(s_indices));
   1447 	}
   1448 
   1449 	if (!m_spec.values.uniforms.empty())
   1450 	{
   1451 		const vk::VkDescriptorBufferInfo	bufInfo	=
   1452 		{
   1453 			*m_uniformBuffer,
   1454 			(vk::VkDeviceSize)0,	// offset
   1455 			(vk::VkDeviceSize)m_uniformLayout.size
   1456 		};
   1457 
   1458 		vk::DescriptorSetUpdateBuilder()
   1459 			.writeSingle(*m_descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(USER_UNIFORM_BINDING),
   1460 						 vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &bufInfo)
   1461 			.update(vkd, m_context.getDevice());
   1462 	}
   1463 
   1464 	if (!m_spec.values.outputs.empty())
   1465 	{
   1466 		const vk::VkDescriptorBufferInfo	bufInfo	=
   1467 		{
   1468 			*m_referenceBuffer,
   1469 			(vk::VkDeviceSize)0,	// offset
   1470 			(vk::VkDeviceSize)m_referenceLayout.size
   1471 		};
   1472 
   1473 		vk::DescriptorSetUpdateBuilder()
   1474 			.writeSingle(*m_descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(REFERENCE_UNIFORM_BINDING),
   1475 						 vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &bufInfo)
   1476 			.update(vkd, m_context.getDevice());
   1477 	}
   1478 
   1479 	// Record command buffer
   1480 
   1481 	{
   1482 		const vk::VkCommandBufferBeginInfo beginInfo	=
   1483 		{
   1484 			vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,	// sType
   1485 			DE_NULL,											// pNext
   1486 			0u,													// flags
   1487 			(const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
   1488 		};
   1489 
   1490 		VK_CHECK(vkd.beginCommandBuffer(*m_cmdBuffer, &beginInfo));
   1491 	}
   1492 
   1493 	{
   1494 		const vk::VkMemoryBarrier		vertFlushBarrier	=
   1495 		{
   1496 			vk::VK_STRUCTURE_TYPE_MEMORY_BARRIER,													// sType
   1497 			DE_NULL,																				// pNext
   1498 			vk::VK_ACCESS_HOST_WRITE_BIT,															// srcAccessMask
   1499 			vk::VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT|vk::VK_ACCESS_UNIFORM_READ_BIT,					// dstAccessMask
   1500 		};
   1501 		const vk::VkImageMemoryBarrier	colorAttBarrier		=
   1502 		{
   1503 			vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,		// sType
   1504 			DE_NULL,										// pNext
   1505 			0u,												// srcAccessMask
   1506 			vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,		// dstAccessMask
   1507 			vk::VK_IMAGE_LAYOUT_UNDEFINED,					// oldLayout
   1508 			vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,	// newLayout
   1509 			queueFamilyIndex,								// srcQueueFamilyIndex
   1510 			queueFamilyIndex,								// destQueueFamilyIndex
   1511 			*m_rtImage,										// image
   1512 			{
   1513 				vk::VK_IMAGE_ASPECT_COLOR_BIT,					// aspectMask
   1514 				0u,												// baseMipLevel
   1515 				1u,												// mipLevels
   1516 				0u,												// baseArraySlice
   1517 				1u,												// arraySize
   1518 			}												// subresourceRange
   1519 		};
   1520 
   1521 		vkd.cmdPipelineBarrier(*m_cmdBuffer, vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, (vk::VkDependencyFlags)0,
   1522 							   1, &vertFlushBarrier,
   1523 							   0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
   1524 							   1, &colorAttBarrier);
   1525 	}
   1526 
   1527 	{
   1528 		const vk::VkClearValue			clearValue		= vk::makeClearValueColorF32(0.125f, 0.25f, 0.75f, 1.0f);
   1529 		const vk::VkRenderPassBeginInfo	passBeginInfo	=
   1530 		{
   1531 			vk::VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,	// sType
   1532 			DE_NULL,										// pNext
   1533 			*m_renderPass,									// renderPass
   1534 			*m_framebuffer,									// framebuffer
   1535 			{ { 0, 0 }, { RENDER_WIDTH, RENDER_HEIGHT } },	// renderArea
   1536 			1u,												// clearValueCount
   1537 			&clearValue,									// pClearValues
   1538 		};
   1539 
   1540 		vkd.cmdBeginRenderPass(*m_cmdBuffer, &passBeginInfo, vk::VK_SUBPASS_CONTENTS_INLINE);
   1541 	}
   1542 
   1543 	vkd.cmdBindPipeline(*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
   1544 
   1545 	if (!m_spec.values.uniforms.empty() || !m_spec.values.outputs.empty())
   1546 		vkd.cmdBindDescriptorSets(*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipelineLayout, 0u, 1u, &*m_descriptorSet, 0u, DE_NULL);
   1547 
   1548 	{
   1549 		const vk::VkBuffer		buffers[]	= { *m_posNdxBuffer, *m_inputBuffer };
   1550 		const vk::VkDeviceSize	offsets[]	= { POSITIONS_OFFSET, 0u };
   1551 		const deUint32			numBuffers	= buffers[1] != 0 ? 2u : 1u;
   1552 		vkd.cmdBindVertexBuffers(*m_cmdBuffer, 0u, numBuffers, buffers, offsets);
   1553 	}
   1554 
   1555 	vkd.cmdBindIndexBuffer	(*m_cmdBuffer, *m_posNdxBuffer, (vk::VkDeviceSize)INDICES_OFFSET, vk::VK_INDEX_TYPE_UINT16);
   1556 	vkd.cmdDrawIndexed		(*m_cmdBuffer, 6u, 1u, 0u, 0u, 0u);
   1557 	vkd.cmdEndRenderPass	(*m_cmdBuffer);
   1558 
   1559 	{
   1560 		const vk::VkImageMemoryBarrier	renderFinishBarrier	=
   1561 		{
   1562 			vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,		// sType
   1563 			DE_NULL,										// pNext
   1564 			vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,		// srcAccessMask
   1565 			vk::VK_ACCESS_TRANSFER_READ_BIT,				// dstAccessMask
   1566 			vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,	// oldLayout
   1567 			vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,		// newLayout
   1568 			queueFamilyIndex,								// srcQueueFamilyIndex
   1569 			queueFamilyIndex,								// destQueueFamilyIndex
   1570 			*m_rtImage,										// image
   1571 			{
   1572 				vk::VK_IMAGE_ASPECT_COLOR_BIT,					// aspectMask
   1573 				0u,												// baseMipLevel
   1574 				1u,												// mipLevels
   1575 				0u,												// baseArraySlice
   1576 				1u,												// arraySize
   1577 			}												// subresourceRange
   1578 		};
   1579 
   1580 		vkd.cmdPipelineBarrier(*m_cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0,
   1581 							   0, (const vk::VkMemoryBarrier*)DE_NULL,
   1582 							   0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
   1583 							   1, &renderFinishBarrier);
   1584 	}
   1585 
   1586 	{
   1587 		const vk::VkBufferImageCopy	copyParams	=
   1588 		{
   1589 			(vk::VkDeviceSize)0u,					// bufferOffset
   1590 			(deUint32)RENDER_WIDTH,					// bufferRowLength
   1591 			(deUint32)RENDER_HEIGHT,				// bufferImageHeight
   1592 			{
   1593 				vk::VK_IMAGE_ASPECT_COLOR_BIT,			// aspect
   1594 				0u,										// mipLevel
   1595 				0u,										// arrayLayer
   1596 				1u,										// arraySize
   1597 			},										// imageSubresource
   1598 			{ 0u, 0u, 0u },							// imageOffset
   1599 			{ RENDER_WIDTH, RENDER_HEIGHT, 1u }		// imageExtent
   1600 		};
   1601 
   1602 		vkd.cmdCopyImageToBuffer(*m_cmdBuffer, *m_rtImage, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *m_readImageBuffer, 1u, &copyParams);
   1603 	}
   1604 
   1605 	{
   1606 		const vk::VkBufferMemoryBarrier	copyFinishBarrier	=
   1607 		{
   1608 			vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,		// sType
   1609 			DE_NULL,											// pNext
   1610 			vk::VK_ACCESS_TRANSFER_WRITE_BIT,					// srcAccessMask
   1611 			vk::VK_ACCESS_HOST_READ_BIT,						// dstAccessMask
   1612 			queueFamilyIndex,									// srcQueueFamilyIndex
   1613 			queueFamilyIndex,									// destQueueFamilyIndex
   1614 			*m_readImageBuffer,									// buffer
   1615 			0u,													// offset
   1616 			(vk::VkDeviceSize)(RENDER_WIDTH*RENDER_HEIGHT*4)	// size
   1617 		};
   1618 
   1619 		vkd.cmdPipelineBarrier(*m_cmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0,
   1620 							   0, (const vk::VkMemoryBarrier*)DE_NULL,
   1621 							   1, &copyFinishBarrier,
   1622 							   0, (const vk::VkImageMemoryBarrier*)DE_NULL);
   1623 	}
   1624 
   1625 	VK_CHECK(vkd.endCommandBuffer(*m_cmdBuffer));
   1626 }
   1627 
   1628 ShaderCaseInstance::~ShaderCaseInstance (void)
   1629 {
   1630 }
   1631 
   1632 int getNumSubCases (const ValueBlock& values)
   1633 {
   1634 	if (!values.outputs.empty())
   1635 		return int(values.outputs[0].elements.size() / values.outputs[0].type.getScalarSize());
   1636 	else
   1637 		return 1; // Always run at least one iteration even if no output values are specified
   1638 }
   1639 
   1640 bool checkResultImage (const ConstPixelBufferAccess& result)
   1641 {
   1642 	const tcu::IVec4	refPix	(255, 255, 255, 255);
   1643 
   1644 	for (int y = 0; y < result.getHeight(); y++)
   1645 	{
   1646 		for (int x = 0; x < result.getWidth(); x++)
   1647 		{
   1648 			const tcu::IVec4	resPix	= result.getPixelInt(x, y);
   1649 
   1650 			if (boolAny(notEqual(resPix, refPix)))
   1651 				return false;
   1652 		}
   1653 	}
   1654 
   1655 	return true;
   1656 }
   1657 
   1658 TestStatus ShaderCaseInstance::iterate (void)
   1659 {
   1660 	const vk::DeviceInterface&	vkd		= m_context.getDeviceInterface();
   1661 	const vk::VkDevice			device	= m_context.getDevice();
   1662 	const vk::VkQueue			queue	= m_context.getUniversalQueue();
   1663 
   1664 	if (!m_spec.values.inputs.empty())
   1665 		writeValuesToMem(m_context, *m_inputMem, m_inputLayout, m_spec.values.inputs, m_subCaseNdx);
   1666 
   1667 	if (!m_spec.values.outputs.empty())
   1668 		writeValuesToMem(m_context, *m_referenceMem, m_referenceLayout, m_spec.values.outputs, m_subCaseNdx);
   1669 
   1670 	if (!m_spec.values.uniforms.empty())
   1671 		writeValuesToMem(m_context, *m_uniformMem, m_uniformLayout, m_spec.values.uniforms, m_subCaseNdx);
   1672 
   1673 	{
   1674 		const vk::VkSubmitInfo		submitInfo	=
   1675 		{
   1676 			vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
   1677 			DE_NULL,
   1678 			0u,											// waitSemaphoreCount
   1679 			(const vk::VkSemaphore*)0,					// pWaitSemaphores
   1680 			(const vk::VkPipelineStageFlags*)DE_NULL,
   1681 			1u,
   1682 			&m_cmdBuffer.get(),
   1683 			0u,											// signalSemaphoreCount
   1684 			(const vk::VkSemaphore*)0,					// pSignalSemaphores
   1685 		};
   1686 		const vk::VkFenceCreateInfo	fenceParams	=
   1687 		{
   1688 			vk::VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,	// sType
   1689 			DE_NULL,									// pNext
   1690 			0u,											// flags
   1691 		};
   1692 		const Unique<vk::VkFence>	fence		(vk::createFence(vkd, device, &fenceParams));
   1693 
   1694 		VK_CHECK(vkd.queueSubmit	(queue, 1u, &submitInfo, *fence));
   1695 		VK_CHECK(vkd.waitForFences	(device, 1u, &fence.get(), DE_TRUE, ~0ull));
   1696 	}
   1697 
   1698 	{
   1699 		const ConstPixelBufferAccess	imgAccess	(TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), RENDER_WIDTH, RENDER_HEIGHT, 1, m_readImageMem->getHostPtr());
   1700 
   1701 		invalidateMappedMemoryRange(vkd, device, m_readImageMem->getMemory(), m_readImageMem->getOffset(), (vk::VkDeviceSize)(RENDER_WIDTH*RENDER_HEIGHT*4));
   1702 
   1703 		if (!checkResultImage(imgAccess))
   1704 		{
   1705 			TestLog&	log		= m_context.getTestContext().getLog();
   1706 
   1707 			log << TestLog::Message << "ERROR: Got non-white pixels on sub-case " << m_subCaseNdx << TestLog::EndMessage
   1708 				<< TestLog::Image("Result", "Result", imgAccess);
   1709 
   1710 			dumpValues(log, m_spec.values, m_subCaseNdx);
   1711 
   1712 			return TestStatus::fail(string("Got invalid pixels at sub-case ") + de::toString(m_subCaseNdx));
   1713 		}
   1714 	}
   1715 
   1716 	if (++m_subCaseNdx < getNumSubCases(m_spec.values))
   1717 		return TestStatus::incomplete();
   1718 	else
   1719 		return TestStatus::pass("All sub-cases passed");
   1720 }
   1721 
   1722 class ShaderCase : public TestCase
   1723 {
   1724 public:
   1725 									ShaderCase		(tcu::TestContext& testCtx, const string& name, const string& description, const ShaderCaseSpecification& spec);
   1726 
   1727 
   1728 	void							initPrograms	(SourceCollections& programCollection) const;
   1729 	TestInstance*					createInstance	(Context& context) const;
   1730 
   1731 private:
   1732 	const ShaderCaseSpecification	m_spec;
   1733 };
   1734 
   1735 ShaderCase::ShaderCase (tcu::TestContext& testCtx, const string& name, const string& description, const ShaderCaseSpecification& spec)
   1736 	: TestCase	(testCtx, name, description)
   1737 	, m_spec	(spec)
   1738 {
   1739 }
   1740 
   1741 void ShaderCase::initPrograms (SourceCollections& sourceCollection) const
   1742 {
   1743 	vector<ProgramSources>	specializedSources	(m_spec.programs.size());
   1744 
   1745 	DE_ASSERT(isValid(m_spec));
   1746 
   1747 	if (m_spec.expectResult != glu::sl::EXPECT_PASS)
   1748 		TCU_THROW(InternalError, "Only EXPECT_PASS is supported");
   1749 
   1750 	if (m_spec.caseType == glu::sl::CASETYPE_VERTEX_ONLY)
   1751 	{
   1752 		DE_ASSERT(m_spec.programs.size() == 1 && m_spec.programs[0].sources.sources[glu::SHADERTYPE_VERTEX].size() == 1);
   1753 		specializedSources[0] << glu::VertexSource(specializeVertexShader(m_spec, m_spec.programs[0].sources.sources[glu::SHADERTYPE_VERTEX][0]))
   1754 							  << glu::FragmentSource(genFragmentShader(m_spec));
   1755 	}
   1756 	else if (m_spec.caseType == glu::sl::CASETYPE_FRAGMENT_ONLY)
   1757 	{
   1758 		DE_ASSERT(m_spec.programs.size() == 1 && m_spec.programs[0].sources.sources[glu::SHADERTYPE_FRAGMENT].size() == 1);
   1759 		specializedSources[0] << glu::VertexSource(genVertexShader(m_spec))
   1760 							  << glu::FragmentSource(specializeFragmentShader(m_spec, m_spec.programs[0].sources.sources[glu::SHADERTYPE_FRAGMENT][0]));
   1761 	}
   1762 	else
   1763 	{
   1764 		DE_ASSERT(m_spec.caseType == glu::sl::CASETYPE_COMPLETE);
   1765 
   1766 		const int	maxPatchVertices	= 4; // \todo [2015-08-05 pyry] Query
   1767 
   1768 		for (size_t progNdx = 0; progNdx < m_spec.programs.size(); progNdx++)
   1769 		{
   1770 			const ProgramSpecializationParams	progSpecParams	(m_spec, m_spec.programs[progNdx].requiredExtensions, maxPatchVertices);
   1771 
   1772 			specializeProgramSources(specializedSources[progNdx], m_spec.programs[progNdx].sources, progSpecParams);
   1773 		}
   1774 	}
   1775 
   1776 	for (size_t progNdx = 0; progNdx < specializedSources.size(); progNdx++)
   1777 	{
   1778 		for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; shaderType++)
   1779 		{
   1780 			if (!specializedSources[progNdx].sources[shaderType].empty())
   1781 			{
   1782 				glu::ProgramSources& curSrc	= sourceCollection.glslSources.add(getShaderName((glu::ShaderType)shaderType, progNdx));
   1783 				curSrc.sources[shaderType] = specializedSources[progNdx].sources[shaderType];
   1784 			}
   1785 		}
   1786 	}
   1787 }
   1788 
   1789 TestInstance* ShaderCase::createInstance (Context& context) const
   1790 {
   1791 	return new ShaderCaseInstance(context, m_spec);
   1792 }
   1793 
   1794 class ShaderCaseFactory : public glu::sl::ShaderCaseFactory
   1795 {
   1796 public:
   1797 	ShaderCaseFactory (tcu::TestContext& testCtx)
   1798 		: m_testCtx(testCtx)
   1799 	{
   1800 	}
   1801 
   1802 	tcu::TestCaseGroup* createGroup (const string& name, const string& description, const vector<tcu::TestNode*>& children)
   1803 	{
   1804 		return new tcu::TestCaseGroup(m_testCtx, name.c_str(), description.c_str(), children);
   1805 	}
   1806 
   1807 	tcu::TestCase* createCase (const string& name, const string& description, const ShaderCaseSpecification& spec)
   1808 	{
   1809 		return new ShaderCase(m_testCtx, name, description, spec);
   1810 	}
   1811 
   1812 private:
   1813 	tcu::TestContext&	m_testCtx;
   1814 };
   1815 
   1816 class ShaderLibraryGroup : public tcu::TestCaseGroup
   1817 {
   1818 public:
   1819 	ShaderLibraryGroup (tcu::TestContext& testCtx, const string& name, const string& description, const string& filename)
   1820 		 : tcu::TestCaseGroup	(testCtx, name.c_str(), description.c_str())
   1821 		 , m_filename			(filename)
   1822 	{
   1823 	}
   1824 
   1825 	void init (void)
   1826 	{
   1827 		ShaderCaseFactory				caseFactory	(m_testCtx);
   1828 		const vector<tcu::TestNode*>	children	= glu::sl::parseFile(m_testCtx.getArchive(), m_filename, &caseFactory);
   1829 
   1830 		for (size_t ndx = 0; ndx < children.size(); ndx++)
   1831 		{
   1832 			try
   1833 			{
   1834 				addChild(children[ndx]);
   1835 			}
   1836 			catch (...)
   1837 			{
   1838 				for (; ndx < children.size(); ndx++)
   1839 					delete children[ndx];
   1840 				throw;
   1841 			}
   1842 		}
   1843 	}
   1844 
   1845 private:
   1846 	const string	m_filename;
   1847 };
   1848 
   1849 } // anonymous
   1850 
   1851 MovePtr<tcu::TestCaseGroup> createShaderLibraryGroup (tcu::TestContext& testCtx, const string& name, const string& description, const string& filename)
   1852 {
   1853 	return MovePtr<tcu::TestCaseGroup>(new ShaderLibraryGroup(testCtx, name, description, filename));
   1854 }
   1855 
   1856 } // vkt
   1857