1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.1 Module 3 * ------------------------------------------------- 4 * 5 * Copyright 2015 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 Image Load Store Tests 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es31fNegativeShaderImageLoadStoreTests.hpp" 25 26 #include "deUniquePtr.hpp" 27 28 #include "glwEnums.hpp" 29 30 #include "gluShaderProgram.hpp" 31 32 #include "glsTextureTestUtil.hpp" 33 34 #include "tcuStringTemplate.hpp" 35 #include "tcuTexture.hpp" 36 #include "tcuTestLog.hpp" 37 38 namespace deqp 39 { 40 namespace gles31 41 { 42 namespace Functional 43 { 44 namespace NegativeTestShared 45 { 46 namespace 47 { 48 49 enum MemoryQualifier 50 { 51 MEMORY_NONE = 0, 52 MEMORY_READONLY, 53 MEMORY_WRITEONLY, 54 MEMORY_BOTH, 55 56 MEMORY_LAST 57 }; 58 59 enum ImageOperation 60 { 61 IMAGE_OPERATION_STORE = 0, 62 IMAGE_OPERATION_LOAD, 63 IMAGE_OPERATION_ATOMIC_ADD, 64 IMAGE_OPERATION_ATOMIC_MIN, 65 IMAGE_OPERATION_ATOMIC_MAX, 66 IMAGE_OPERATION_ATOMIC_AND, 67 IMAGE_OPERATION_ATOMIC_OR, 68 IMAGE_OPERATION_ATOMIC_XOR, 69 IMAGE_OPERATION_ATOMIC_EXCHANGE, 70 IMAGE_OPERATION_ATOMIC_COMP_SWAP, 71 72 IMAGE_OPERATION_LAST 73 }; 74 75 static const glu::ShaderType s_shaders[] = 76 { 77 glu::SHADERTYPE_VERTEX, 78 glu::SHADERTYPE_FRAGMENT, 79 glu::SHADERTYPE_GEOMETRY, 80 glu::SHADERTYPE_TESSELLATION_CONTROL, 81 glu::SHADERTYPE_TESSELLATION_EVALUATION, 82 glu::SHADERTYPE_COMPUTE 83 }; 84 85 static const gls::TextureTestUtil::TextureType s_imageTypes[] = 86 { 87 gls::TextureTestUtil::TEXTURETYPE_2D, 88 gls::TextureTestUtil::TEXTURETYPE_3D, 89 gls::TextureTestUtil::TEXTURETYPE_CUBE, 90 gls::TextureTestUtil::TEXTURETYPE_2D_ARRAY, 91 gls::TextureTestUtil::TEXTURETYPE_BUFFER, 92 gls::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY 93 }; 94 95 std::string getShaderImageLayoutQualifier (const tcu::TextureFormat& format) 96 { 97 std::ostringstream qualifier; 98 99 switch (format.order) 100 { 101 case tcu::TextureFormat::RGBA: qualifier << "rgba"; break; 102 case tcu::TextureFormat::R: qualifier << "r"; break; 103 default: 104 DE_ASSERT(false); 105 return std::string(""); 106 } 107 108 switch (format.type) 109 { 110 case tcu::TextureFormat::FLOAT: qualifier << "32f"; break; 111 case tcu::TextureFormat::HALF_FLOAT: qualifier << "16f"; break; 112 case tcu::TextureFormat::UNORM_INT8: qualifier << "8"; break; 113 case tcu::TextureFormat::SNORM_INT8: qualifier << "8_snorm"; break; 114 case tcu::TextureFormat::SIGNED_INT32: qualifier << "32i"; break; 115 case tcu::TextureFormat::SIGNED_INT16: qualifier << "16i"; break; 116 case tcu::TextureFormat::SIGNED_INT8: qualifier << "8i"; break; 117 case tcu::TextureFormat::UNSIGNED_INT32: qualifier << "32ui"; break; 118 case tcu::TextureFormat::UNSIGNED_INT16: qualifier << "16ui"; break; 119 case tcu::TextureFormat::UNSIGNED_INT8: qualifier << "8ui"; break; 120 default: 121 DE_ASSERT(false); 122 return std::string(""); 123 } 124 125 return qualifier.str(); 126 } 127 128 std::string getShaderImageTypeDeclaration (const tcu::TextureFormat& format, gls::TextureTestUtil::TextureType imageType) 129 { 130 std::ostringstream declaration; 131 132 switch (format.type) 133 { 134 case tcu::TextureFormat::FLOAT: 135 case tcu::TextureFormat::HALF_FLOAT: 136 case tcu::TextureFormat::UNORM_INT8: 137 case tcu::TextureFormat::SNORM_INT8: declaration << ""; break; 138 139 case tcu::TextureFormat::SIGNED_INT32: 140 case tcu::TextureFormat::SIGNED_INT16: 141 case tcu::TextureFormat::SIGNED_INT8: declaration << "i"; break; 142 143 case tcu::TextureFormat::UNSIGNED_INT32: 144 case tcu::TextureFormat::UNSIGNED_INT16: 145 case tcu::TextureFormat::UNSIGNED_INT8: declaration << "u"; break; 146 147 default: 148 DE_ASSERT(false); 149 return std::string(""); 150 } 151 152 declaration << "image"; 153 154 switch(imageType) 155 { 156 case gls::TextureTestUtil::TEXTURETYPE_2D: declaration << "2D"; break; 157 case gls::TextureTestUtil::TEXTURETYPE_3D: declaration << "3D"; break; 158 case gls::TextureTestUtil::TEXTURETYPE_CUBE: declaration << "Cube"; break; 159 case gls::TextureTestUtil::TEXTURETYPE_2D_ARRAY: declaration << "2DArray"; break; 160 case gls::TextureTestUtil::TEXTURETYPE_BUFFER: declaration << "Buffer"; break; 161 case gls::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY: declaration << "CubeArray"; break; 162 default: 163 DE_ASSERT(false); 164 return std::string(""); 165 } 166 167 return declaration.str(); 168 } 169 170 std::string getShaderImageTypeExtensionString (gls::TextureTestUtil::TextureType imageType) 171 { 172 std::string extension; 173 174 switch(imageType) 175 { 176 case gls::TextureTestUtil::TEXTURETYPE_2D: 177 case gls::TextureTestUtil::TEXTURETYPE_3D: 178 case gls::TextureTestUtil::TEXTURETYPE_CUBE: 179 case gls::TextureTestUtil::TEXTURETYPE_2D_ARRAY: 180 extension = ""; 181 break; 182 183 case gls::TextureTestUtil::TEXTURETYPE_BUFFER: 184 extension = "#extension GL_EXT_texture_buffer : enable"; 185 break; 186 187 case gls::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY: 188 extension = "#extension GL_EXT_texture_cube_map_array : enable"; 189 break; 190 191 default: 192 DE_ASSERT(false); 193 return std::string(""); 194 } 195 196 return extension; 197 } 198 199 std::string getShaderImageParamP (gls::TextureTestUtil::TextureType imageType) 200 { 201 switch(imageType) 202 { 203 case gls::TextureTestUtil::TEXTURETYPE_2D: 204 return "ivec2(1, 1)"; 205 206 case gls::TextureTestUtil::TEXTURETYPE_3D: 207 case gls::TextureTestUtil::TEXTURETYPE_CUBE: 208 case gls::TextureTestUtil::TEXTURETYPE_2D_ARRAY: 209 case gls::TextureTestUtil::TEXTURETYPE_CUBE_ARRAY: 210 return "ivec3(1, 1, 1)"; 211 212 case gls::TextureTestUtil::TEXTURETYPE_BUFFER: 213 return "1"; 214 215 default: 216 DE_ASSERT(false); 217 return std::string(""); 218 } 219 } 220 221 std::string getOtherFunctionArguments (const tcu::TextureFormat& format, ImageOperation function) 222 { 223 std::ostringstream data; 224 data << ", "; 225 226 bool isFloat = false; 227 228 switch(format.type) 229 { 230 case tcu::TextureFormat::FLOAT: 231 case tcu::TextureFormat::HALF_FLOAT: 232 case tcu::TextureFormat::UNORM_INT8: 233 case tcu::TextureFormat::SNORM_INT8: 234 data << ""; 235 isFloat = true; 236 break; 237 238 case tcu::TextureFormat::SIGNED_INT32: 239 case tcu::TextureFormat::SIGNED_INT16: 240 case tcu::TextureFormat::SIGNED_INT8: 241 data << "i"; 242 break; 243 244 case tcu::TextureFormat::UNSIGNED_INT32: 245 case tcu::TextureFormat::UNSIGNED_INT16: 246 case tcu::TextureFormat::UNSIGNED_INT8: 247 data << "u"; 248 break; 249 250 default: 251 DE_ASSERT(false); 252 return std::string(""); 253 } 254 255 switch (function) 256 { 257 case IMAGE_OPERATION_LOAD: 258 return ""; 259 260 case IMAGE_OPERATION_STORE: 261 data << "vec4(1, 1, 1, 1)"; 262 break; 263 264 case IMAGE_OPERATION_ATOMIC_ADD: 265 case IMAGE_OPERATION_ATOMIC_MIN: 266 case IMAGE_OPERATION_ATOMIC_MAX: 267 case IMAGE_OPERATION_ATOMIC_AND: 268 case IMAGE_OPERATION_ATOMIC_OR: 269 case IMAGE_OPERATION_ATOMIC_XOR: 270 return ", 1"; 271 272 case IMAGE_OPERATION_ATOMIC_EXCHANGE: 273 return isFloat ? ", 1.0" : ", 1"; 274 275 case IMAGE_OPERATION_ATOMIC_COMP_SWAP: 276 return ", 1, 1"; 277 278 default: 279 DE_ASSERT(false); 280 return std::string(""); 281 } 282 return data.str(); 283 } 284 285 std::string getMemoryQualifier (MemoryQualifier memory) 286 { 287 switch (memory) 288 { 289 case MEMORY_NONE: 290 return std::string(""); 291 292 case MEMORY_WRITEONLY: 293 return std::string("writeonly"); 294 295 case MEMORY_READONLY: 296 return std::string("readonly"); 297 298 case MEMORY_BOTH: 299 return std::string("writeonly readonly"); 300 301 default: 302 DE_ASSERT(DE_FALSE); 303 } 304 305 return std::string(""); 306 } 307 308 std::string getShaderImageFunctionExtensionString (ImageOperation function) 309 { 310 switch (function) 311 { 312 case IMAGE_OPERATION_STORE: 313 case IMAGE_OPERATION_LOAD: 314 return std::string(""); 315 316 case IMAGE_OPERATION_ATOMIC_ADD: 317 case IMAGE_OPERATION_ATOMIC_MIN: 318 case IMAGE_OPERATION_ATOMIC_MAX: 319 case IMAGE_OPERATION_ATOMIC_AND: 320 case IMAGE_OPERATION_ATOMIC_OR: 321 case IMAGE_OPERATION_ATOMIC_XOR: 322 case IMAGE_OPERATION_ATOMIC_EXCHANGE: 323 case IMAGE_OPERATION_ATOMIC_COMP_SWAP: 324 return std::string("#extension GL_OES_shader_image_atomic : enable"); 325 326 default: 327 DE_ASSERT(DE_FALSE); 328 } 329 return std::string(""); 330 } 331 332 std::string getFunctionName (ImageOperation function) 333 { 334 switch (function) 335 { 336 case IMAGE_OPERATION_STORE: return std::string("imageStore"); 337 case IMAGE_OPERATION_LOAD: return std::string("imageLoad"); 338 case IMAGE_OPERATION_ATOMIC_ADD: return std::string("imageAtomicAdd"); 339 case IMAGE_OPERATION_ATOMIC_MIN: return std::string("imageAtomicMin"); 340 case IMAGE_OPERATION_ATOMIC_MAX: return std::string("imageAtomicMax"); 341 case IMAGE_OPERATION_ATOMIC_AND: return std::string("imageAtomicAnd"); 342 case IMAGE_OPERATION_ATOMIC_OR: return std::string("imageAtomicOr"); 343 case IMAGE_OPERATION_ATOMIC_XOR: return std::string("imageAtomicXor"); 344 case IMAGE_OPERATION_ATOMIC_EXCHANGE: return std::string("imageAtomicExchange"); 345 case IMAGE_OPERATION_ATOMIC_COMP_SWAP: return std::string("imageAtomicCompSwap"); 346 default: 347 DE_ASSERT(DE_FALSE); 348 } 349 return std::string(""); 350 } 351 352 std::string generateShaderSource (ImageOperation function, MemoryQualifier memory, gls::TextureTestUtil::TextureType imageType, const tcu::TextureFormat& format, glu::ShaderType shaderType) 353 { 354 const char* shaderTemplate = "${GLSL_VERSION_DECL}\n" 355 "${GLSL_TYPE_EXTENSION}\n" 356 "${GLSL_FUNCTION_EXTENSION}\n" 357 "${GEOMETRY_SHADER_LAYOUT}\n" 358 "layout(${LAYOUT_FORMAT}, binding = 0) highp uniform ${MEMORY_QUALIFIER} ${IMAGE_TYPE} u_img0;\n" 359 "void main(void)\n" 360 "{\n" 361 " ${FUNCTION_NAME}(u_img0, ${IMAGE_PARAM_P}${FUNCTION_ARGUMENTS});\n" 362 "}\n"; 363 364 std::map<std::string, std::string> params; 365 366 params["GLSL_VERSION_DECL"] = getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES); 367 params["GLSL_TYPE_EXTENSION"] = getShaderImageTypeExtensionString(imageType); 368 params["GLSL_FUNCTION_EXTENSION"] = getShaderImageFunctionExtensionString(function); 369 params["GEOMETRY_SHADER_LAYOUT"] = getGLShaderType(shaderType) == GL_GEOMETRY_SHADER ? "layout(max_vertices = 3) out;" : ""; 370 params["LAYOUT_FORMAT"] = getShaderImageLayoutQualifier(format); 371 params["MEMORY_QUALIFIER"] = getMemoryQualifier(memory); 372 params["IMAGE_TYPE"] = getShaderImageTypeDeclaration(format, imageType); 373 params["FUNCTION_NAME"] = getFunctionName(function); 374 params["IMAGE_PARAM_P"] = getShaderImageParamP(imageType); 375 params["FUNCTION_ARGUMENTS"] = getOtherFunctionArguments(format, function); 376 377 return tcu::StringTemplate(shaderTemplate).specialize(params); 378 } 379 380 void testShader (NegativeTestContext& ctx, ImageOperation function, MemoryQualifier memory, gls::TextureTestUtil::TextureType imageType, const tcu::TextureFormat& format) 381 { 382 tcu::TestLog& log = ctx.getLog(); 383 ctx.beginSection(getFunctionName(function) + " " + getMemoryQualifier(memory) + " " + getShaderImageLayoutQualifier(format)); 384 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_shaders); ndx++) 385 { 386 if (ctx.isShaderSupported(s_shaders[ndx])) 387 { 388 ctx.beginSection(std::string("Verify shader: ") + glu::getShaderTypeName(s_shaders[ndx])); 389 std::string shaderSource(generateShaderSource(function, memory, imageType, format, s_shaders[ndx])); 390 const glu::ShaderProgram program(ctx.getRenderContext(), glu::ProgramSources() << glu::ShaderSource(s_shaders[ndx], shaderSource)); 391 if (program.getShaderInfo(s_shaders[ndx]).compileOk) 392 { 393 log << program; 394 log << tcu::TestLog::Message << "Expected program to fail, but compilation passed." << tcu::TestLog::EndMessage; 395 ctx.fail("Shader was not expected to compile."); 396 } 397 ctx.endSection(); 398 } 399 } 400 ctx.endSection(); 401 } 402 403 void image_store (NegativeTestContext& ctx) 404 { 405 const tcu::TextureFormat formats[] = 406 { 407 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::FLOAT), 408 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::HALF_FLOAT), 409 tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::FLOAT), 410 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), 411 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SNORM_INT8), 412 413 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT32), 414 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT16), 415 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT8), 416 tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::SIGNED_INT32), 417 418 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT32), 419 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT16), 420 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT8), 421 tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::UNSIGNED_INT32) 422 }; 423 424 const MemoryQualifier memoryOptions[] = 425 { 426 MEMORY_READONLY, 427 MEMORY_BOTH 428 }; 429 430 ctx.beginSection("It is an error to pass a readonly image to imageStore."); 431 for (int memoryNdx = 0; memoryNdx < DE_LENGTH_OF_ARRAY(memoryOptions); ++memoryNdx) 432 { 433 for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); ++fmtNdx) 434 { 435 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_imageTypes); ++typeNdx) 436 { 437 testShader(ctx, IMAGE_OPERATION_STORE, memoryOptions[memoryNdx], s_imageTypes[typeNdx], formats[fmtNdx]); 438 } 439 } 440 } 441 ctx.endSection(); 442 } 443 444 void image_load (NegativeTestContext& ctx) 445 { 446 const tcu::TextureFormat formats[] = 447 { 448 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::FLOAT), 449 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::HALF_FLOAT), 450 tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::FLOAT), 451 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), 452 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SNORM_INT8), 453 454 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT32), 455 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT16), 456 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT8), 457 tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::SIGNED_INT32), 458 459 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT32), 460 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT16), 461 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT8), 462 tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::UNSIGNED_INT32) 463 }; 464 465 const MemoryQualifier memoryOptions[] = 466 { 467 MEMORY_WRITEONLY, 468 MEMORY_BOTH 469 }; 470 471 ctx.beginSection("It is an error to pass a writeonly image to imageLoad."); 472 for (int memoryNdx = 0; memoryNdx < DE_LENGTH_OF_ARRAY(memoryOptions); ++memoryNdx) 473 { 474 for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); ++fmtNdx) 475 { 476 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_imageTypes); ++typeNdx) 477 { 478 testShader(ctx, IMAGE_OPERATION_LOAD, memoryOptions[memoryNdx], s_imageTypes[typeNdx], formats[fmtNdx]); 479 } 480 } 481 } 482 ctx.endSection(); 483 } 484 485 void image_atomic (NegativeTestContext& ctx) 486 { 487 const tcu::TextureFormat formats[] = 488 { 489 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT32), 490 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT16), 491 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT8), 492 tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::SIGNED_INT32), 493 494 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT32), 495 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT16), 496 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT8), 497 tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::UNSIGNED_INT32) 498 }; 499 500 const MemoryQualifier memoryOptions[] = 501 { 502 MEMORY_READONLY, 503 MEMORY_WRITEONLY, 504 MEMORY_BOTH 505 }; 506 507 const ImageOperation imageOperations[] = 508 { 509 IMAGE_OPERATION_ATOMIC_ADD, 510 IMAGE_OPERATION_ATOMIC_MIN, 511 IMAGE_OPERATION_ATOMIC_MAX, 512 IMAGE_OPERATION_ATOMIC_AND, 513 IMAGE_OPERATION_ATOMIC_OR, 514 IMAGE_OPERATION_ATOMIC_XOR, 515 IMAGE_OPERATION_ATOMIC_COMP_SWAP 516 }; 517 518 ctx.beginSection("It is an error to pass a writeonly and/or readonly image to imageAtomic*."); 519 for (int memoryNdx = 0; memoryNdx < DE_LENGTH_OF_ARRAY(memoryOptions); ++memoryNdx) 520 { 521 for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); ++fmtNdx) 522 { 523 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_imageTypes); ++typeNdx) 524 { 525 for (int functionNdx = 0; functionNdx < DE_LENGTH_OF_ARRAY(imageOperations); ++functionNdx) 526 { 527 testShader(ctx, imageOperations[functionNdx], memoryOptions[memoryNdx], s_imageTypes[typeNdx], formats[fmtNdx]); 528 } 529 } 530 } 531 } 532 ctx.endSection(); 533 } 534 535 void image_atomic_exchange (NegativeTestContext& ctx) 536 { 537 const tcu::TextureFormat formats[] = 538 { 539 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::FLOAT), 540 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::HALF_FLOAT), 541 tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::FLOAT), 542 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), 543 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SNORM_INT8), 544 545 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT32), 546 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT16), 547 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT8), 548 tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::SIGNED_INT32), 549 550 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT32), 551 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT16), 552 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT8), 553 tcu::TextureFormat(tcu::TextureFormat::R, tcu::TextureFormat::UNSIGNED_INT32) 554 }; 555 556 const MemoryQualifier memoryOptions[] = 557 { 558 MEMORY_READONLY, 559 MEMORY_WRITEONLY, 560 MEMORY_BOTH 561 }; 562 563 ctx.beginSection("It is an error to pass a writeonly and/or readonly image to imageAtomic*."); 564 for (int memoryNdx = 0; memoryNdx < DE_LENGTH_OF_ARRAY(memoryOptions); ++memoryNdx) 565 { 566 for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); ++fmtNdx) 567 { 568 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_imageTypes); ++typeNdx) 569 { 570 testShader(ctx, IMAGE_OPERATION_ATOMIC_EXCHANGE, memoryOptions[memoryNdx], s_imageTypes[typeNdx], formats[fmtNdx]); 571 } 572 } 573 } 574 ctx.endSection(); 575 } 576 577 } // anonymous 578 579 std::vector<FunctionContainer> getNegativeShaderImageLoadStoreTestFunctions (void) 580 { 581 const FunctionContainer funcs[] = 582 { 583 {image_store, "image_store", "Test incorrect usage of imageStore()" }, 584 {image_load, "image_load", "Test incorrect usage of imageLoad()" }, 585 {image_atomic, "image_atomic", "Test incorrect usage of imageAtomic*()" }, 586 {image_atomic_exchange, "image_atomic_exchange", "Test incorrect usage of imageAtomicExchange()" }, 587 }; 588 589 return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs)); 590 } 591 592 } // NegativeTestShared 593 } // Functional 594 } // gles31 595 } // deqp 596