1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.1 Module 3 * ------------------------------------------------- 4 * 5 * Copyright 2016 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 Negative Shader Storage Buffer Object (SSBO) tests. 22 *//*--------------------------------------------------------------------*/ 23 #include "es31fNegativeSSBOBlockTests.hpp" 24 #include "glwDefs.hpp" 25 #include "glwEnums.hpp" 26 #include "tcuStringTemplate.hpp" 27 #include "gluShaderProgram.hpp" 28 #include <map> 29 30 namespace deqp 31 { 32 namespace gles31 33 { 34 namespace Functional 35 { 36 namespace NegativeTestShared 37 { 38 namespace 39 { 40 using tcu::TestLog; 41 using glu::CallLogWrapper; 42 using namespace glw; 43 namespace args 44 { 45 enum ArgMember 46 { 47 ARGMEMBER_FORMAT = 0, 48 ARGMEMBER_BINDING_POINT, 49 ARGMEMBER_MATRIX_ORDER, 50 ARGMEMBER_MEMBER_TYPE, 51 ARGMEMBER_NAME, 52 ARGMEMBER_FIXED_ARRAY, 53 ARGMEMBER_VARIABLE_ARRAY, 54 ARGMEMBER_REORDER 55 }; 56 57 // key pair ssbo arg data 58 struct SsboArgData 59 { 60 ArgMember member; 61 std::string data; 62 63 SsboArgData(const ArgMember& member_, const std::string& data_) 64 { 65 member = member_; 66 data = data_; 67 } 68 }; 69 70 // class which manages string based argument used to build varying ssbo interface blocks and members 71 class SsboArgs 72 { 73 public: 74 SsboArgs(const std::string version, tcu::TestLog& log); 75 76 void setSingleValue (const SsboArgData argData); 77 bool setAllValues (const std::vector<SsboArgData> argDataList); 78 79 bool getMemberReorder (void) const; 80 81 void resetValues (void); 82 83 std::map<std::string, std::string> populateArgsMap (void) const; 84 85 private: 86 std::string m_negativeContextVersion; 87 std::string m_stdFormat; 88 std::string m_bindingPoint; 89 std::string m_matrixOrder; 90 std::string m_memberType; 91 std::string m_memberName; 92 std::string m_memberFixedArrayerName; 93 std::string m_memberVariableArray; 94 bool m_memberReorder; 95 int m_numberMembers; 96 tcu::TestLog& m_testLog; 97 98 void setDefaultValues (void); 99 }; 100 101 //constructor which ensure a proper context is passed into the struct 102 SsboArgs::SsboArgs(const std::string version, tcu::TestLog& log) 103 : m_negativeContextVersion (version) 104 , m_numberMembers (8) 105 , m_testLog (log) 106 { 107 setDefaultValues(); 108 } 109 110 void SsboArgs::setSingleValue (const SsboArgData argData) 111 { 112 std::string message; 113 114 switch (argData.member) 115 { 116 case ARGMEMBER_FORMAT: 117 m_stdFormat = argData.data; 118 return; 119 case ARGMEMBER_BINDING_POINT: 120 m_bindingPoint = argData.data; 121 return; 122 case ARGMEMBER_MATRIX_ORDER: 123 m_matrixOrder = argData.data; 124 return; 125 case ARGMEMBER_MEMBER_TYPE: 126 m_memberType = argData.data; 127 return; 128 case ARGMEMBER_NAME: 129 m_memberName = argData.data; 130 return; 131 case ARGMEMBER_FIXED_ARRAY: 132 m_memberFixedArrayerName = argData.data; 133 return; 134 case ARGMEMBER_VARIABLE_ARRAY: 135 m_memberVariableArray = argData.data; 136 return; 137 case ARGMEMBER_REORDER: 138 if (argData.data == "true") 139 { 140 m_memberReorder = true; 141 } 142 return; 143 default: 144 message = "auto loop argument data member not recognised."; 145 m_testLog << tcu::TestLog::Message << message << tcu::TestLog::EndMessage; 146 } 147 } 148 149 bool SsboArgs::setAllValues (const std::vector<SsboArgData> argDataList) 150 { 151 std::string message; 152 153 if ((argDataList.size() == 0) || (argDataList.size() > (size_t)m_numberMembers)) 154 { 155 message = "set of args does not match the number of args struct changeable members."; 156 m_testLog << tcu::TestLog::Message << message << tcu::TestLog::EndMessage; 157 158 return false; 159 } 160 else 161 { 162 for (unsigned int idx = 0; idx < argDataList.size(); idx++) 163 { 164 setSingleValue(argDataList[idx]); 165 } 166 } 167 168 return true; 169 } 170 171 bool SsboArgs::getMemberReorder (void) const 172 { 173 return m_memberReorder; 174 } 175 176 void SsboArgs::resetValues (void) 177 { 178 setDefaultValues(); 179 } 180 181 //converts SsboArgs member variable into a map object to be used by tcu::StringTemplate 182 std::map<std::string, std::string> SsboArgs::populateArgsMap (void) const 183 { 184 std::map<std::string, std::string> argsMap; 185 186 // key placeholders located at specific points in the ssbo block 187 argsMap["NEGATIVE_CONTEXT_VERSION"] = m_negativeContextVersion; 188 argsMap["STD_FORMAT"] = m_stdFormat; 189 argsMap["BINDING_POINT"] = m_bindingPoint; 190 argsMap["MATRIX_ORDER"] = m_matrixOrder; 191 argsMap["MEMBER_TYPE"] = m_memberType; 192 argsMap["MEMBER_NAME"] = m_memberName; 193 argsMap["MEMBER_FIXED_ARRAY"] = m_memberFixedArrayerName; 194 argsMap["MEMBER_VARIABLE_ARRAY"] = m_memberVariableArray; 195 196 return argsMap; 197 } 198 199 // default values i.e. same shader template 200 void SsboArgs::setDefaultValues (void) 201 { 202 m_stdFormat = "std430"; 203 m_bindingPoint = "0"; 204 m_matrixOrder = "column_major"; 205 m_memberType = "int"; 206 m_memberName = "matrix"; 207 m_memberFixedArrayerName = "10"; 208 m_memberVariableArray = ""; 209 m_memberReorder = false; 210 } 211 } // args 212 213 std::string generateVaryingSSBOShader(const glw::GLenum shaderType, const args::SsboArgs& args, tcu::TestLog& log) 214 { 215 std::map<std::string, std::string> argsMap; 216 std::ostringstream source; 217 std::string sourceString; 218 std::stringstream ssboString; 219 std::string message; 220 221 if (args.getMemberReorder()) 222 { 223 ssboString << " mediump vec4 array_1[${MEMBER_FIXED_ARRAY}];\n" 224 << " highp mat4 ${MEMBER_NAME};\n" 225 << " lowp ${MEMBER_TYPE} data;\n" 226 << " mediump float array_2[${MEMBER_VARIABLE_ARRAY}];\n"; 227 } 228 else 229 { 230 ssboString << " lowp ${MEMBER_TYPE} data;\n" 231 << " highp mat4 ${MEMBER_NAME};\n" 232 << " mediump vec4 array_1[${MEMBER_FIXED_ARRAY}];\n" 233 << " mediump float array_2[${MEMBER_VARIABLE_ARRAY}];\n"; 234 } 235 236 argsMap = args.populateArgsMap(); 237 238 switch (shaderType) 239 { 240 case GL_VERTEX_SHADER: 241 { 242 source << "${NEGATIVE_CONTEXT_VERSION}\n" 243 << "layout (location = 0) in highp vec4 position;\n" 244 << "layout (location = 1) in mediump vec4 colour;\n" 245 << "out mediump vec4 vertex_colour;\n" 246 << "layout (${STD_FORMAT}, binding = ${BINDING_POINT}, ${MATRIX_ORDER}) buffer ssbo_block\n" 247 << "{\n"; 248 249 source << ssboString.str(); 250 251 source << "} ssbo;\n" 252 << "void main()\n" 253 << "{\n" 254 << " mediump vec4 variable;\n" 255 << " gl_Position = ssbo.${MEMBER_NAME} * position;\n" 256 << " for (int idx = 0; idx < ${MEMBER_FIXED_ARRAY}; idx++)\n" 257 << " {\n" 258 << " variable += ssbo.array_1[idx];\n" 259 << " }\n" 260 << " vertex_colour = colour + variable;\n" 261 << "}\n"; 262 263 sourceString = source.str(); 264 sourceString = tcu::StringTemplate(sourceString).specialize(argsMap); 265 266 return sourceString; 267 } 268 269 case GL_FRAGMENT_SHADER: 270 { 271 source << "${NEGATIVE_CONTEXT_VERSION}\n" 272 << "in mediump vec4 vertex_colour;\n" 273 << "layout (location = 0) out mediump vec4 fragment_colour;\n" 274 << "layout (${STD_FORMAT}, binding = ${BINDING_POINT}, ${MATRIX_ORDER}) buffer ssbo_block\n" 275 << "{\n"; 276 277 source << ssboString.str(); 278 279 source << "} ssbo;\n" 280 << "void main()\n" 281 << "{\n" 282 << " mediump vec4 variable;\n" 283 << " variable * ssbo.${MEMBER_NAME};\n" 284 << " for (int idx = 0; idx < ${MEMBER_FIXED_ARRAY}; idx++)\n" 285 << " {\n" 286 << " variable += ssbo.array_1[idx];\n" 287 << " }\n" 288 << " fragment_colour = vertex_colour + variable;\n" 289 << "}\n"; 290 291 sourceString = source.str(); 292 sourceString = tcu::StringTemplate(sourceString).specialize(argsMap); 293 294 return sourceString; 295 } 296 297 case GL_GEOMETRY_SHADER: 298 { 299 // TODO: 300 return sourceString; 301 } 302 303 case GL_TESS_CONTROL_SHADER: 304 { 305 // TODO: 306 return sourceString; 307 } 308 309 case GL_TESS_EVALUATION_SHADER: 310 { 311 // TODO: 312 return sourceString; 313 } 314 315 case GL_COMPUTE_SHADER: 316 { 317 // TODO: 318 return sourceString; 319 } 320 321 default: 322 { 323 message = "shader type not recognised."; 324 log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage; 325 } 326 } 327 328 return std::string(); 329 } 330 331 void logProgramInfo(NegativeTestContext& ctx, GLint program) 332 { 333 GLint maxLength = 0; 334 std::string message; 335 tcu::TestLog& log = ctx.getLog(); 336 337 ctx.glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength); 338 339 message = "Program log:"; 340 log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage; 341 342 if (maxLength == 0) 343 { 344 message = "No available info log."; 345 log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage; 346 return; 347 } 348 349 std::vector<GLchar> infoLog(maxLength); 350 ctx.glGetProgramInfoLog(program, maxLength, &maxLength, &infoLog[0]); 351 352 std::string programLogMessage(&infoLog[0], maxLength); 353 log << tcu::TestLog::Message << programLogMessage << tcu::TestLog::EndMessage; 354 } 355 356 void ssbo_block_matching(NegativeTestContext& ctx) 357 { 358 const bool isES32 = contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)); 359 const glu::GLSLVersion version = isES32 ? glu::GLSL_VERSION_320_ES : glu::GLSL_VERSION_310_ES; 360 tcu::TestLog& log = ctx.getLog(); 361 std::string message; 362 std::string versionString(glu::getGLSLVersionDeclaration(version)); 363 args::SsboArgs ssboArgs(versionString, log); 364 GLint shaderVertexGL; 365 std::string shaderVertexString; 366 const char* shaderVertexCharPtr; 367 368 // List of arguments used to create varying ssbo objects in the fragment shader 369 const args::SsboArgData argDataArrayFrag[] = { args::SsboArgData(args::ARGMEMBER_FORMAT, "std140"), 370 args::SsboArgData(args::ARGMEMBER_BINDING_POINT, "10"), 371 args::SsboArgData(args::ARGMEMBER_MATRIX_ORDER, "row_major"), 372 args::SsboArgData(args::ARGMEMBER_MEMBER_TYPE, "vec2"), 373 args::SsboArgData(args::ARGMEMBER_NAME, "name_changed"), 374 args::SsboArgData(args::ARGMEMBER_FIXED_ARRAY, "20"), 375 args::SsboArgData(args::ARGMEMBER_VARIABLE_ARRAY, "5"), 376 args::SsboArgData(args::ARGMEMBER_REORDER, "true") }; 377 std::vector<args::SsboArgData> argDataVectorFrag(argDataArrayFrag, argDataArrayFrag + sizeof(argDataArrayFrag) / sizeof(argDataArrayFrag[0])); 378 379 // create default vertex shader 380 shaderVertexString = generateVaryingSSBOShader(GL_VERTEX_SHADER, ssboArgs, log); 381 shaderVertexCharPtr = shaderVertexString.c_str(); 382 shaderVertexGL = ctx.glCreateShader(GL_VERTEX_SHADER); 383 384 // log 385 message = shaderVertexString; 386 log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage; 387 388 // compile 389 ctx.glShaderSource(shaderVertexGL, 1, &shaderVertexCharPtr, DE_NULL); 390 ctx.glCompileShader(shaderVertexGL); 391 392 for (std::size_t idx = 0; idx < argDataVectorFrag.size(); ++idx) 393 { 394 GLint linkStatus = -1; 395 GLint program; 396 GLint shaderFragmentGL; 397 std::string shaderFragmentString; 398 const char* shaderFragmentCharPtr; 399 400 ctx.beginSection("Multiple shaders created using SSBO's sharing the same name but not matching layouts"); 401 402 program = ctx.glCreateProgram(); 403 404 // reset args to default and make a single change 405 ssboArgs.resetValues(); 406 ssboArgs.setSingleValue(argDataVectorFrag[idx]); 407 408 // create fragment shader 409 shaderFragmentString = generateVaryingSSBOShader(GL_FRAGMENT_SHADER, ssboArgs, log); 410 shaderFragmentCharPtr = shaderFragmentString.c_str(); 411 shaderFragmentGL = ctx.glCreateShader(GL_FRAGMENT_SHADER); 412 413 // log 414 message = shaderFragmentString; 415 log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage; 416 417 // compile 418 ctx.glShaderSource(shaderFragmentGL, 1, &shaderFragmentCharPtr, DE_NULL); 419 ctx.glCompileShader(shaderFragmentGL); 420 421 // attach shaders to program and attempt to link 422 ctx.glAttachShader(program, shaderVertexGL); 423 ctx.glAttachShader(program, shaderFragmentGL); 424 ctx.glLinkProgram(program); 425 ctx.glGetProgramiv(program, GL_LINK_STATUS, &linkStatus); 426 427 logProgramInfo(ctx, program); 428 429 if (linkStatus == GL_TRUE) 430 { 431 ctx.fail("Program should not have linked"); 432 } 433 434 // clean up resources 435 ctx.glDeleteShader(shaderFragmentGL); 436 ctx.glDeleteProgram(program); 437 438 ctx.endSection(); 439 } 440 441 // clean up default resources 442 ctx.glDeleteShader(shaderVertexGL); 443 } 444 445 void ssbo_block_shared_qualifier(NegativeTestContext& ctx) 446 { 447 const bool isES32 = contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)); 448 const glu::GLSLVersion version = isES32 ? glu::GLSL_VERSION_320_ES : glu::GLSL_VERSION_310_ES; 449 tcu::TestLog& log = ctx.getLog(); 450 std::string message; 451 std::string versionString(glu::getGLSLVersionDeclaration(version)); 452 args::SsboArgs ssboArgs(versionString, log); 453 bool result; 454 GLint shaderVertexGL; 455 std::string shaderVertexString; 456 const char* shaderVertexCharPtr; 457 458 // default args used in vertex shader ssbo 459 const args::SsboArgData argDataArrayVert[] = { args::SsboArgData(args::ARGMEMBER_FORMAT, "shared"), 460 args::SsboArgData(args::ARGMEMBER_BINDING_POINT, "0"), 461 args::SsboArgData(args::ARGMEMBER_MATRIX_ORDER, "column_major"), 462 args::SsboArgData(args::ARGMEMBER_FIXED_ARRAY, "10"), 463 args::SsboArgData(args::ARGMEMBER_VARIABLE_ARRAY, "10"), 464 args::SsboArgData(args::ARGMEMBER_REORDER, "false") }; 465 std::vector<args::SsboArgData> argDataVectorVert(argDataArrayVert, argDataArrayVert + sizeof(argDataArrayVert) / sizeof(argDataArrayVert[0])); 466 467 // args changed in fragment shader ssbo 468 const args::SsboArgData argDataArrayFrag[] = { args::SsboArgData(args::ARGMEMBER_MATRIX_ORDER, "row_major"), 469 args::SsboArgData(args::ARGMEMBER_VARIABLE_ARRAY, ""), 470 args::SsboArgData(args::ARGMEMBER_FIXED_ARRAY, "20") }; 471 std::vector<args::SsboArgData> argDataVectorFrag(argDataArrayFrag, argDataArrayFrag + sizeof(argDataArrayFrag) / sizeof(argDataArrayFrag[0])); 472 473 // set default vertex ssbo args 474 result = ssboArgs.setAllValues(argDataVectorVert); 475 476 if (result == false) 477 { 478 message = "Invalid use of args.setAllValues()"; 479 log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage; 480 return; 481 } 482 483 // create default vertex shader 484 shaderVertexString = generateVaryingSSBOShader(GL_VERTEX_SHADER, ssboArgs, log); 485 shaderVertexCharPtr = shaderVertexString.c_str(); 486 shaderVertexGL = ctx.glCreateShader(GL_VERTEX_SHADER); 487 488 // log 489 message = shaderVertexString; 490 log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage; 491 492 // compile 493 ctx.glShaderSource(shaderVertexGL, 1, &shaderVertexCharPtr, DE_NULL); 494 ctx.glCompileShader(shaderVertexGL); 495 496 for (std::size_t idx = 0; idx < argDataVectorFrag.size(); idx++) 497 { 498 GLint linkStatus = -1; 499 GLint program; 500 GLint shaderFragmentGL; 501 std::string shaderFragmentString; 502 const char* shaderFragmentCharPtr; 503 504 ctx.beginSection("Multiple shaders created using SSBO's sharing the same name but not matching layouts"); 505 506 program = ctx.glCreateProgram(); 507 508 // reset args to default and make a single change 509 ssboArgs.setAllValues(argDataVectorVert); 510 ssboArgs.setSingleValue(argDataVectorFrag[idx]); 511 512 // create fragment shader 513 shaderFragmentString = generateVaryingSSBOShader(GL_FRAGMENT_SHADER, ssboArgs, log); 514 shaderFragmentCharPtr = shaderFragmentString.c_str(); 515 shaderFragmentGL = ctx.glCreateShader(GL_FRAGMENT_SHADER); 516 517 // log 518 message = shaderFragmentString; 519 log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage; 520 521 // compile 522 ctx.glShaderSource(shaderFragmentGL, 1, &shaderFragmentCharPtr, DE_NULL); 523 ctx.glCompileShader(shaderFragmentGL); 524 525 // attach shaders to the program and attempt to link 526 ctx.glAttachShader(program, shaderVertexGL); 527 ctx.glAttachShader(program, shaderFragmentGL); 528 ctx.glLinkProgram(program); 529 ctx.glGetProgramiv(program, GL_LINK_STATUS, &linkStatus); 530 531 logProgramInfo(ctx, program); 532 533 if (linkStatus == GL_TRUE) 534 { 535 ctx.fail("Program should not have linked"); 536 } 537 538 // clean up resources 539 ctx.glDeleteShader(shaderFragmentGL); 540 ctx.glDeleteProgram(program); 541 542 ctx.endSection(); 543 } 544 545 // clean up default resources 546 ctx.glDeleteShader(shaderVertexGL); 547 } 548 } // anonymous 549 550 std::vector<FunctionContainer> getNegativeSSBOBlockTestFunctions (void) 551 { 552 const FunctionContainer funcs[] = 553 { 554 { ssbo_block_matching, "ssbo_block_interface_matching_tests", "Invalid Shader Linkage" }, 555 { ssbo_block_shared_qualifier, "ssbo_using_shared_qualifier_tests", "Invalid Shader Linkage" }, 556 }; 557 558 return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs)); 559 } 560 } // NegativeTestShared 561 } //Functional 562 } //gles31 563 } //deqp 564
