1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL (ES) Module 3 * ----------------------------------------------- 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Compiler test case. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "glsShaderLibraryCase.hpp" 25 26 #include "tcuTestLog.hpp" 27 #include "tcuRenderTarget.hpp" 28 #include "tcuTextureUtil.hpp" 29 #include "tcuSurface.hpp" 30 31 #include "tcuStringTemplate.hpp" 32 #include "gluShaderProgram.hpp" 33 #include "gluPixelTransfer.hpp" 34 #include "gluDrawUtil.hpp" 35 #include "gluContextInfo.hpp" 36 #include "gluStrUtil.hpp" 37 38 #include "glwFunctions.hpp" 39 #include "glwEnums.hpp" 40 41 #include "deRandom.hpp" 42 #include "deInt32.h" 43 #include "deMath.h" 44 #include "deString.h" 45 #include "deStringUtil.hpp" 46 #include "deSharedPtr.hpp" 47 48 #include <map> 49 #include <vector> 50 #include <string> 51 #include <sstream> 52 53 namespace deqp 54 { 55 namespace gls 56 { 57 58 using namespace tcu; 59 using namespace glu; 60 using namespace glu::sl; 61 62 using std::vector; 63 using std::string; 64 using std::ostringstream; 65 using std::map; 66 using std::pair; 67 68 using de::SharedPtr; 69 70 // OpenGL-specific specialization utils 71 72 static vector<RequiredExtension> checkAndSpecializeExtensions (const vector<RequiredExtension>& src, 73 const ContextInfo& ctxInfo) 74 { 75 vector<RequiredExtension> specialized; 76 77 for (size_t extNdx = 0; extNdx < src.size(); ++extNdx) 78 { 79 const RequiredExtension& extension = src[extNdx]; 80 int supportedAltNdx = -1; 81 82 for (size_t alternativeNdx = 0; alternativeNdx < extension.alternatives.size(); ++alternativeNdx) 83 { 84 if (ctxInfo.isExtensionSupported(extension.alternatives[alternativeNdx].c_str())) 85 { 86 supportedAltNdx = (int)alternativeNdx; 87 break; 88 } 89 } 90 91 if (supportedAltNdx >= 0) 92 { 93 specialized.push_back(RequiredExtension(extension.alternatives[supportedAltNdx], extension.effectiveStages)); 94 } 95 else 96 { 97 // no extension(s). Make a nice output 98 std::ostringstream extensionList; 99 100 for (size_t ndx = 0; ndx < extension.alternatives.size(); ++ndx) 101 { 102 if (!extensionList.str().empty()) 103 extensionList << ", "; 104 extensionList << extension.alternatives[ndx]; 105 } 106 107 if (extension.alternatives.size() == 1) 108 throw tcu::NotSupportedError("Test requires extension " + extensionList.str()); 109 else 110 throw tcu::NotSupportedError("Test requires any extension of " + extensionList.str()); 111 } 112 } 113 114 return specialized; 115 } 116 117 static void checkImplementationLimits (const vector<RequiredCapability>& requiredCaps, 118 const ContextInfo& ctxInfo) 119 { 120 for (size_t capNdx = 0; capNdx < requiredCaps.size(); ++capNdx) 121 { 122 const deUint32 pname = requiredCaps[capNdx].enumName; 123 const int requiredValue = requiredCaps[capNdx].referenceValue; 124 const int supportedValue = ctxInfo.getInt((int)pname); 125 126 if (supportedValue <= requiredValue) 127 throw tcu::NotSupportedError("Test requires " + de::toString(glu::getGettableStateStr(pname)) + " (" + de::toString(supportedValue) + ") >= " + de::toString(requiredValue)); 128 } 129 } 130 131 // Shader source specialization 132 133 // This functions builds a matching vertex shader for a 'both' case, when 134 // the fragment shader is being tested. 135 // We need to build attributes and varyings for each 'input'. 136 static string genVertexShader (const ShaderCaseSpecification& spec) 137 { 138 ostringstream res; 139 const bool usesInout = glslVersionUsesInOutQualifiers(spec.targetVersion); 140 const char* const vtxIn = usesInout ? "in" : "attribute"; 141 const char* const vtxOut = usesInout ? "out" : "varying"; 142 143 res << glu::getGLSLVersionDeclaration(spec.targetVersion) << "\n"; 144 145 // Declarations (position + attribute/varying for each input). 146 res << "precision highp float;\n"; 147 res << "precision highp int;\n"; 148 res << "\n"; 149 res << vtxIn << " highp vec4 dEQP_Position;\n"; 150 151 for (size_t ndx = 0; ndx < spec.values.inputs.size(); ndx++) 152 { 153 const Value& val = spec.values.inputs[ndx]; 154 const DataType basicType = val.type.getBasicType(); 155 const DataType floatType = getDataTypeFloatScalars(basicType); 156 const char* const typeStr = getDataTypeName(floatType); 157 158 res << vtxIn << " " << typeStr << " a_" << val.name << ";\n"; 159 160 if (getDataTypeScalarType(basicType) == TYPE_FLOAT) 161 res << vtxOut << " " << typeStr << " " << val.name << ";\n"; 162 else 163 res << vtxOut << " " << typeStr << " v_" << val.name << ";\n"; 164 } 165 res << "\n"; 166 167 // Main function. 168 // - gl_Position = dEQP_Position; 169 // - for each input: write attribute directly to varying 170 res << "void main()\n"; 171 res << "{\n"; 172 res << " gl_Position = dEQP_Position;\n"; 173 for (size_t ndx = 0; ndx < spec.values.inputs.size(); ndx++) 174 { 175 const Value& val = spec.values.inputs[ndx]; 176 const string& name = val.name; 177 178 if (getDataTypeScalarType(val.type.getBasicType()) == TYPE_FLOAT) 179 res << " " << name << " = a_" << name << ";\n"; 180 else 181 res << " v_" << name << " = a_" << name << ";\n"; 182 } 183 184 res << "}\n"; 185 return res.str(); 186 } 187 188 static void genCompareOp (ostringstream& output, const char* dstVec4Var, const ValueBlock& valueBlock, const char* nonFloatNamePrefix, const char* checkVarName) 189 { 190 bool isFirstOutput = true; 191 192 for (size_t ndx = 0; ndx < valueBlock.outputs.size(); ndx++) 193 { 194 const Value& val = valueBlock.outputs[ndx]; 195 196 // Check if we're only interested in one variable (then skip if not the right one). 197 if (checkVarName && val.name != checkVarName) 198 continue; 199 200 // Prefix. 201 if (isFirstOutput) 202 { 203 output << "bool RES = "; 204 isFirstOutput = false; 205 } 206 else 207 output << "RES = RES && "; 208 209 // Generate actual comparison. 210 if (getDataTypeScalarType(val.type.getBasicType()) == TYPE_FLOAT) 211 output << "isOk(" << val.name << ", ref_" << val.name << ", 0.05);\n"; 212 else 213 output << "isOk(" << nonFloatNamePrefix << val.name << ", ref_" << val.name << ");\n"; 214 } 215 216 if (isFirstOutput) 217 output << dstVec4Var << " = vec4(1.0);\n"; // \todo [petri] Should we give warning if not expect-failure case? 218 else 219 output << dstVec4Var << " = vec4(RES, RES, RES, 1.0);\n"; 220 } 221 222 static inline bool supportsFragmentHighp (glu::GLSLVersion version) 223 { 224 return version != glu::GLSL_VERSION_100_ES; 225 } 226 227 static string genFragmentShader (const ShaderCaseSpecification& spec) 228 { 229 ostringstream shader; 230 const bool usesInout = glslVersionUsesInOutQualifiers(spec.targetVersion); 231 const bool customColorOut = usesInout; 232 const char* const fragIn = usesInout ? "in" : "varying"; 233 const char* const prec = supportsFragmentHighp(spec.targetVersion) ? "highp" : "mediump"; 234 235 shader << glu::getGLSLVersionDeclaration(spec.targetVersion) << "\n"; 236 237 shader << "precision " << prec << " float;\n"; 238 shader << "precision " << prec << " int;\n"; 239 shader << "\n"; 240 241 if (customColorOut) 242 { 243 shader << "layout(location = 0) out mediump vec4 dEQP_FragColor;\n"; 244 shader << "\n"; 245 } 246 247 genCompareFunctions(shader, spec.values, true); 248 shader << "\n"; 249 250 // Declarations (varying, reference for each output). 251 for (size_t ndx = 0; ndx < spec.values.outputs.size(); ndx++) 252 { 253 const Value& val = spec.values.outputs[ndx]; 254 const DataType basicType = val.type.getBasicType(); 255 const DataType floatType = getDataTypeFloatScalars(basicType); 256 const char* const floatTypeStr = getDataTypeName(floatType); 257 const char* const refTypeStr = getDataTypeName(basicType); 258 259 if (getDataTypeScalarType(basicType) == TYPE_FLOAT) 260 shader << fragIn << " " << floatTypeStr << " " << val.name << ";\n"; 261 else 262 shader << fragIn << " " << floatTypeStr << " v_" << val.name << ";\n"; 263 264 shader << "uniform " << refTypeStr << " ref_" << val.name << ";\n"; 265 } 266 267 shader << "\n"; 268 shader << "void main()\n"; 269 shader << "{\n"; 270 271 shader << " "; 272 genCompareOp(shader, customColorOut ? "dEQP_FragColor" : "gl_FragColor", spec.values, "v_", DE_NULL); 273 274 shader << "}\n"; 275 return shader.str(); 276 } 277 278 // Specialize a shader for the vertex shader test case. 279 static string specializeVertexShader (const ShaderCaseSpecification& spec, const std::string& src, const vector<RequiredExtension>& extensions) 280 { 281 ostringstream decl; 282 ostringstream setup; 283 ostringstream output; 284 const bool usesInout = glslVersionUsesInOutQualifiers(spec.targetVersion); 285 const char* const vtxIn = usesInout ? "in" : "attribute"; 286 const char* const vtxOut = usesInout ? "out" : "varying"; 287 288 // generated from "both" case 289 DE_ASSERT(spec.caseType == CASETYPE_VERTEX_ONLY); 290 291 // Output (write out position). 292 output << "gl_Position = dEQP_Position;\n"; 293 294 // Declarations (position + attribute for each input, varying for each output). 295 decl << vtxIn << " highp vec4 dEQP_Position;\n"; 296 297 for (size_t ndx = 0; ndx < spec.values.inputs.size(); ndx++) 298 { 299 const Value& val = spec.values.inputs[ndx]; 300 const DataType basicType = val.type.getBasicType(); 301 const DataType floatType = getDataTypeFloatScalars(basicType); 302 const char* const floatTypeStr = getDataTypeName(floatType); 303 const char* const refTypeStr = getDataTypeName(basicType); 304 305 if (getDataTypeScalarType(basicType) == TYPE_FLOAT) 306 { 307 decl << vtxIn << " " << floatTypeStr << " " << val.name << ";\n"; 308 } 309 else 310 { 311 decl << vtxIn << " " << floatTypeStr << " a_" << val.name << ";\n"; 312 setup << refTypeStr << " " << val.name << " = " << refTypeStr << "(a_" << val.name << ");\n"; 313 } 314 } 315 316 // \todo [2015-07-24 pyry] Why are uniforms missing? 317 318 for (size_t ndx = 0; ndx < spec.values.outputs.size(); ndx++) 319 { 320 const Value& val = spec.values.outputs[ndx]; 321 const DataType basicType = val.type.getBasicType(); 322 const DataType floatType = getDataTypeFloatScalars(basicType); 323 const char* const floatTypeStr = getDataTypeName(floatType); 324 const char* const refTypeStr = getDataTypeName(basicType); 325 326 if (getDataTypeScalarType(basicType) == TYPE_FLOAT) 327 decl << vtxOut << " " << floatTypeStr << " " << val.name << ";\n"; 328 else 329 { 330 decl << vtxOut << " " << floatTypeStr << " v_" << val.name << ";\n"; 331 decl << refTypeStr << " " << val.name << ";\n"; 332 333 output << "v_" << val.name << " = " << floatTypeStr << "(" << val.name << ");\n"; 334 } 335 } 336 337 // Shader specialization. 338 map<string, string> params; 339 params.insert(pair<string, string>("DECLARATIONS", decl.str())); 340 params.insert(pair<string, string>("SETUP", setup.str())); 341 params.insert(pair<string, string>("OUTPUT", output.str())); 342 params.insert(pair<string, string>("POSITION_FRAG_COLOR", "gl_Position")); 343 344 StringTemplate tmpl (src); 345 const string baseSrc = tmpl.specialize(params); 346 const string withExt = injectExtensionRequirements(baseSrc, extensions, SHADERTYPE_VERTEX); 347 348 return withExt; 349 } 350 351 // Specialize a shader for the fragment shader test case. 352 static string specializeFragmentShader (const ShaderCaseSpecification& spec, const std::string& src, const vector<RequiredExtension>& extensions) 353 { 354 ostringstream decl; 355 ostringstream setup; 356 ostringstream output; 357 358 const bool usesInout = glslVersionUsesInOutQualifiers(spec.targetVersion); 359 const bool customColorOut = usesInout; 360 const char* const fragIn = usesInout ? "in" : "varying"; 361 const char* const fragColor = customColorOut ? "dEQP_FragColor" : "gl_FragColor"; 362 363 // generated from "both" case 364 DE_ASSERT(spec.caseType == CASETYPE_FRAGMENT_ONLY); 365 366 genCompareFunctions(decl, spec.values, false); 367 genCompareOp(output, fragColor, spec.values, "", DE_NULL); 368 369 if (customColorOut) 370 decl << "layout(location = 0) out mediump vec4 dEQP_FragColor;\n"; 371 372 for (size_t ndx = 0; ndx < spec.values.inputs.size(); ndx++) 373 { 374 const Value& val = spec.values.inputs[ndx]; 375 const DataType basicType = val.type.getBasicType(); 376 const DataType floatType = getDataTypeFloatScalars(basicType); 377 const char* const floatTypeStr = getDataTypeName(floatType); 378 const char* const refTypeStr = getDataTypeName(basicType); 379 380 if (getDataTypeScalarType(basicType) == TYPE_FLOAT) 381 decl << fragIn << " " << floatTypeStr << " " << val.name << ";\n"; 382 else 383 { 384 decl << fragIn << " " << floatTypeStr << " v_" << val.name << ";\n"; 385 std::string offset = isDataTypeIntOrIVec(basicType) ? " * 1.0025" : ""; // \todo [petri] bit of a hack to avoid errors in chop() due to varying interpolation 386 setup << refTypeStr << " " << val.name << " = " << refTypeStr << "(v_" << val.name << offset << ");\n"; 387 } 388 } 389 390 // \todo [2015-07-24 pyry] Why are uniforms missing? 391 392 for (size_t ndx = 0; ndx < spec.values.outputs.size(); ndx++) 393 { 394 const Value& val = spec.values.outputs[ndx]; 395 const DataType basicType = val.type.getBasicType(); 396 const char* const refTypeStr = getDataTypeName(basicType); 397 398 decl << "uniform " << refTypeStr << " ref_" << val.name << ";\n"; 399 decl << refTypeStr << " " << val.name << ";\n"; 400 } 401 402 /* \todo [2010-04-01 petri] Check all outputs. */ 403 404 // Shader specialization. 405 map<string, string> params; 406 params.insert(pair<string, string>("DECLARATIONS", decl.str())); 407 params.insert(pair<string, string>("SETUP", setup.str())); 408 params.insert(pair<string, string>("OUTPUT", output.str())); 409 params.insert(pair<string, string>("POSITION_FRAG_COLOR", fragColor)); 410 411 StringTemplate tmpl (src); 412 const string baseSrc = tmpl.specialize(params); 413 const string withExt = injectExtensionRequirements(baseSrc, extensions, SHADERTYPE_FRAGMENT); 414 415 return withExt; 416 } 417 418 static void generateUniformDeclarations (std::ostream& dst, const ValueBlock& valueBlock) 419 { 420 for (size_t ndx = 0; ndx < valueBlock.uniforms.size(); ndx++) 421 { 422 const Value& val = valueBlock.uniforms[ndx]; 423 const char* const typeStr = getDataTypeName(val.type.getBasicType()); 424 425 if (val.name.find('.') == string::npos) 426 dst << "uniform " << typeStr << " " << val.name << ";\n"; 427 } 428 } 429 430 static map<string, string> generateVertexSpecialization (const ProgramSpecializationParams& specParams) 431 { 432 const bool usesInout = glslVersionUsesInOutQualifiers(specParams.caseSpec.targetVersion); 433 const char* vtxIn = usesInout ? "in" : "attribute"; 434 ostringstream decl; 435 ostringstream setup; 436 map<string, string> params; 437 438 decl << vtxIn << " highp vec4 dEQP_Position;\n"; 439 440 for (size_t ndx = 0; ndx < specParams.caseSpec.values.inputs.size(); ndx++) 441 { 442 const Value& val = specParams.caseSpec.values.inputs[ndx]; 443 const DataType basicType = val.type.getBasicType(); 444 const char* const typeStr = getDataTypeName(val.type.getBasicType()); 445 446 if (getDataTypeScalarType(basicType) == TYPE_FLOAT) 447 { 448 decl << vtxIn << " " << typeStr << " " << val.name << ";\n"; 449 } 450 else 451 { 452 const DataType floatType = getDataTypeFloatScalars(basicType); 453 const char* const floatTypeStr = getDataTypeName(floatType); 454 455 decl << vtxIn << " " << floatTypeStr << " a_" << val.name << ";\n"; 456 setup << typeStr << " " << val.name << " = " << typeStr << "(a_" << val.name << ");\n"; 457 } 458 } 459 460 generateUniformDeclarations(decl, specParams.caseSpec.values); 461 462 params.insert(pair<string, string>("VERTEX_DECLARATIONS", decl.str())); 463 params.insert(pair<string, string>("VERTEX_SETUP", setup.str())); 464 params.insert(pair<string, string>("VERTEX_OUTPUT", string("gl_Position = dEQP_Position;\n"))); 465 466 return params; 467 } 468 469 static map<string, string> generateFragmentSpecialization (const ProgramSpecializationParams& specParams) 470 { 471 const bool usesInout = glslVersionUsesInOutQualifiers(specParams.caseSpec.targetVersion); 472 const bool customColorOut = usesInout; 473 const char* const fragColor = customColorOut ? "dEQP_FragColor" : "gl_FragColor"; 474 ostringstream decl; 475 ostringstream output; 476 map<string, string> params; 477 478 genCompareFunctions(decl, specParams.caseSpec.values, false); 479 genCompareOp(output, fragColor, specParams.caseSpec.values, "", DE_NULL); 480 481 if (customColorOut) 482 decl << "layout(location = 0) out mediump vec4 dEQP_FragColor;\n"; 483 484 for (size_t ndx = 0; ndx < specParams.caseSpec.values.outputs.size(); ndx++) 485 { 486 const Value& val = specParams.caseSpec.values.outputs[ndx]; 487 const char* const refTypeStr = getDataTypeName(val.type.getBasicType()); 488 489 decl << "uniform " << refTypeStr << " ref_" << val.name << ";\n"; 490 decl << refTypeStr << " " << val.name << ";\n"; 491 } 492 493 generateUniformDeclarations(decl, specParams.caseSpec.values); 494 495 params.insert(pair<string, string>("FRAGMENT_DECLARATIONS", decl.str())); 496 params.insert(pair<string, string>("FRAGMENT_OUTPUT", output.str())); 497 params.insert(pair<string, string>("FRAG_COLOR", fragColor)); 498 499 return params; 500 } 501 502 static map<string, string> generateGeometrySpecialization (const ProgramSpecializationParams& specParams) 503 { 504 ostringstream decl; 505 map<string, string> params; 506 507 decl << "layout (triangles) in;\n"; 508 decl << "layout (triangle_strip, max_vertices=3) out;\n"; 509 decl << "\n"; 510 511 generateUniformDeclarations(decl, specParams.caseSpec.values); 512 513 params.insert(pair<string, string>("GEOMETRY_DECLARATIONS", decl.str())); 514 515 return params; 516 } 517 518 static map<string, string> generateTessControlSpecialization (const ProgramSpecializationParams& specParams) 519 { 520 ostringstream decl; 521 ostringstream output; 522 map<string, string> params; 523 524 decl << "layout (vertices=3) out;\n"; 525 decl << "\n"; 526 527 generateUniformDeclarations(decl, specParams.caseSpec.values); 528 529 output << "gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" 530 "gl_TessLevelInner[0] = 2.0;\n" 531 "gl_TessLevelInner[1] = 2.0;\n" 532 "gl_TessLevelOuter[0] = 2.0;\n" 533 "gl_TessLevelOuter[1] = 2.0;\n" 534 "gl_TessLevelOuter[2] = 2.0;\n" 535 "gl_TessLevelOuter[3] = 2.0;"; 536 537 params.insert(pair<string, string>("TESSELLATION_CONTROL_DECLARATIONS", decl.str())); 538 params.insert(pair<string, string>("TESSELLATION_CONTROL_OUTPUT", output.str())); 539 params.insert(pair<string, string>("GL_MAX_PATCH_VERTICES", de::toString(specParams.maxPatchVertices))); 540 541 return params; 542 } 543 544 static map<string, string> generateTessEvalSpecialization (const ProgramSpecializationParams& specParams) 545 { 546 ostringstream decl; 547 ostringstream output; 548 map<string, string> params; 549 550 decl << "layout (triangles) in;\n"; 551 decl << "\n"; 552 553 generateUniformDeclarations(decl, specParams.caseSpec.values); 554 555 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"; 556 557 params.insert(pair<string, string>("TESSELLATION_EVALUATION_DECLARATIONS", decl.str())); 558 params.insert(pair<string, string>("TESSELLATION_EVALUATION_OUTPUT", output.str())); 559 params.insert(pair<string, string>("GL_MAX_PATCH_VERTICES", de::toString(specParams.maxPatchVertices))); 560 561 return params; 562 } 563 564 static void specializeShaderSources (ProgramSources& dst, 565 const ProgramSources& src, 566 const ProgramSpecializationParams& specParams, 567 glu::ShaderType shaderType, 568 map<string, string> (*specializationGenerator) (const ProgramSpecializationParams& specParams)) 569 { 570 if (!src.sources[shaderType].empty()) 571 { 572 const map<string, string> tmplParams = specializationGenerator(specParams); 573 574 for (size_t ndx = 0; ndx < src.sources[shaderType].size(); ++ndx) 575 { 576 const StringTemplate tmpl (src.sources[shaderType][ndx]); 577 const std::string baseGLSLCode = tmpl.specialize(tmplParams); 578 const std::string sourceWithExts = injectExtensionRequirements(baseGLSLCode, specParams.requiredExtensions, shaderType); 579 580 dst << glu::ShaderSource(shaderType, sourceWithExts); 581 } 582 } 583 } 584 585 static void specializeProgramSources (glu::ProgramSources& dst, 586 const glu::ProgramSources& src, 587 const ProgramSpecializationParams& specParams) 588 { 589 specializeShaderSources(dst, src, specParams, SHADERTYPE_VERTEX, generateVertexSpecialization); 590 specializeShaderSources(dst, src, specParams, SHADERTYPE_FRAGMENT, generateFragmentSpecialization); 591 specializeShaderSources(dst, src, specParams, SHADERTYPE_GEOMETRY, generateGeometrySpecialization); 592 specializeShaderSources(dst, src, specParams, SHADERTYPE_TESSELLATION_CONTROL, generateTessControlSpecialization); 593 specializeShaderSources(dst, src, specParams, SHADERTYPE_TESSELLATION_EVALUATION, generateTessEvalSpecialization); 594 595 dst << ProgramSeparable(src.separable); 596 } 597 598 enum 599 { 600 VIEWPORT_WIDTH = 128, 601 VIEWPORT_HEIGHT = 128 602 }; 603 604 class BeforeDrawValidator : public glu::DrawUtilCallback 605 { 606 public: 607 enum TargetType 608 { 609 TARGETTYPE_PROGRAM = 0, 610 TARGETTYPE_PIPELINE, 611 612 TARGETTYPE_LAST 613 }; 614 615 BeforeDrawValidator (const glw::Functions& gl, glw::GLuint target, TargetType targetType); 616 617 void beforeDrawCall (void); 618 619 const std::string& getInfoLog (void) const; 620 glw::GLint getValidateStatus (void) const; 621 622 private: 623 const glw::Functions& m_gl; 624 const glw::GLuint m_target; 625 const TargetType m_targetType; 626 627 glw::GLint m_validateStatus; 628 std::string m_logMessage; 629 }; 630 631 BeforeDrawValidator::BeforeDrawValidator (const glw::Functions& gl, glw::GLuint target, TargetType targetType) 632 : m_gl (gl) 633 , m_target (target) 634 , m_targetType (targetType) 635 , m_validateStatus (-1) 636 { 637 DE_ASSERT(targetType < TARGETTYPE_LAST); 638 } 639 640 void BeforeDrawValidator::beforeDrawCall (void) 641 { 642 glw::GLint bytesWritten = 0; 643 glw::GLint infoLogLength; 644 std::vector<glw::GLchar> logBuffer; 645 int stringLength; 646 647 // validate 648 if (m_targetType == TARGETTYPE_PROGRAM) 649 m_gl.validateProgram(m_target); 650 else if (m_targetType == TARGETTYPE_PIPELINE) 651 m_gl.validateProgramPipeline(m_target); 652 else 653 DE_ASSERT(false); 654 655 GLU_EXPECT_NO_ERROR(m_gl.getError(), "validate"); 656 657 // check status 658 m_validateStatus = -1; 659 660 if (m_targetType == TARGETTYPE_PROGRAM) 661 m_gl.getProgramiv(m_target, GL_VALIDATE_STATUS, &m_validateStatus); 662 else if (m_targetType == TARGETTYPE_PIPELINE) 663 m_gl.getProgramPipelineiv(m_target, GL_VALIDATE_STATUS, &m_validateStatus); 664 else 665 DE_ASSERT(false); 666 667 GLU_EXPECT_NO_ERROR(m_gl.getError(), "get validate status"); 668 TCU_CHECK(m_validateStatus == GL_TRUE || m_validateStatus == GL_FALSE); 669 670 // read log 671 672 infoLogLength = 0; 673 674 if (m_targetType == TARGETTYPE_PROGRAM) 675 m_gl.getProgramiv(m_target, GL_INFO_LOG_LENGTH, &infoLogLength); 676 else if (m_targetType == TARGETTYPE_PIPELINE) 677 m_gl.getProgramPipelineiv(m_target, GL_INFO_LOG_LENGTH, &infoLogLength); 678 else 679 DE_ASSERT(false); 680 681 GLU_EXPECT_NO_ERROR(m_gl.getError(), "get info log length"); 682 683 if (infoLogLength <= 0) 684 { 685 m_logMessage.clear(); 686 return; 687 } 688 689 logBuffer.resize(infoLogLength + 2, '0'); // +1 for zero terminator (infoLogLength should include it, but better play it safe), +1 to make sure buffer is always larger 690 691 if (m_targetType == TARGETTYPE_PROGRAM) 692 m_gl.getProgramInfoLog(m_target, infoLogLength + 1, &bytesWritten, &logBuffer[0]); 693 else if (m_targetType == TARGETTYPE_PIPELINE) 694 m_gl.getProgramPipelineInfoLog(m_target, infoLogLength + 1, &bytesWritten, &logBuffer[0]); 695 else 696 DE_ASSERT(false); 697 698 // just ignore bytesWritten to be safe, find the null terminator 699 stringLength = (int)(std::find(logBuffer.begin(), logBuffer.end(), '0') - logBuffer.begin()); 700 m_logMessage.assign(&logBuffer[0], stringLength); 701 } 702 703 const std::string& BeforeDrawValidator::getInfoLog (void) const 704 { 705 return m_logMessage; 706 } 707 708 glw::GLint BeforeDrawValidator::getValidateStatus (void) const 709 { 710 return m_validateStatus; 711 } 712 713 // ShaderCase. 714 715 ShaderLibraryCase::ShaderLibraryCase (tcu::TestContext& testCtx, RenderContext& renderCtx, const glu::ContextInfo& contextInfo, const char* name, const char* description, const ShaderCaseSpecification& specification) 716 : tcu::TestCase (testCtx, name, description) 717 , m_renderCtx (renderCtx) 718 , m_contextInfo (contextInfo) 719 , m_spec (specification) 720 { 721 } 722 723 ShaderLibraryCase::~ShaderLibraryCase (void) 724 { 725 } 726 727 void ShaderLibraryCase::init (void) 728 { 729 DE_ASSERT(isValid(m_spec)); 730 731 checkImplementationLimits(m_spec.requiredCaps, m_contextInfo); 732 733 // log the expected result 734 switch (m_spec.expectResult) 735 { 736 case EXPECT_PASS: 737 // Don't write anything 738 break; 739 740 case EXPECT_COMPILE_FAIL: 741 m_testCtx.getLog() << tcu::TestLog::Message << "Expecting shader compilation to fail." << tcu::TestLog::EndMessage; 742 break; 743 744 case EXPECT_LINK_FAIL: 745 m_testCtx.getLog() << tcu::TestLog::Message << "Expecting program linking to fail." << tcu::TestLog::EndMessage; 746 break; 747 748 case EXPECT_COMPILE_LINK_FAIL: 749 m_testCtx.getLog() << tcu::TestLog::Message << "Expecting either shader compilation or program linking to fail." << tcu::TestLog::EndMessage; 750 break; 751 752 case EXPECT_VALIDATION_FAIL: 753 m_testCtx.getLog() << tcu::TestLog::Message << "Expecting program validation to fail." << tcu::TestLog::EndMessage; 754 break; 755 756 case EXPECT_BUILD_SUCCESSFUL: 757 m_testCtx.getLog() << tcu::TestLog::Message << "Expecting shader compilation and program linking to succeed. Resulting program will not be executed." << tcu::TestLog::EndMessage; 758 break; 759 760 default: 761 DE_ASSERT(false); 762 break; 763 } 764 } 765 766 static void setUniformValue (const glw::Functions& gl, const std::vector<deUint32>& pipelinePrograms, const std::string& name, const Value& val, int arrayNdx, tcu::TestLog& log) 767 { 768 bool foundAnyMatch = false; 769 770 for (int programNdx = 0; programNdx < (int)pipelinePrograms.size(); ++programNdx) 771 { 772 const DataType dataType = val.type.getBasicType(); 773 const int scalarSize = getDataTypeScalarSize(dataType); 774 const int loc = gl.getUniformLocation(pipelinePrograms[programNdx], name.c_str()); 775 const int elemNdx = arrayNdx * scalarSize; 776 777 DE_ASSERT(elemNdx+scalarSize <= (int)val.elements.size()); 778 779 if (loc == -1) 780 continue; 781 782 foundAnyMatch = true; 783 784 DE_STATIC_ASSERT(sizeof(Value::Element) == sizeof(glw::GLfloat)); 785 DE_STATIC_ASSERT(sizeof(Value::Element) == sizeof(glw::GLint)); 786 787 gl.useProgram(pipelinePrograms[programNdx]); 788 789 switch (dataType) 790 { 791 case TYPE_FLOAT: gl.uniform1fv(loc, 1, &val.elements[elemNdx].float32); break; 792 case TYPE_FLOAT_VEC2: gl.uniform2fv(loc, 1, &val.elements[elemNdx].float32); break; 793 case TYPE_FLOAT_VEC3: gl.uniform3fv(loc, 1, &val.elements[elemNdx].float32); break; 794 case TYPE_FLOAT_VEC4: gl.uniform4fv(loc, 1, &val.elements[elemNdx].float32); break; 795 case TYPE_FLOAT_MAT2: gl.uniformMatrix2fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32); break; 796 case TYPE_FLOAT_MAT3: gl.uniformMatrix3fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32); break; 797 case TYPE_FLOAT_MAT4: gl.uniformMatrix4fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32); break; 798 case TYPE_INT: gl.uniform1iv(loc, 1, &val.elements[elemNdx].int32); break; 799 case TYPE_INT_VEC2: gl.uniform2iv(loc, 1, &val.elements[elemNdx].int32); break; 800 case TYPE_INT_VEC3: gl.uniform3iv(loc, 1, &val.elements[elemNdx].int32); break; 801 case TYPE_INT_VEC4: gl.uniform4iv(loc, 1, &val.elements[elemNdx].int32); break; 802 case TYPE_BOOL: gl.uniform1iv(loc, 1, &val.elements[elemNdx].int32); break; 803 case TYPE_BOOL_VEC2: gl.uniform2iv(loc, 1, &val.elements[elemNdx].int32); break; 804 case TYPE_BOOL_VEC3: gl.uniform3iv(loc, 1, &val.elements[elemNdx].int32); break; 805 case TYPE_BOOL_VEC4: gl.uniform4iv(loc, 1, &val.elements[elemNdx].int32); break; 806 case TYPE_UINT: gl.uniform1uiv(loc, 1, (const deUint32*)&val.elements[elemNdx].int32); break; 807 case TYPE_UINT_VEC2: gl.uniform2uiv(loc, 1, (const deUint32*)&val.elements[elemNdx].int32); break; 808 case TYPE_UINT_VEC3: gl.uniform3uiv(loc, 1, (const deUint32*)&val.elements[elemNdx].int32); break; 809 case TYPE_UINT_VEC4: gl.uniform4uiv(loc, 1, (const deUint32*)&val.elements[elemNdx].int32); break; 810 case TYPE_FLOAT_MAT2X3: gl.uniformMatrix2x3fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32); break; 811 case TYPE_FLOAT_MAT2X4: gl.uniformMatrix2x4fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32); break; 812 case TYPE_FLOAT_MAT3X2: gl.uniformMatrix3x2fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32); break; 813 case TYPE_FLOAT_MAT3X4: gl.uniformMatrix3x4fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32); break; 814 case TYPE_FLOAT_MAT4X2: gl.uniformMatrix4x2fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32); break; 815 case TYPE_FLOAT_MAT4X3: gl.uniformMatrix4x3fv(loc, 1, GL_FALSE, &val.elements[elemNdx].float32); break; 816 817 case TYPE_SAMPLER_2D: 818 case TYPE_SAMPLER_CUBE: 819 DE_FATAL("implement!"); 820 break; 821 822 default: 823 DE_ASSERT(false); 824 } 825 } 826 827 if (!foundAnyMatch) 828 log << tcu::TestLog::Message << "WARNING // Uniform \"" << name << "\" location is not valid, location = -1. Cannot set value to the uniform." << tcu::TestLog::EndMessage; 829 } 830 831 static bool isTessellationPresent (const ShaderCaseSpecification& spec) 832 { 833 if (spec.programs[0].sources.separable) 834 { 835 const deUint32 tessellationBits = (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | 836 (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION); 837 838 for (int programNdx = 0; programNdx < (int)spec.programs.size(); ++programNdx) 839 if (spec.programs[programNdx].activeStages & tessellationBits) 840 return true; 841 return false; 842 } 843 else 844 return !spec.programs[0].sources.sources[glu::SHADERTYPE_TESSELLATION_CONTROL].empty() || 845 !spec.programs[0].sources.sources[glu::SHADERTYPE_TESSELLATION_EVALUATION].empty(); 846 } 847 848 static bool isTessellationSupported (const glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo) 849 { 850 if (renderCtx.getType().getProfile() == PROFILE_ES) 851 { 852 const int majorVer = renderCtx.getType().getMajorVersion(); 853 const int minorVer = renderCtx.getType().getMinorVersion(); 854 855 return (majorVer > 3) || (majorVer == 3 && minorVer >= 2) || 856 ctxInfo.isExtensionSupported("GL_EXT_tessellation_shader"); 857 } 858 else 859 return false; 860 } 861 862 static bool checkPixels (tcu::TestLog& log, const tcu::ConstPixelBufferAccess& surface) 863 { 864 bool allWhite = true; 865 bool allBlack = true; 866 bool anyUnexpected = false; 867 868 for (int y = 0; y < surface.getHeight(); y++) 869 { 870 for (int x = 0; x < surface.getWidth(); x++) 871 { 872 const tcu::IVec4 pixel = surface.getPixelInt(x, y); 873 // Note: we really do not want to involve alpha in the check comparison 874 // \todo [2010-09-22 kalle] Do we know that alpha would be one? If yes, could use color constants white and black. 875 const bool isWhite = (pixel[0] == 255) && (pixel[1] == 255) && (pixel[2] == 255); 876 const bool isBlack = (pixel[0] == 0) && (pixel[1] == 0) && (pixel[2] == 0); 877 878 allWhite = allWhite && isWhite; 879 allBlack = allBlack && isBlack; 880 anyUnexpected = anyUnexpected || (!isWhite && !isBlack); 881 } 882 } 883 884 if (!allWhite) 885 { 886 if (anyUnexpected) 887 log << TestLog::Message << "WARNING: expecting all rendered pixels to be white or black, but got other colors as well!" << TestLog::EndMessage; 888 else if (!allBlack) 889 log << TestLog::Message << "WARNING: got inconsistent results over the image, when all pixels should be the same color!" << TestLog::EndMessage; 890 891 return false; 892 } 893 894 return true; 895 } 896 897 bool ShaderLibraryCase::execute (void) 898 { 899 const float quadSize = 1.0f; 900 static const float s_positions[4*4] = 901 { 902 -quadSize, -quadSize, 0.0f, 1.0f, 903 -quadSize, +quadSize, 0.0f, 1.0f, 904 +quadSize, -quadSize, 0.0f, 1.0f, 905 +quadSize, +quadSize, 0.0f, 1.0f 906 }; 907 908 static const deUint16 s_indices[2*3] = 909 { 910 0, 1, 2, 911 1, 3, 2 912 }; 913 914 TestLog& log = m_testCtx.getLog(); 915 const glw::Functions& gl = m_renderCtx.getFunctions(); 916 917 // Compute viewport. 918 const tcu::RenderTarget& renderTarget = m_renderCtx.getRenderTarget(); 919 de::Random rnd (deStringHash(getName())); 920 const int width = deMin32(renderTarget.getWidth(), VIEWPORT_WIDTH); 921 const int height = deMin32(renderTarget.getHeight(), VIEWPORT_HEIGHT); 922 const int viewportX = rnd.getInt(0, renderTarget.getWidth() - width); 923 const int viewportY = rnd.getInt(0, renderTarget.getHeight() - height); 924 const int numVerticesPerDraw = 4; 925 const bool tessellationPresent = isTessellationPresent(m_spec); 926 const bool separablePrograms = m_spec.programs[0].sources.separable; 927 928 bool allCompilesOk = true; 929 bool allLinksOk = true; 930 const char* failReason = DE_NULL; 931 932 vector<ProgramSources> specializedSources (m_spec.programs.size()); 933 934 deUint32 vertexProgramID = -1; 935 vector<deUint32> pipelineProgramIDs; 936 vector<SharedPtr<ShaderProgram> > programs; 937 SharedPtr<ProgramPipeline> programPipeline; 938 939 GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderCase::execute(): start"); 940 941 // Specialize shaders 942 if (m_spec.caseType == CASETYPE_VERTEX_ONLY) 943 { 944 const vector<RequiredExtension> reqExt = checkAndSpecializeExtensions(m_spec.programs[0].requiredExtensions, m_contextInfo); 945 946 DE_ASSERT(m_spec.programs.size() == 1 && m_spec.programs[0].sources.sources[SHADERTYPE_VERTEX].size() == 1); 947 specializedSources[0] << glu::VertexSource(specializeVertexShader(m_spec, m_spec.programs[0].sources.sources[SHADERTYPE_VERTEX][0], reqExt)) 948 << glu::FragmentSource(genFragmentShader(m_spec)); 949 } 950 else if (m_spec.caseType == CASETYPE_FRAGMENT_ONLY) 951 { 952 const vector<RequiredExtension> reqExt = checkAndSpecializeExtensions(m_spec.programs[0].requiredExtensions, m_contextInfo); 953 954 DE_ASSERT(m_spec.programs.size() == 1 && m_spec.programs[0].sources.sources[SHADERTYPE_FRAGMENT].size() == 1); 955 specializedSources[0] << glu::VertexSource(genVertexShader(m_spec)) 956 << glu::FragmentSource(specializeFragmentShader(m_spec, m_spec.programs[0].sources.sources[SHADERTYPE_FRAGMENT][0], reqExt)); 957 } 958 else 959 { 960 DE_ASSERT(m_spec.caseType == CASETYPE_COMPLETE); 961 962 const int maxPatchVertices = isTessellationPresent(m_spec) && isTessellationSupported(m_renderCtx, m_contextInfo) 963 ? m_contextInfo.getInt(GL_MAX_PATCH_VERTICES) : 0; 964 965 for (size_t progNdx = 0; progNdx < m_spec.programs.size(); progNdx++) 966 { 967 const ProgramSpecializationParams progSpecParams (m_spec, checkAndSpecializeExtensions(m_spec.programs[progNdx].requiredExtensions, m_contextInfo), maxPatchVertices); 968 969 specializeProgramSources(specializedSources[progNdx], m_spec.programs[progNdx].sources, progSpecParams); 970 } 971 } 972 973 if (!separablePrograms) 974 { 975 de::SharedPtr<glu::ShaderProgram> program (new glu::ShaderProgram(m_renderCtx, specializedSources[0])); 976 977 vertexProgramID = program->getProgram(); 978 pipelineProgramIDs.push_back(program->getProgram()); 979 programs.push_back(program); 980 981 // Check that compile/link results are what we expect. 982 983 DE_STATIC_ASSERT(glu::SHADERTYPE_VERTEX == 0); 984 for (int stage = glu::SHADERTYPE_VERTEX; stage < glu::SHADERTYPE_LAST; ++stage) 985 if (program->hasShader((glu::ShaderType)stage) && !program->getShaderInfo((glu::ShaderType)stage).compileOk) 986 allCompilesOk = false; 987 988 if (!program->getProgramInfo().linkOk) 989 allLinksOk = false; 990 991 log << *program; 992 } 993 else 994 { 995 // Separate programs 996 for (size_t programNdx = 0; programNdx < m_spec.programs.size(); ++programNdx) 997 { 998 de::SharedPtr<glu::ShaderProgram> program(new glu::ShaderProgram(m_renderCtx, specializedSources[programNdx])); 999 1000 if (m_spec.programs[programNdx].activeStages & (1u << glu::SHADERTYPE_VERTEX)) 1001 vertexProgramID = program->getProgram(); 1002 1003 pipelineProgramIDs.push_back(program->getProgram()); 1004 programs.push_back(program); 1005 1006 // Check that compile/link results are what we expect. 1007 1008 DE_STATIC_ASSERT(glu::SHADERTYPE_VERTEX == 0); 1009 for (int stage = glu::SHADERTYPE_VERTEX; stage < glu::SHADERTYPE_LAST; ++stage) 1010 if (program->hasShader((glu::ShaderType)stage) && !program->getShaderInfo((glu::ShaderType)stage).compileOk) 1011 allCompilesOk = false; 1012 1013 if (!program->getProgramInfo().linkOk) 1014 allLinksOk = false; 1015 1016 // Log program and active stages 1017 { 1018 const tcu::ScopedLogSection section (log, "Program", "Program " + de::toString(programNdx+1)); 1019 tcu::MessageBuilder builder (&log); 1020 bool firstStage = true; 1021 1022 builder << "Pipeline uses stages: "; 1023 for (int stage = glu::SHADERTYPE_VERTEX; stage < glu::SHADERTYPE_LAST; ++stage) 1024 { 1025 if (m_spec.programs[programNdx].activeStages & (1u << stage)) 1026 { 1027 if (!firstStage) 1028 builder << ", "; 1029 builder << glu::getShaderTypeName((glu::ShaderType)stage); 1030 firstStage = true; 1031 } 1032 } 1033 builder << tcu::TestLog::EndMessage; 1034 1035 log << *program; 1036 } 1037 } 1038 } 1039 1040 switch (m_spec.expectResult) 1041 { 1042 case EXPECT_PASS: 1043 case EXPECT_VALIDATION_FAIL: 1044 case EXPECT_BUILD_SUCCESSFUL: 1045 if (!allCompilesOk) 1046 failReason = "expected shaders to compile and link properly, but failed to compile."; 1047 else if (!allLinksOk) 1048 failReason = "expected shaders to compile and link properly, but failed to link."; 1049 break; 1050 1051 case EXPECT_COMPILE_FAIL: 1052 if (allCompilesOk && !allLinksOk) 1053 failReason = "expected compilation to fail, but shaders compiled and link failed."; 1054 else if (allCompilesOk) 1055 failReason = "expected compilation to fail, but shaders compiled correctly."; 1056 break; 1057 1058 case EXPECT_LINK_FAIL: 1059 if (!allCompilesOk) 1060 failReason = "expected linking to fail, but unable to compile."; 1061 else if (allLinksOk) 1062 failReason = "expected linking to fail, but passed."; 1063 break; 1064 1065 case EXPECT_COMPILE_LINK_FAIL: 1066 if (allCompilesOk && allLinksOk) 1067 failReason = "expected compile or link to fail, but passed."; 1068 break; 1069 1070 default: 1071 DE_ASSERT(false); 1072 return false; 1073 } 1074 1075 if (failReason != DE_NULL) 1076 { 1077 // \todo [2010-06-07 petri] These should be handled in the test case? 1078 log << TestLog::Message << "ERROR: " << failReason << TestLog::EndMessage; 1079 1080 if (m_spec.fullGLSLES100Required) 1081 { 1082 log << TestLog::Message 1083 << "Assuming build failure is caused by implementation not supporting full GLSL ES 100 specification, which is not required." 1084 << TestLog::EndMessage; 1085 1086 if (allCompilesOk && !allLinksOk) 1087 { 1088 // Used features are detectable at compile time. If implementation parses shader 1089 // at link time, report it as quality warning. 1090 m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, failReason); 1091 } 1092 else 1093 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Full GLSL ES 100 is not supported"); 1094 } 1095 else if (m_spec.expectResult == EXPECT_COMPILE_FAIL && allCompilesOk && !allLinksOk) 1096 { 1097 // If implementation parses shader at link time, report it as quality warning. 1098 m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, failReason); 1099 } 1100 else 1101 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, failReason); 1102 return false; 1103 } 1104 1105 // Return if shader is not intended to be run 1106 if (m_spec.expectResult == EXPECT_COMPILE_FAIL || 1107 m_spec.expectResult == EXPECT_COMPILE_LINK_FAIL || 1108 m_spec.expectResult == EXPECT_LINK_FAIL || 1109 m_spec.expectResult == EXPECT_BUILD_SUCCESSFUL) 1110 return true; 1111 1112 // Setup viewport. 1113 gl.viewport(viewportX, viewportY, width, height); 1114 1115 if (separablePrograms) 1116 { 1117 programPipeline = de::SharedPtr<glu::ProgramPipeline>(new glu::ProgramPipeline(m_renderCtx)); 1118 1119 // Setup pipeline 1120 gl.bindProgramPipeline(programPipeline->getPipeline()); 1121 for (int programNdx = 0; programNdx < (int)m_spec.programs.size(); ++programNdx) 1122 { 1123 deUint32 shaderFlags = 0; 1124 for (int stage = glu::SHADERTYPE_VERTEX; stage < glu::SHADERTYPE_LAST; ++stage) 1125 if (m_spec.programs[programNdx].activeStages & (1u << stage)) 1126 shaderFlags |= glu::getGLShaderTypeBit((glu::ShaderType)stage); 1127 1128 programPipeline->useProgramStages(shaderFlags, pipelineProgramIDs[programNdx]); 1129 } 1130 1131 programPipeline->activeShaderProgram(vertexProgramID); 1132 GLU_EXPECT_NO_ERROR(gl.getError(), "setup pipeline"); 1133 } 1134 else 1135 { 1136 // Start using program 1137 gl.useProgram(vertexProgramID); 1138 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram()"); 1139 } 1140 1141 // Fetch location for positions positions. 1142 int positionLoc = gl.getAttribLocation(vertexProgramID, "dEQP_Position"); 1143 if (positionLoc == -1) 1144 { 1145 string errStr = string("no location found for attribute 'dEQP_Position'"); 1146 TCU_FAIL(errStr.c_str()); 1147 } 1148 1149 // Iterate all value blocks. 1150 { 1151 const ValueBlock& valueBlock = m_spec.values; 1152 1153 // always render at least one pass even if there is no input/output data 1154 const int numRenderPasses = valueBlock.outputs.empty() ? 1 : (int)valueBlock.outputs[0].elements.size() / valueBlock.outputs[0].type.getScalarSize(); 1155 1156 // Iterate all array sub-cases. 1157 for (int arrayNdx = 0; arrayNdx < numRenderPasses; arrayNdx++) 1158 { 1159 vector<VertexArrayBinding> vertexArrays; 1160 int attribValueNdx = 0; 1161 vector<vector<float> > attribValues (valueBlock.inputs.size()); 1162 glw::GLenum postDrawError; 1163 BeforeDrawValidator beforeDrawValidator (gl, 1164 (separablePrograms) ? (programPipeline->getPipeline()) : (vertexProgramID), 1165 (separablePrograms) ? (BeforeDrawValidator::TARGETTYPE_PIPELINE) : (BeforeDrawValidator::TARGETTYPE_PROGRAM)); 1166 1167 vertexArrays.push_back(va::Float(positionLoc, 4, numVerticesPerDraw, 0, &s_positions[0])); 1168 1169 // Collect VA pointer for inputs 1170 for (size_t valNdx = 0; valNdx < valueBlock.inputs.size(); valNdx++) 1171 { 1172 const Value& val = valueBlock.inputs[valNdx]; 1173 const char* const valueName = val.name.c_str(); 1174 const DataType dataType = val.type.getBasicType(); 1175 const int scalarSize = getDataTypeScalarSize(dataType); 1176 1177 // Replicate values four times. 1178 std::vector<float>& scalars = attribValues[attribValueNdx++]; 1179 scalars.resize(numVerticesPerDraw * scalarSize); 1180 if (isDataTypeFloatOrVec(dataType) || isDataTypeMatrix(dataType)) 1181 { 1182 for (int repNdx = 0; repNdx < numVerticesPerDraw; repNdx++) 1183 for (int ndx = 0; ndx < scalarSize; ndx++) 1184 scalars[repNdx*scalarSize + ndx] = val.elements[arrayNdx*scalarSize + ndx].float32; 1185 } 1186 else 1187 { 1188 // convert to floats. 1189 for (int repNdx = 0; repNdx < numVerticesPerDraw; repNdx++) 1190 { 1191 for (int ndx = 0; ndx < scalarSize; ndx++) 1192 { 1193 float v = (float)val.elements[arrayNdx*scalarSize + ndx].int32; 1194 DE_ASSERT(val.elements[arrayNdx*scalarSize + ndx].int32 == (int)v); 1195 scalars[repNdx*scalarSize + ndx] = v; 1196 } 1197 } 1198 } 1199 1200 // Attribute name prefix. 1201 string attribPrefix = ""; 1202 // \todo [2010-05-27 petri] Should latter condition only apply for vertex cases (or actually non-fragment cases)? 1203 if ((m_spec.caseType == CASETYPE_FRAGMENT_ONLY) || (getDataTypeScalarType(dataType) != TYPE_FLOAT)) 1204 attribPrefix = "a_"; 1205 1206 // Input always given as attribute. 1207 string attribName = attribPrefix + valueName; 1208 int attribLoc = gl.getAttribLocation(vertexProgramID, attribName.c_str()); 1209 if (attribLoc == -1) 1210 { 1211 log << TestLog::Message << "Warning: no location found for attribute '" << attribName << "'" << TestLog::EndMessage; 1212 continue; 1213 } 1214 1215 if (isDataTypeMatrix(dataType)) 1216 { 1217 int numCols = getDataTypeMatrixNumColumns(dataType); 1218 int numRows = getDataTypeMatrixNumRows(dataType); 1219 DE_ASSERT(scalarSize == numCols*numRows); 1220 1221 for (int i = 0; i < numCols; i++) 1222 vertexArrays.push_back(va::Float(attribLoc + i, numRows, numVerticesPerDraw, scalarSize*(int)sizeof(float), &scalars[i * numRows])); 1223 } 1224 else 1225 { 1226 DE_ASSERT(isDataTypeFloatOrVec(dataType) || isDataTypeIntOrIVec(dataType) || isDataTypeUintOrUVec(dataType) || isDataTypeBoolOrBVec(dataType)); 1227 vertexArrays.push_back(va::Float(attribLoc, scalarSize, numVerticesPerDraw, 0, &scalars[0])); 1228 } 1229 1230 GLU_EXPECT_NO_ERROR(gl.getError(), "set vertex attrib array"); 1231 } 1232 1233 GLU_EXPECT_NO_ERROR(gl.getError(), "before set uniforms"); 1234 1235 // set reference values for outputs. 1236 for (size_t valNdx = 0; valNdx < valueBlock.outputs.size(); valNdx++) 1237 { 1238 const Value& val = valueBlock.outputs[valNdx]; 1239 const char* const valueName = val.name.c_str(); 1240 1241 // Set reference value. 1242 string refName = string("ref_") + valueName; 1243 setUniformValue(gl, pipelineProgramIDs, refName, val, arrayNdx, m_testCtx.getLog()); 1244 GLU_EXPECT_NO_ERROR(gl.getError(), "set reference uniforms"); 1245 } 1246 1247 // set uniform values 1248 for (size_t valNdx = 0; valNdx < valueBlock.uniforms.size(); valNdx++) 1249 { 1250 const Value& val = valueBlock.uniforms[valNdx]; 1251 const char* const valueName = val.name.c_str(); 1252 1253 setUniformValue(gl, pipelineProgramIDs, valueName, val, arrayNdx, m_testCtx.getLog()); 1254 GLU_EXPECT_NO_ERROR(gl.getError(), "set uniforms"); 1255 } 1256 1257 // Clear. 1258 gl.clearColor(0.125f, 0.25f, 0.5f, 1.0f); 1259 gl.clear(GL_COLOR_BUFFER_BIT); 1260 GLU_EXPECT_NO_ERROR(gl.getError(), "clear buffer"); 1261 1262 // Use program or pipeline 1263 if (separablePrograms) 1264 gl.useProgram(0); 1265 else 1266 gl.useProgram(vertexProgramID); 1267 1268 // Draw. 1269 if (tessellationPresent) 1270 { 1271 gl.patchParameteri(GL_PATCH_VERTICES, 3); 1272 GLU_EXPECT_NO_ERROR(gl.getError(), "set patchParameteri(PATCH_VERTICES, 3)"); 1273 } 1274 1275 draw(m_renderCtx, 1276 vertexProgramID, 1277 (int)vertexArrays.size(), 1278 &vertexArrays[0], 1279 (tessellationPresent) ? 1280 (pr::Patches(DE_LENGTH_OF_ARRAY(s_indices), &s_indices[0])) : 1281 (pr::Triangles(DE_LENGTH_OF_ARRAY(s_indices), &s_indices[0])), 1282 (m_spec.expectResult == EXPECT_VALIDATION_FAIL) ? 1283 (&beforeDrawValidator) : 1284 (DE_NULL)); 1285 1286 postDrawError = gl.getError(); 1287 1288 if (m_spec.expectResult == EXPECT_PASS) 1289 { 1290 // Read back results. 1291 Surface surface (width, height); 1292 const float w = s_positions[3]; 1293 const int minY = deCeilFloatToInt32 (((-quadSize / w) * 0.5f + 0.5f) * (float)height + 1.0f); 1294 const int maxY = deFloorFloatToInt32(((+quadSize / w) * 0.5f + 0.5f) * (float)height - 0.5f); 1295 const int minX = deCeilFloatToInt32 (((-quadSize / w) * 0.5f + 0.5f) * (float)width + 1.0f); 1296 const int maxX = deFloorFloatToInt32(((+quadSize / w) * 0.5f + 0.5f) * (float)width - 0.5f); 1297 1298 GLU_EXPECT_NO_ERROR(postDrawError, "draw"); 1299 1300 glu::readPixels(m_renderCtx, viewportX, viewportY, surface.getAccess()); 1301 GLU_EXPECT_NO_ERROR(gl.getError(), "read pixels"); 1302 1303 if (!checkPixels(log, tcu::getSubregion(surface.getAccess(), minX, minY, maxX-minX+1, maxY-minY+1))) 1304 { 1305 log << TestLog::Message << "INCORRECT RESULT for sub-case " << arrayNdx+1 << " of " << numRenderPasses << "):" 1306 << TestLog::EndMessage; 1307 1308 log << TestLog::Message << "Failing shader input/output values:" << TestLog::EndMessage; 1309 dumpValues(log, valueBlock, arrayNdx); 1310 1311 // Dump image on failure. 1312 log << TestLog::Image("Result", "Rendered result image", surface); 1313 1314 gl.useProgram(0); 1315 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed"); 1316 return false; 1317 } 1318 } 1319 else if (m_spec.expectResult == EXPECT_VALIDATION_FAIL) 1320 { 1321 log << TestLog::Message 1322 << "Draw call generated error: " 1323 << glu::getErrorStr(postDrawError) << " " 1324 << ((postDrawError == GL_INVALID_OPERATION) ? ("(expected)") : ("(unexpected)")) << "\n" 1325 << "Validate status: " 1326 << glu::getBooleanStr(beforeDrawValidator.getValidateStatus()) << " " 1327 << ((beforeDrawValidator.getValidateStatus() == GL_FALSE) ? ("(expected)") : ("(unexpected)")) << "\n" 1328 << "Info log: " 1329 << ((beforeDrawValidator.getInfoLog().empty()) ? ("[empty string]") : (beforeDrawValidator.getInfoLog())) << "\n" 1330 << TestLog::EndMessage; 1331 1332 // test result 1333 1334 if (postDrawError != GL_NO_ERROR && postDrawError != GL_INVALID_OPERATION) 1335 { 1336 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, ("Draw: got unexpected error: " + de::toString(glu::getErrorStr(postDrawError))).c_str()); 1337 return false; 1338 } 1339 1340 if (beforeDrawValidator.getValidateStatus() == GL_TRUE) 1341 { 1342 if (postDrawError == GL_NO_ERROR) 1343 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "expected validation and rendering to fail but validation and rendering succeeded"); 1344 else if (postDrawError == GL_INVALID_OPERATION) 1345 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "expected validation and rendering to fail but validation succeeded (rendering failed as expected)"); 1346 else 1347 DE_ASSERT(false); 1348 return false; 1349 } 1350 else if (beforeDrawValidator.getValidateStatus() == GL_FALSE && postDrawError == GL_NO_ERROR) 1351 { 1352 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "expected validation and rendering to fail but rendering succeeded (validation failed as expected)"); 1353 return false; 1354 } 1355 else if (beforeDrawValidator.getValidateStatus() == GL_FALSE && postDrawError == GL_INVALID_OPERATION) 1356 { 1357 // Validation does not depend on input values, no need to test all values 1358 return true; 1359 } 1360 else 1361 DE_ASSERT(false); 1362 } 1363 else 1364 DE_ASSERT(false); 1365 } 1366 } 1367 1368 gl.useProgram(0); 1369 if (separablePrograms) 1370 gl.bindProgramPipeline(0); 1371 1372 GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderCase::execute(): end"); 1373 return true; 1374 } 1375 1376 TestCase::IterateResult ShaderLibraryCase::iterate (void) 1377 { 1378 // Initialize state to pass. 1379 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1380 1381 bool executeOk = execute(); 1382 1383 DE_ASSERT(executeOk ? m_testCtx.getTestResult() == QP_TEST_RESULT_PASS : m_testCtx.getTestResult() != QP_TEST_RESULT_PASS); 1384 DE_UNREF(executeOk); 1385 return TestCase::STOP; 1386 } 1387 1388 } // gls 1389 } // deqp 1390
