1/*------------------------------------------------------------------------- 2 * OpenGL Conformance Test Suite 3 * ----------------------------- 4 * 5 * Copyright (c) 2016 The Khronos Group 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 22 */ /*-------------------------------------------------------------------*/ 23 24/** 25 */ /*! 26 * \file gl4cSparseTextureClampTests.cpp 27 * \brief Conformance tests for the GL_ARB_sparse_texture2 functionality. 28 */ /*-------------------------------------------------------------------*/ 29 30#include "gl4cSparseTextureClampTests.hpp" 31#include "deStringUtil.hpp" 32#include "gl4cSparseTexture2Tests.hpp" 33#include "gl4cSparseTextureTests.hpp" 34#include "gluContextInfo.hpp" 35#include "gluDefs.hpp" 36#include "glwEnums.hpp" 37#include "glwFunctions.hpp" 38#include "tcuImageIO.hpp" 39#include "tcuTestLog.hpp" 40 41#include <cmath> 42#include <string.h> 43#include <vector> 44 45using namespace glw; 46using namespace glu; 47 48namespace gl4cts 49{ 50 51const char* stc_compute_textureFill = "#version 430 core\n" 52 "\n" 53 "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 54 "\n" 55 "layout (location = 1) writeonly uniform highp <INPUT_TYPE> uni_image;\n" 56 "\n" 57 "void main()\n" 58 "{\n" 59 " <POINT_TYPE> point = <POINT_TYPE>(<POINT_DEF>);\n" 60 " memoryBarrier();\n" 61 " <RETURN_TYPE> color = <RETURN_TYPE><RESULT_EXPECTED>;\n" 62 " imageStore(uni_image, point<SAMPLE_DEF>, color);\n" 63 "}\n"; 64 65const char* stc_vertex_common = "#version 450\n" 66 "\n" 67 "in vec3 vertex;\n" 68 "in <COORD_TYPE> inCoord;\n" 69 "out <COORD_TYPE> texCoord;\n" 70 "\n" 71 "void main()\n" 72 "{\n" 73 " texCoord = inCoord;\n" 74 " gl_Position = vec4(vertex, 1);\n" 75 "}\n"; 76 77const char* stc_fragment_lookupResidency = "#version 450 core\n" 78 "\n" 79 "#extension GL_ARB_sparse_texture2 : enable\n" 80 "#extension GL_ARB_sparse_texture_clamp : enable\n" 81 "\n" 82 "in <COORD_TYPE> texCoord;\n" 83 "out vec4 fragColor;\n" 84 "\n" 85 "layout (location = 1<FORMAT_DEF>) uniform <INPUT_TYPE> uni_in;\n" 86 "layout (location = 2) uniform int widthCommitted;\n" 87 "\n" 88 "void main()\n" 89 "{\n" 90 " <COORD_TYPE> coord = texCoord;\n" 91 " <ICOORD_TYPE> texSize = <ICOORD_TYPE>(<SIZE_DEF>);\n" 92 " <POINT_TYPE> point = <POINT_TYPE>(coord * texSize);\n" 93 " <RETURN_TYPE> retValue,\n" 94 " expValue,\n" 95 " epsilon;\n" 96 " retValue = <RETURN_TYPE>(0);\n" 97 " expValue = <RETURN_TYPE><RESULT_EXPECTED>;\n" 98 " epsilon = <RETURN_TYPE>(<EPSILON>);\n" 99 "\n" 100 "<CUBE_MAP_COORD_DEF>\n" 101 "<OFFSET_ARRAY_DEF>\n" 102 "\n" 103 " ivec2 corner1 = ivec2(1, 1);\n" 104 " ivec2 corner2 = ivec2(texSize.x - 1, texSize.y - 1);\n" 105 "\n" 106 " int code = <FUNCTION>(uni_in,\n" 107 " <POINT_COORD><SAMPLE_DEF><ARGUMENTS>,\n" 108 " retValue<COMPONENT_DEF>);\n" 109 "\n" 110 " fragColor = vec4(1);\n" 111 "\n" 112 " if (point.x > corner1.x && point.y > corner1.y &&\n" 113 " point.x < corner2.x && point.y < corner2.y &&\n" 114 " point.x < widthCommitted - 1)\n" 115 " {\n" 116 " if (!sparseTexelsResidentARB(code) ||\n" 117 " any(greaterThan(retValue, expValue + epsilon)) ||\n" 118 " any(lessThan(retValue, expValue - epsilon)))\n" 119 " {\n" 120 " fragColor = vec4(0);\n" 121 " }\n" 122 " }\n" 123 "\n" 124 " if (point.x > corner1.x && point.y > corner1.y &&\n" 125 " point.x < corner2.x && point.y < corner2.y &&\n" 126 " point.x >= widthCommitted + 1)\n" 127 " {\n" 128 " if (sparseTexelsResidentARB(code))\n" 129 " {\n" 130 " fragColor = vec4(0);\n" 131 " }\n" 132 " }\n" 133 "}\n"; 134 135const char* stc_fragment_lookupColor = "#version 450 core\n" 136 "\n" 137 "#extension GL_ARB_sparse_texture2 : enable\n" 138 "#extension GL_ARB_sparse_texture_clamp : enable\n" 139 "\n" 140 "in <COORD_TYPE> texCoord;\n" 141 "out vec4 fragColor;\n" 142 "\n" 143 "layout (location = 1<FORMAT_DEF>) uniform <INPUT_TYPE> uni_in;\n" 144 "\n" 145 "void main()\n" 146 "{\n" 147 " <COORD_TYPE> coord = texCoord;\n" 148 " <ICOORD_TYPE> texSize = <ICOORD_TYPE>(<SIZE_DEF>);\n" 149 " <POINT_TYPE> point = <POINT_TYPE>(coord * texSize);\n" 150 " <RETURN_TYPE> retValue,\n" 151 " expValue,\n" 152 " epsilon;\n" 153 " retValue = <RETURN_TYPE>(0);\n" 154 " expValue = <RETURN_TYPE><RESULT_EXPECTED>;\n" 155 " epsilon = <RETURN_TYPE>(<EPSILON>);\n" 156 "\n" 157 "<CUBE_MAP_COORD_DEF>\n" 158 "<OFFSET_ARRAY_DEF>\n" 159 "\n" 160 "<FUNCTION_DEF>\n" 161 "\n" 162 " fragColor = vec4(1);\n" 163 "\n" 164 " if (any(greaterThan(retValue, expValue + epsilon)) ||\n" 165 " any(lessThan(retValue, expValue - epsilon)))\n" 166 " {\n" 167 " fragColor = vec4(0);\n" 168 " }\n" 169 "}\n"; 170 171/** Constructor. 172 * 173 * @param context Rendering context 174 */ 175SparseTextureClampLookupResidencyTestCase::SparseTextureClampLookupResidencyTestCase(deqp::Context& context) 176 : SparseTexture2LookupTestCase( 177 context, "SparseTextureClampLookupResidency", 178 "Verifies if sparse texture clamp lookup functions generates access residency information") 179{ 180 /* Left blank intentionally */ 181} 182 183/** Constructor. 184 * 185 * @param context Rendering context 186 */ 187SparseTextureClampLookupResidencyTestCase::SparseTextureClampLookupResidencyTestCase(deqp::Context& context, 188 const char* name, 189 const char* description) 190 : SparseTexture2LookupTestCase(context, name, description) 191{ 192 /* Left blank intentionally */ 193} 194 195/** Stub init method */ 196void SparseTextureClampLookupResidencyTestCase::init() 197{ 198 SparseTextureCommitmentTestCase::init(); 199 mSupportedInternalFormats.push_back(GL_DEPTH_COMPONENT16); 200 201 FunctionToken f; 202 f = FunctionToken("sparseTextureClampARB", "<CUBE_REFZ_DEF>, <LOD>"); 203 f.allowedTargets.insert(GL_TEXTURE_2D); 204 f.allowedTargets.insert(GL_TEXTURE_2D_ARRAY); 205 f.allowedTargets.insert(GL_TEXTURE_CUBE_MAP); 206 f.allowedTargets.insert(GL_TEXTURE_CUBE_MAP_ARRAY); 207 f.allowedTargets.insert(GL_TEXTURE_3D); 208 mFunctions.push_back(f); 209 210 f = FunctionToken("sparseTextureOffsetClampARB", ", <OFFSET_TYPE><OFFSET_DIM>(0), <LOD>"); 211 f.allowedTargets.insert(GL_TEXTURE_2D); 212 f.allowedTargets.insert(GL_TEXTURE_2D_ARRAY); 213 f.allowedTargets.insert(GL_TEXTURE_3D); 214 mFunctions.push_back(f); 215 216 f = FunctionToken("sparseTextureGradClampARB", 217 ", <NOFFSET_TYPE><OFFSET_DIM>(0), <NOFFSET_TYPE><OFFSET_DIM>(0), <LOD>"); 218 f.allowedTargets.insert(GL_TEXTURE_2D); 219 f.allowedTargets.insert(GL_TEXTURE_2D_ARRAY); 220 f.allowedTargets.insert(GL_TEXTURE_CUBE_MAP); 221 f.allowedTargets.insert(GL_TEXTURE_CUBE_MAP_ARRAY); 222 f.allowedTargets.insert(GL_TEXTURE_3D); 223 mFunctions.push_back(f); 224 225 f = FunctionToken( 226 "sparseTextureGradOffsetClampARB", 227 ", <NOFFSET_TYPE><OFFSET_DIM>(0), <NOFFSET_TYPE><OFFSET_DIM>(0), <OFFSET_TYPE><OFFSET_DIM>(0), <LOD>"); 228 f.allowedTargets.insert(GL_TEXTURE_2D); 229 f.allowedTargets.insert(GL_TEXTURE_2D_ARRAY); 230 f.allowedTargets.insert(GL_TEXTURE_3D); 231 mFunctions.push_back(f); 232} 233 234/** Executes test iteration. 235 * 236 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 237 */ 238tcu::TestNode::IterateResult SparseTextureClampLookupResidencyTestCase::iterate() 239{ 240 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_sparse_texture_clamp")) 241 { 242 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); 243 return STOP; 244 } 245 246 return SparseTexture2LookupTestCase::iterate(); 247} 248 249/** Check if specific lookup function is allowed for specific target and format 250 * 251 * @param target Target for which texture is binded 252 * @param format Texture internal format 253 * @param funcToken Texture lookup function structure 254 * 255 * @return Returns true if target/format combination is allowed, false otherwise. 256 */ 257bool SparseTextureClampLookupResidencyTestCase::funcAllowed(GLint target, GLint format, FunctionToken& funcToken) 258{ 259 if (funcToken.allowedTargets.find(target) == funcToken.allowedTargets.end()) 260 return false; 261 262 if (format == GL_DEPTH_COMPONENT16) 263 { 264 if (target == GL_TEXTURE_CUBE_MAP_ARRAY && 265 (funcToken.name == "sparseTextureGradClampARB" || funcToken.name == "textureGradClampARB")) 266 return false; 267 } 268 269 return true; 270} 271 272/** Verify if data stored in texture is as expected 273 * 274 * @param gl GL API functions 275 * @param target Target for which texture is binded 276 * @param format Texture internal format 277 * @param texture Texture object 278 * @param level Texture mipmap level 279 * @param funcToken Lookup function tokenize structure 280 * 281 * @return Returns true if data is as expected, false if not, throws an exception if error occurred. 282 */ 283bool SparseTextureClampLookupResidencyTestCase::verifyLookupTextureData(const Functions& gl, GLint target, GLint format, 284 GLuint& texture, GLint level, 285 FunctionToken& funcToken) 286{ 287 mLog << "Verify Lookup Residency Texture Data [function: " << funcToken.name << ", level: " << level << "] - "; 288 289 if (level > mState.levels - 1) 290 TCU_FAIL("Invalid level"); 291 292 GLint width; 293 GLint height; 294 GLint depth; 295 SparseTextureUtils::getTextureLevelSize(target, mState, level, width, height, depth); 296 297 //Committed region is limited to 1/2 of width 298 GLint widthCommitted = width / 2; 299 300 if (widthCommitted == 0 || height == 0 || depth < mState.minDepth) 301 return true; 302 303 bool result = true; 304 305 if (target == GL_TEXTURE_CUBE_MAP) 306 depth = depth * 6; 307 308 GLint texSize = width * height; 309 310 std::vector<GLubyte> vecExpData; 311 std::vector<GLubyte> vecOutData; 312 vecExpData.resize(texSize); 313 vecOutData.resize(texSize); 314 GLubyte* exp_data = vecExpData.data(); 315 GLubyte* out_data = vecOutData.data(); 316 317 // Expected data is 255 because 318 deMemset(exp_data, 255, texSize); 319 320 // Create verifying texture 321 GLint verifyTarget = GL_TEXTURE_2D; 322 GLuint verifyTexture; 323 Texture::Generate(gl, verifyTexture); 324 Texture::Bind(gl, verifyTexture, verifyTarget); 325 Texture::Storage(gl, verifyTarget, 1, GL_R8, width, height, depth); 326 GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::Storage"); 327 328 GLuint fbo; 329 gl.genFramebuffers(1, &fbo); 330 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers"); 331 gl.bindFramebuffer(GL_FRAMEBUFFER, fbo); 332 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer"); 333 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, verifyTarget, verifyTexture, 0); 334 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D"); 335 336 gl.viewport(0, 0, width, height); 337 338 for (GLint z = 0; z < depth; ++z) 339 { 340 for (int sample = 0; sample < mState.samples; ++sample) 341 { 342 deMemset(out_data, 0, texSize); 343 344 Texture::Bind(gl, verifyTexture, verifyTarget); 345 Texture::SubImage(gl, verifyTarget, 0, 0, 0, 0, width, height, 0, GL_RED, GL_UNSIGNED_BYTE, 346 (GLvoid*)out_data); 347 GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::SubImage"); 348 349 std::string vertex = stc_vertex_common; 350 std::string fragment = stc_fragment_lookupResidency; 351 352 // Make token copy to work on 353 FunctionToken f = funcToken; 354 355 // Adjust shader source to texture format 356 TokenStringsExt s = createLookupShaderTokens(target, format, level, sample, f); 357 358 replaceToken("<COORD_TYPE>", s.coordType.c_str(), vertex); 359 360 replaceToken("<FUNCTION>", f.name.c_str(), fragment); 361 replaceToken("<ARGUMENTS>", f.arguments.c_str(), fragment); 362 363 replaceToken("<OUTPUT_TYPE>", s.outputType.c_str(), fragment); 364 replaceToken("<INPUT_TYPE>", s.inputType.c_str(), fragment); 365 replaceToken("<SIZE_DEF>", s.sizeDef.c_str(), fragment); 366 replaceToken("<LOD>", s.lod.c_str(), fragment); 367 replaceToken("<LOD_DEF>", s.lodDef.c_str(), fragment); 368 replaceToken("<COORD_TYPE>", s.coordType.c_str(), fragment); 369 replaceToken("<ICOORD_TYPE>", s.iCoordType.c_str(), fragment); 370 replaceToken("<COORD_DEF>", s.coordDef.c_str(), fragment); 371 replaceToken("<POINT_TYPE>", s.pointType.c_str(), fragment); 372 replaceToken("<POINT_DEF>", s.pointDef.c_str(), fragment); 373 replaceToken("<RETURN_TYPE>", s.returnType.c_str(), fragment); 374 replaceToken("<RESULT_EXPECTED>", s.resultExpected.c_str(), fragment); 375 replaceToken("<EPSILON>", s.epsilon.c_str(), fragment); 376 replaceToken("<SAMPLE_DEF>", s.sampleDef.c_str(), fragment); 377 replaceToken("<REFZ_DEF>", s.refZDef.c_str(), fragment); 378 replaceToken("<CUBE_REFZ_DEF>", s.cubeMapArrayRefZDef.c_str(), fragment); 379 replaceToken("<POINT_COORD>", s.pointCoord.c_str(), fragment); 380 replaceToken("<COMPONENT_DEF>", s.componentDef.c_str(), fragment); 381 replaceToken("<CUBE_MAP_COORD_DEF>", s.cubeMapCoordDef.c_str(), fragment); 382 replaceToken("<OFFSET_ARRAY_DEF>", s.offsetArrayDef.c_str(), fragment); 383 replaceToken("<FORMAT_DEF>", s.formatDef.c_str(), fragment); 384 replaceToken("<OFFSET_TYPE>", s.offsetType.c_str(), fragment); 385 replaceToken("<NOFFSET_TYPE>", s.nOffsetType.c_str(), fragment); 386 replaceToken("<OFFSET_DIM>", s.offsetDim.c_str(), fragment); 387 388 replaceToken("<TEX_WIDTH>", de::toString(width).c_str(), fragment); 389 replaceToken("<TEX_HEIGHT>", de::toString(height).c_str(), fragment); 390 replaceToken("<TEX_DEPTH>", de::toString(depth).c_str(), fragment); 391 392 ProgramSources sources = makeVtxFragSources(vertex.c_str(), fragment.c_str()); 393 394 // Build and run shader 395 ShaderProgram program(m_context.getRenderContext(), sources); 396 if (program.isOk()) 397 { 398 gl.useProgram(program.getProgram()); 399 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram"); 400 401 // Pass input sampler/image to shader 402 gl.activeTexture(GL_TEXTURE0); 403 GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture"); 404 gl.uniform1i(1, 0 /* sampler_unit */); 405 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i"); 406 407 // Pass committed region width to shader 408 gl.uniform1i(2, widthCommitted /* committed region width */); 409 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i"); 410 411 gl.bindTexture(target, texture); 412 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture"); 413 414 gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 415 draw(target, z, program); 416 417 Texture::Bind(gl, verifyTexture, verifyTarget); 418 Texture::GetData(gl, 0, verifyTarget, GL_RED, GL_UNSIGNED_BYTE, (GLvoid*)out_data); 419 GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::GetData"); 420 421 //Verify only committed region 422 for (GLint y = 0; y < height; ++y) 423 for (GLint x = 0; x < width; ++x) 424 { 425 GLubyte* dataRegion = exp_data + x + y * width; 426 GLubyte* outDataRegion = out_data + x + y * width; 427 if (dataRegion[0] != outDataRegion[0]) 428 result = false; 429 } 430 } 431 else 432 { 433 mLog << "Shader compilation failed (lookup residency) for target: " << target << ", format: " << format 434 << ", vertexInfoLog: " << program.getShaderInfo(SHADERTYPE_VERTEX).infoLog 435 << ", fragmentInfoLog: " << program.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog 436 << ", programInfoLog: " << program.getProgramInfo().infoLog 437 << ", fragmentSource: " << fragment.c_str() << " - "; 438 439 result = false; 440 } 441 } 442 } 443 444 gl.bindFramebuffer(GL_FRAMEBUFFER, 0); 445 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer"); 446 447 Texture::Delete(gl, verifyTexture); 448 449 return result; 450} 451 452void SparseTextureClampLookupResidencyTestCase::draw(GLint target, GLint layer, const ShaderProgram& program) 453{ 454 const GLfloat texCoord1D[] = { 0.0f, 1.0f, 0.0f, 1.0f }; 455 456 const GLfloat texCoord2D[] = { 457 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 458 }; 459 460 const GLfloat texCoord3D[] = { 0.0f, 0.0f, 0.5f, 1.0f, 0.0f, 0.5f, 0.0f, 1.0f, 0.5f, 1.0f, 1.0f, 0.5f }; 461 462 const GLfloat texCoordCubeMap[6][12] = { 463 { 0.0f, 0.0f, 0.00f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f }, 464 { 0.0f, 0.0f, 0.17f, 1.0f, 0.0f, 0.17f, 0.0f, 1.0f, 0.17f, 1.0f, 1.0f, 0.17f }, 465 { 0.0f, 0.0f, 0.33f, 1.0f, 0.0f, 0.33f, 0.0f, 1.0f, 0.33f, 1.0f, 1.0f, 0.33f }, 466 { 0.0f, 0.0f, 0.5f, 1.0f, 0.0f, 0.5f, 0.0f, 1.0f, 0.5f, 1.0f, 1.0f, 0.5f }, 467 { 0.0f, 0.0f, 0.67f, 1.0f, 0.0f, 0.67f, 0.0f, 1.0f, 0.67f, 1.0f, 1.0f, 0.67f }, 468 { 0.0f, 0.0f, 0.83f, 1.0f, 0.0f, 0.83f, 0.0f, 1.0f, 0.83f, 1.0f, 1.0f, 0.83f } 469 }; 470 471 const GLfloat vertices[] = { 472 -1.0f, -1.0f, 0.0f, 1.0f, -1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 473 }; 474 475 const GLuint indices[] = { 0, 1, 2, 1, 2, 3 }; 476 477 VertexArrayBinding floatCoord; 478 479 if (target == GL_TEXTURE_1D || target == GL_TEXTURE_1D_ARRAY) 480 floatCoord = glu::va::Float("inCoord", 1, 4, 0, texCoord1D); 481 else if (target == GL_TEXTURE_3D) 482 floatCoord = glu::va::Float("inCoord", 3, 4, 0, texCoord3D); 483 else if (target == GL_TEXTURE_CUBE_MAP) 484 floatCoord = glu::va::Float("inCoord", 3, 4, 0, texCoordCubeMap[layer]); 485 else if (target == GL_TEXTURE_CUBE_MAP_ARRAY) 486 { 487 GLfloat layerCoord = GLfloat(layer) / 6.0f + 0.01f; 488 const GLfloat texCoordCubeMapArray[16] = { 0.0f, 0.0f, layerCoord, GLfloat(layer), 489 1.0f, 0.0f, layerCoord, GLfloat(layer), 490 0.0f, 1.0f, layerCoord, GLfloat(layer), 491 1.0f, 1.0f, layerCoord, GLfloat(layer) }; 492 floatCoord = glu::va::Float("inCoord", 4, 4, 0, texCoordCubeMapArray); 493 } 494 else 495 floatCoord = glu::va::Float("inCoord", 2, 4, 0, texCoord2D); 496 497 glu::VertexArrayBinding vertexArrays[] = { glu::va::Float("vertex", 3, 4, 0, vertices), floatCoord }; 498 499 glu::draw(m_context.getRenderContext(), program.getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays), vertexArrays, 500 glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(indices), indices)); 501} 502 503/** Constructor. 504 * 505 * @param context Rendering context 506 */ 507SparseTextureClampLookupColorTestCase::SparseTextureClampLookupColorTestCase(deqp::Context& context) 508 : SparseTextureClampLookupResidencyTestCase( 509 context, "SparseTextureClampLookupColor", 510 "Verifies if sparse and non-sparse texture clamp lookup functions works as expected") 511{ 512 /* Left blank intentionally */ 513} 514 515/** Stub init method */ 516void SparseTextureClampLookupColorTestCase::init() 517{ 518 SparseTextureCommitmentTestCase::init(); 519 mSupportedTargets.push_back(GL_TEXTURE_1D); 520 mSupportedTargets.push_back(GL_TEXTURE_1D_ARRAY); 521 mSupportedInternalFormats.push_back(GL_DEPTH_COMPONENT16); 522 523 FunctionToken f; 524 f = FunctionToken("sparseTextureClampARB", "<CUBE_REFZ_DEF>, <LOD>"); 525 f.allowedTargets.insert(GL_TEXTURE_2D); 526 f.allowedTargets.insert(GL_TEXTURE_2D_ARRAY); 527 f.allowedTargets.insert(GL_TEXTURE_CUBE_MAP); 528 f.allowedTargets.insert(GL_TEXTURE_CUBE_MAP_ARRAY); 529 f.allowedTargets.insert(GL_TEXTURE_3D); 530 mFunctions.push_back(f); 531 532 f = FunctionToken("textureClampARB", "<CUBE_REFZ_DEF>, <LOD>"); 533 f.allowedTargets.insert(GL_TEXTURE_1D); 534 f.allowedTargets.insert(GL_TEXTURE_1D_ARRAY); 535 f.allowedTargets.insert(GL_TEXTURE_2D); 536 f.allowedTargets.insert(GL_TEXTURE_2D_ARRAY); 537 f.allowedTargets.insert(GL_TEXTURE_CUBE_MAP); 538 f.allowedTargets.insert(GL_TEXTURE_CUBE_MAP_ARRAY); 539 f.allowedTargets.insert(GL_TEXTURE_3D); 540 mFunctions.push_back(f); 541 542 f = FunctionToken("sparseTextureOffsetClampARB", ", <OFFSET_TYPE><OFFSET_DIM>(0), <LOD>"); 543 f.allowedTargets.insert(GL_TEXTURE_2D); 544 f.allowedTargets.insert(GL_TEXTURE_2D_ARRAY); 545 f.allowedTargets.insert(GL_TEXTURE_3D); 546 mFunctions.push_back(f); 547 548 f = FunctionToken("textureOffsetClampARB", ", <OFFSET_TYPE><OFFSET_DIM>(0), <LOD>"); 549 f.allowedTargets.insert(GL_TEXTURE_1D); 550 f.allowedTargets.insert(GL_TEXTURE_1D_ARRAY); 551 f.allowedTargets.insert(GL_TEXTURE_2D); 552 f.allowedTargets.insert(GL_TEXTURE_2D_ARRAY); 553 f.allowedTargets.insert(GL_TEXTURE_3D); 554 mFunctions.push_back(f); 555 556 f = FunctionToken("sparseTextureGradClampARB", 557 ", <NOFFSET_TYPE><OFFSET_DIM>(0), <NOFFSET_TYPE><OFFSET_DIM>(0), <LOD>"); 558 f.allowedTargets.insert(GL_TEXTURE_2D); 559 f.allowedTargets.insert(GL_TEXTURE_2D_ARRAY); 560 f.allowedTargets.insert(GL_TEXTURE_CUBE_MAP); 561 f.allowedTargets.insert(GL_TEXTURE_CUBE_MAP_ARRAY); 562 f.allowedTargets.insert(GL_TEXTURE_3D); 563 mFunctions.push_back(f); 564 565 f = FunctionToken("textureGradClampARB", ", <NOFFSET_TYPE><OFFSET_DIM>(0), <NOFFSET_TYPE><OFFSET_DIM>(0), <LOD>"); 566 f.allowedTargets.insert(GL_TEXTURE_1D); 567 f.allowedTargets.insert(GL_TEXTURE_1D_ARRAY); 568 f.allowedTargets.insert(GL_TEXTURE_2D); 569 f.allowedTargets.insert(GL_TEXTURE_2D_ARRAY); 570 f.allowedTargets.insert(GL_TEXTURE_CUBE_MAP); 571 f.allowedTargets.insert(GL_TEXTURE_CUBE_MAP_ARRAY); 572 f.allowedTargets.insert(GL_TEXTURE_3D); 573 mFunctions.push_back(f); 574 575 f = FunctionToken( 576 "sparseTextureGradOffsetClampARB", 577 ", <NOFFSET_TYPE><OFFSET_DIM>(0), <NOFFSET_TYPE><OFFSET_DIM>(0), <OFFSET_TYPE><OFFSET_DIM>(0), <LOD>"); 578 f.allowedTargets.insert(GL_TEXTURE_2D); 579 f.allowedTargets.insert(GL_TEXTURE_2D_ARRAY); 580 f.allowedTargets.insert(GL_TEXTURE_3D); 581 mFunctions.push_back(f); 582 583 f = FunctionToken( 584 "textureGradOffsetClampARB", 585 ", <NOFFSET_TYPE><OFFSET_DIM>(0), <NOFFSET_TYPE><OFFSET_DIM>(0), <OFFSET_TYPE><OFFSET_DIM>(0), <LOD>"); 586 f.allowedTargets.insert(GL_TEXTURE_1D); 587 f.allowedTargets.insert(GL_TEXTURE_1D_ARRAY); 588 f.allowedTargets.insert(GL_TEXTURE_2D); 589 f.allowedTargets.insert(GL_TEXTURE_2D_ARRAY); 590 f.allowedTargets.insert(GL_TEXTURE_3D); 591 mFunctions.push_back(f); 592} 593 594/** Executes test iteration. 595 * 596 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 597 */ 598tcu::TestNode::IterateResult SparseTextureClampLookupColorTestCase::iterate() 599{ 600 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_sparse_texture_clamp")) 601 { 602 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); 603 return STOP; 604 } 605 606 const Functions& gl = m_context.getRenderContext().getFunctions(); 607 608 bool result = true; 609 610 GLuint texture; 611 612 for (std::vector<glw::GLint>::const_iterator iter = mSupportedTargets.begin(); iter != mSupportedTargets.end(); 613 ++iter) 614 { 615 const GLint& target = *iter; 616 617 for (std::vector<glw::GLint>::const_iterator formIter = mSupportedInternalFormats.begin(); 618 formIter != mSupportedInternalFormats.end(); ++formIter) 619 { 620 const GLint& format = *formIter; 621 622 if (!caseAllowed(target, format)) 623 continue; 624 625 for (std::vector<FunctionToken>::const_iterator tokIter = mFunctions.begin(); tokIter != mFunctions.end(); 626 ++tokIter) 627 { 628 // Check if target is allowed for current lookup function 629 FunctionToken funcToken = *tokIter; 630 if (!funcAllowed(target, format, funcToken)) 631 continue; 632 633 bool isSparse = false; 634 if (funcToken.name.find("sparse", 0) != std::string::npos) 635 isSparse = true; 636 637 mLog.str(""); 638 mLog << "Testing sparse texture lookup color functions for target: " << target << ", format: " << format 639 << " - "; 640 641 if (isSparse) 642 sparseAllocateTexture(gl, target, format, texture, 3); 643 else 644 allocateTexture(gl, target, format, texture, 3); 645 646 if (format == GL_DEPTH_COMPONENT16) 647 setupDepthMode(gl, target, texture); 648 649 int l; 650 int maxLevels = 0; 651 for (l = 0; l < mState.levels; ++l) 652 { 653 if (!isSparse || commitTexturePage(gl, target, format, texture, l)) 654 { 655 writeDataToTexture(gl, target, format, texture, l); 656 maxLevels = l; 657 } 658 } 659 660 for (l = 0; l <= maxLevels; ++l) 661 { 662 result = result && verifyLookupTextureData(gl, target, format, texture, l, funcToken); 663 664 if (!result) 665 break; 666 } 667 668 Texture::Delete(gl, texture); 669 670 if (!result) 671 { 672 m_testCtx.getLog() << tcu::TestLog::Message << mLog.str() << "Fail" << tcu::TestLog::EndMessage; 673 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 674 return STOP; 675 } 676 } 677 } 678 } 679 680 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 681 return STOP; 682} 683 684/** Writing data to generated texture using compute shader 685 * 686 * @param gl GL API functions 687 * @param target Target for which texture is binded 688 * @param format Texture internal format 689 * @param texture Texture object 690 * 691 * @return Returns true if no error occurred, otherwise throws an exception. 692 */ 693bool SparseTextureClampLookupColorTestCase::writeDataToTexture(const Functions& gl, GLint target, GLint format, 694 GLuint& texture, GLint level) 695{ 696 mLog << "Fill Texture with shader [level: " << level << "] - "; 697 698 if (level > mState.levels - 1) 699 TCU_FAIL("Invalid level"); 700 701 GLint width; 702 GLint height; 703 GLint depth; 704 SparseTextureUtils::getTextureLevelSize(target, mState, level, width, height, depth); 705 706 if (width > 0 && height > 0 && depth >= mState.minDepth) 707 { 708 if (target == GL_TEXTURE_CUBE_MAP) 709 depth = depth * 6; 710 711 GLint texSize = width * height * depth * mState.format.getPixelSize(); 712 713 std::vector<GLubyte> vecData; 714 vecData.resize(texSize); 715 GLubyte* data = vecData.data(); 716 717 deMemset(data, 255, texSize); 718 719 for (GLint sample = 0; sample < mState.samples; ++sample) 720 { 721 std::string shader = stc_compute_textureFill; 722 723 // Adjust shader source to texture format 724 TokenStrings s = createShaderTokens(target, format, sample); 725 726 GLint convFormat = format; 727 if (format == GL_DEPTH_COMPONENT16) 728 convFormat = GL_R16; 729 730 // Change expected result as it has to be adjusted to different levels 731 s.resultExpected = generateExpectedResult(s.returnType, level, convFormat); 732 733 replaceToken("<INPUT_TYPE>", s.inputType.c_str(), shader); 734 replaceToken("<POINT_TYPE>", s.pointType.c_str(), shader); 735 replaceToken("<POINT_DEF>", s.pointDef.c_str(), shader); 736 replaceToken("<RETURN_TYPE>", s.returnType.c_str(), shader); 737 replaceToken("<RESULT_EXPECTED>", s.resultExpected.c_str(), shader); 738 replaceToken("<SAMPLE_DEF>", s.sampleDef.c_str(), shader); 739 740 ProgramSources sources; 741 sources << ComputeSource(shader); 742 743 // Build and run shader 744 ShaderProgram program(m_context.getRenderContext(), sources); 745 if (program.isOk()) 746 { 747 gl.useProgram(program.getProgram()); 748 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram"); 749 gl.bindImageTexture(0 /* unit */, texture, level /* level */, GL_FALSE /* layered */, 0 /* layer */, 750 GL_WRITE_ONLY, convFormat); 751 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture"); 752 gl.uniform1i(1, 0 /* image_unit */); 753 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i"); 754 gl.dispatchCompute(width, height, depth); 755 GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute"); 756 gl.memoryBarrier(GL_ALL_BARRIER_BITS); 757 GLU_EXPECT_NO_ERROR(gl.getError(), "glMemoryBarrier"); 758 } 759 else 760 { 761 mLog << "Compute shader compilation failed (writing) for target: " << target << ", format: " << format 762 << ", sample: " << sample << ", infoLog: " << program.getShaderInfo(SHADERTYPE_COMPUTE).infoLog 763 << ", shaderSource: " << shader.c_str() << " - "; 764 } 765 } 766 } 767 768 return true; 769} 770 771/** Verify if data stored in texture is as expected 772 * 773 * @param gl GL API functions 774 * @param target Target for which texture is binded 775 * @param format Texture internal format 776 * @param texture Texture object 777 * @param level Texture mipmap level 778 * @param funcToken Lookup function tokenize structure 779 * 780 * @return Returns true if data is as expected, false if not, throws an exception if error occurred. 781 */ 782bool SparseTextureClampLookupColorTestCase::verifyLookupTextureData(const Functions& gl, GLint target, GLint format, 783 GLuint& texture, GLint level, 784 FunctionToken& funcToken) 785{ 786 mLog << "Verify Lookup Color Texture Data [function: " << funcToken.name << ", level: " << level << "] - "; 787 788 if (level > mState.levels - 1) 789 TCU_FAIL("Invalid level"); 790 791 GLint width; 792 GLint height; 793 GLint depth; 794 SparseTextureUtils::getTextureLevelSize(target, mState, level, width, height, depth); 795 796 if (width == 0 || height == 0 || depth < mState.minDepth) 797 return true; 798 799 bool result = true; 800 801 if (target == GL_TEXTURE_CUBE_MAP) 802 depth = depth * 6; 803 804 GLint texSize = width * height; 805 806 std::vector<GLubyte> vecExpData; 807 std::vector<GLubyte> vecOutData; 808 vecExpData.resize(texSize); 809 vecOutData.resize(texSize); 810 GLubyte* exp_data = vecExpData.data(); 811 GLubyte* out_data = vecOutData.data(); 812 813 // Expected data is 255 because 814 deMemset(exp_data, 255, texSize); 815 816 // Create verifying texture 817 GLint verifyTarget = GL_TEXTURE_2D; 818 GLuint verifyTexture; 819 Texture::Generate(gl, verifyTexture); 820 Texture::Bind(gl, verifyTexture, verifyTarget); 821 Texture::Storage(gl, verifyTarget, 1, GL_R8, width, height, depth); 822 GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::Storage"); 823 824 GLuint fbo; 825 gl.genFramebuffers(1, &fbo); 826 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers"); 827 gl.bindFramebuffer(GL_FRAMEBUFFER, fbo); 828 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer"); 829 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, verifyTarget, verifyTexture, 0); 830 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D"); 831 832 gl.viewport(0, 0, width, height); 833 834 for (GLint z = 0; z < depth; ++z) 835 { 836 for (int sample = 0; sample < mState.samples; ++sample) 837 { 838 deMemset(out_data, 0, texSize); 839 840 Texture::Bind(gl, verifyTexture, verifyTarget); 841 Texture::SubImage(gl, verifyTarget, 0, 0, 0, 0, width, height, 0, GL_RED, GL_UNSIGNED_BYTE, 842 (GLvoid*)out_data); 843 GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::SubImage"); 844 845 std::string vertex = stc_vertex_common; 846 std::string fragment = stc_fragment_lookupColor; 847 848 // Make token copy to work on 849 FunctionToken f = funcToken; 850 851 std::string functionDef = generateFunctionDef(f.name); 852 853 // Adjust shader source to texture format 854 TokenStringsExt s = createLookupShaderTokens(target, format, level, sample, f); 855 856 // Change expected result as it has to be adjusted to different levels 857 s.resultExpected = generateExpectedResult(s.returnType, level, format); 858 859 replaceToken("<COORD_TYPE>", s.coordType.c_str(), vertex); 860 861 replaceToken("<FUNCTION_DEF>", functionDef.c_str(), fragment); 862 replaceToken("<FUNCTION>", f.name.c_str(), fragment); 863 replaceToken("<ARGUMENTS>", f.arguments.c_str(), fragment); 864 865 replaceToken("<OUTPUT_TYPE>", s.outputType.c_str(), fragment); 866 replaceToken("<INPUT_TYPE>", s.inputType.c_str(), fragment); 867 replaceToken("<SIZE_DEF>", s.sizeDef.c_str(), fragment); 868 replaceToken("<LOD>", s.lod.c_str(), fragment); 869 replaceToken("<LOD_DEF>", s.lodDef.c_str(), fragment); 870 replaceToken("<COORD_TYPE>", s.coordType.c_str(), fragment); 871 replaceToken("<ICOORD_TYPE>", s.coordType.c_str(), fragment); 872 replaceToken("<COORD_DEF>", s.coordDef.c_str(), fragment); 873 replaceToken("<POINT_TYPE>", s.pointType.c_str(), fragment); 874 replaceToken("<POINT_DEF>", s.pointDef.c_str(), fragment); 875 replaceToken("<RETURN_TYPE>", s.returnType.c_str(), fragment); 876 replaceToken("<RESULT_EXPECTED>", s.resultExpected.c_str(), fragment); 877 replaceToken("<EPSILON>", s.epsilon.c_str(), fragment); 878 replaceToken("<SAMPLE_DEF>", s.sampleDef.c_str(), fragment); 879 replaceToken("<REFZ_DEF>", s.refZDef.c_str(), fragment); 880 replaceToken("<CUBE_REFZ_DEF>", s.cubeMapArrayRefZDef.c_str(), fragment); 881 replaceToken("<POINT_COORD>", s.pointCoord.c_str(), fragment); 882 replaceToken("<COMPONENT_DEF>", s.componentDef.c_str(), fragment); 883 replaceToken("<CUBE_MAP_COORD_DEF>", s.cubeMapCoordDef.c_str(), fragment); 884 replaceToken("<OFFSET_ARRAY_DEF>", s.offsetArrayDef.c_str(), fragment); 885 replaceToken("<FORMAT_DEF>", s.formatDef.c_str(), fragment); 886 replaceToken("<OFFSET_TYPE>", s.offsetType.c_str(), fragment); 887 replaceToken("<NOFFSET_TYPE>", s.nOffsetType.c_str(), fragment); 888 replaceToken("<OFFSET_DIM>", s.offsetDim.c_str(), fragment); 889 890 replaceToken("<TEX_WIDTH>", de::toString(width).c_str(), fragment); 891 replaceToken("<TEX_HEIGHT>", de::toString(height).c_str(), fragment); 892 replaceToken("<TEX_DEPTH>", de::toString(depth).c_str(), fragment); 893 894 ProgramSources sources = makeVtxFragSources(vertex.c_str(), fragment.c_str()); 895 896 // Build and run shader 897 ShaderProgram program(m_context.getRenderContext(), sources); 898 if (program.isOk()) 899 { 900 gl.useProgram(program.getProgram()); 901 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram"); 902 903 // Pass input sampler/image to shader 904 gl.activeTexture(GL_TEXTURE0); 905 GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture"); 906 gl.uniform1i(1, 0 /* sampler_unit */); 907 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i"); 908 909 gl.bindTexture(target, texture); 910 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture"); 911 912 gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 913 draw(target, z, program); 914 915 Texture::Bind(gl, verifyTexture, verifyTarget); 916 Texture::GetData(gl, 0, verifyTarget, GL_RED, GL_UNSIGNED_BYTE, (GLvoid*)out_data); 917 GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::GetData"); 918 919 //Verify only committed region 920 for (GLint y = 0; y < height; ++y) 921 for (GLint x = 0; x < width; ++x) 922 { 923 GLubyte* dataRegion = exp_data + x + y * width; 924 GLubyte* outDataRegion = out_data + x + y * width; 925 if (dataRegion[0] != outDataRegion[0]) 926 result = false; 927 } 928 } 929 else 930 { 931 mLog << "Shader compilation failed (lookup color) for target: " << target << ", format: " << format 932 << ", vertexInfoLog: " << program.getShaderInfo(SHADERTYPE_VERTEX).infoLog 933 << ", fragmentInfoLog: " << program.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog 934 << ", programInfoLog: " << program.getProgramInfo().infoLog 935 << ", fragmentSource: " << fragment.c_str() << " - "; 936 937 result = false; 938 } 939 } 940 } 941 942 gl.bindFramebuffer(GL_FRAMEBUFFER, 0); 943 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer"); 944 945 Texture::Delete(gl, verifyTexture); 946 947 return result; 948} 949 950/** Preparing texture. Function overridden to increase textures size. 951 * 952 * @param gl GL API functions 953 * @param target Target for which texture is binded 954 * @param format Texture internal format 955 * @param texture Texture object 956 * 957 * @return Returns true if no error occurred, otherwise throws an exception. 958 */ 959bool SparseTextureClampLookupColorTestCase::prepareTexture(const Functions& gl, GLint target, GLint format, 960 GLuint& texture) 961{ 962 Texture::Generate(gl, texture); 963 Texture::Bind(gl, texture, target); 964 965 mState.minDepth = SparseTextureUtils::getTargetDepth(target); 966 SparseTextureUtils::getTexturePageSizes(gl, target, format, mState.pageSizeX, mState.pageSizeY, mState.pageSizeZ); 967 968 //The <width> and <height> has to be equal for cube map textures 969 if (target == GL_TEXTURE_CUBE_MAP || target == GL_TEXTURE_CUBE_MAP_ARRAY) 970 { 971 if (mState.pageSizeX > mState.pageSizeY) 972 mState.pageSizeY = mState.pageSizeX; 973 else if (mState.pageSizeX < mState.pageSizeY) 974 mState.pageSizeX = mState.pageSizeY; 975 } 976 977 mState.width = 4 * mState.pageSizeX; 978 mState.height = 4 * mState.pageSizeY; 979 mState.depth = 4 * mState.pageSizeZ * mState.minDepth; 980 981 mState.format = glu::mapGLInternalFormat(format); 982 983 return true; 984} 985 986/** Commit texture page using texPageCommitment function. Function overridden to commit whole texture region. 987 * 988 * @param gl GL API functions 989 * @param target Target for which texture is binded 990 * @param format Texture internal format 991 * @param texture Texture object 992 * @param level Texture mipmap level 993 * 994 * @return Returns true if commitment is done properly, false if commitment is not allowed or throws exception if error occurred. 995 */ 996bool SparseTextureClampLookupColorTestCase::commitTexturePage(const Functions& gl, GLint target, GLint format, 997 GLuint& texture, GLint level) 998{ 999 mLog << "Commit Region [level: " << level << "] - "; 1000 1001 if (level > mState.levels - 1) 1002 TCU_FAIL("Invalid level"); 1003 1004 // Avoid not allowed commitments 1005 if (!isInPageSizesRange(target, level) || !isPageSizesMultiplication(target, level)) 1006 { 1007 mLog << "Skip commitment [level: " << level << "] - "; 1008 return false; 1009 } 1010 1011 GLint width; 1012 GLint height; 1013 GLint depth; 1014 SparseTextureUtils::getTextureLevelSize(target, mState, level, width, height, depth); 1015 1016 if (target == GL_TEXTURE_CUBE_MAP) 1017 depth = 6 * depth; 1018 1019 Texture::Bind(gl, texture, target); 1020 texPageCommitment(gl, target, format, texture, level, 0, 0, 0, width, height, depth, GL_TRUE); 1021 GLU_EXPECT_NO_ERROR(gl.getError(), "texPageCommitment"); 1022 1023 return true; 1024} 1025 1026/** Check if current texture size for level is greater or equal page size in a corresponding direction 1027 * 1028 * @param target Target for which texture is binded 1029 * @param level Texture mipmap level 1030 * 1031 * @return Returns true if the texture size condition is fulfilled, false otherwise. 1032 */ 1033bool SparseTextureClampLookupColorTestCase::isInPageSizesRange(GLint target, GLint level) 1034{ 1035 GLint width; 1036 GLint height; 1037 GLint depth; 1038 SparseTextureUtils::getTextureLevelSize(target, mState, level, width, height, depth); 1039 1040 if (target == GL_TEXTURE_CUBE_MAP) 1041 depth = 6 * depth; 1042 1043 if (width >= mState.pageSizeX && height >= mState.pageSizeY && (mState.minDepth == 0 || depth >= mState.pageSizeZ)) 1044 { 1045 return true; 1046 } 1047 1048 return false; 1049} 1050 1051/** Check if current texture size for level is page size multiplication in a corresponding direction 1052 * 1053 * @param target Target for which texture is binded 1054 * @param level Texture mipmap level 1055 * 1056 * @return Returns true if the texture size condition is fulfilled, false otherwise. 1057 */ 1058bool SparseTextureClampLookupColorTestCase::isPageSizesMultiplication(GLint target, GLint level) 1059{ 1060 GLint width; 1061 GLint height; 1062 GLint depth; 1063 SparseTextureUtils::getTextureLevelSize(target, mState, level, width, height, depth); 1064 1065 if (target == GL_TEXTURE_CUBE_MAP) 1066 depth = 6 * depth; 1067 1068 if ((width % mState.pageSizeX) == 0 && (height % mState.pageSizeY) == 0 && (depth % mState.pageSizeZ) == 0) 1069 { 1070 return true; 1071 } 1072 1073 return false; 1074} 1075 1076/** Constructor. 1077 * 1078 * @param funcName Tested function name. 1079 * 1080 * @return Returns shader source code part that uses lookup function to fetch texel from texture. 1081 */ 1082std::string SparseTextureClampLookupColorTestCase::generateFunctionDef(std::string funcName) 1083{ 1084 if (funcName.find("sparse", 0) != std::string::npos) 1085 { 1086 return std::string(" <FUNCTION>(uni_in,\n" 1087 " <POINT_COORD><SAMPLE_DEF><ARGUMENTS>,\n" 1088 " retValue<COMPONENT_DEF>);\n"); 1089 } 1090 else 1091 { 1092 return std::string(" retValue<COMPONENT_DEF> = <FUNCTION>(uni_in,\n" 1093 " <POINT_COORD><SAMPLE_DEF><ARGUMENTS>);\n"); 1094 } 1095} 1096 1097/** Constructor. 1098 * 1099 * @param returnType Expected result variable type. 1100 * 1101 * @return Returns shader source token that represent expected lookup result value. 1102 */ 1103std::string SparseTextureClampLookupColorTestCase::generateExpectedResult(std::string returnType, GLint level, 1104 GLint format) 1105{ 1106 if (format == GL_DEPTH_COMPONENT16) 1107 return std::string("(1, 0, 0, 0)"); 1108 else if (returnType == "vec4") 1109 return std::string("(") + de::toString(0.5f + (float)level / 10) + std::string(", 0, 0, 1)"); 1110 else 1111 return std::string("(") + de::toString(level * 10) + std::string(", 0, 0, 1)"); 1112} 1113 1114/** Constructor. 1115 * 1116 * @param context Rendering context. 1117 */ 1118SparseTextureClampTests::SparseTextureClampTests(deqp::Context& context) 1119 : TestCaseGroup(context, "sparse_texture_clamp_tests", 1120 "Verify conformance of CTS_ARB_sparse_texture_clamp implementation") 1121{ 1122} 1123 1124/** Initializes the test group contents. */ 1125void SparseTextureClampTests::init() 1126{ 1127 addChild(new ShaderExtensionTestCase(m_context, "GL_ARB_sparse_texture_clamp")); 1128 addChild(new SparseTextureClampLookupResidencyTestCase(m_context)); 1129 addChild(new SparseTextureClampLookupColorTestCase(m_context)); 1130} 1131 1132} /* gl4cts namespace */ 1133