1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.0 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 Texture unit usage tests. 22 * 23 * \todo [2012-07-12 nuutti] Come up with a good way to make these tests faster. 24 *//*--------------------------------------------------------------------*/ 25 26 #include "es3fTextureUnitTests.hpp" 27 #include "glsTextureTestUtil.hpp" 28 #include "gluTextureUtil.hpp" 29 #include "gluContextInfo.hpp" 30 #include "gluTextureUtil.hpp" 31 #include "tcuTextureUtil.hpp" 32 #include "tcuImageCompare.hpp" 33 #include "tcuMatrix.hpp" 34 #include "tcuRenderTarget.hpp" 35 #include "sglrContextUtil.hpp" 36 #include "sglrReferenceContext.hpp" 37 #include "sglrGLContext.hpp" 38 #include "deRandom.hpp" 39 #include "deStringUtil.hpp" 40 41 #include "glwEnums.hpp" 42 #include "glwFunctions.hpp" 43 44 using tcu::Vec2; 45 using tcu::Vec3; 46 using tcu::Vec4; 47 using tcu::IVec2; 48 using tcu::IVec3; 49 using tcu::Mat3; 50 using tcu::Mat4; 51 using std::vector; 52 using std::string; 53 using namespace glw; // GL types 54 55 namespace deqp 56 { 57 58 using namespace gls::TextureTestUtil; 59 60 namespace gles3 61 { 62 namespace Functional 63 { 64 65 static const int VIEWPORT_WIDTH = 128; 66 static const int VIEWPORT_HEIGHT = 128; 67 68 static const int TEXTURE_WIDTH_2D = 128; 69 static const int TEXTURE_HEIGHT_2D = 128; 70 71 // \note Cube map texture size is larger in order to make minifications possible - otherwise would need to display different faces at same time. 72 static const int TEXTURE_WIDTH_CUBE = 256; 73 static const int TEXTURE_HEIGHT_CUBE = 256; 74 75 static const int TEXTURE_WIDTH_2D_ARRAY = 64; 76 static const int TEXTURE_HEIGHT_2D_ARRAY = 64; 77 static const int TEXTURE_LAYERS_2D_ARRAY = 4; 78 79 static const int TEXTURE_WIDTH_3D = 32; 80 static const int TEXTURE_HEIGHT_3D = 32; 81 static const int TEXTURE_DEPTH_3D = 32; 82 83 static const int GRID_CELL_SIZE = 8; 84 85 static const GLenum s_testSizedInternalFormats[] = 86 { 87 GL_RGBA32F, 88 GL_RGBA32I, 89 GL_RGBA32UI, 90 GL_RGBA16F, 91 GL_RGBA16I, 92 GL_RGBA16UI, 93 GL_RGBA8, 94 GL_RGBA8I, 95 GL_RGBA8UI, 96 GL_SRGB8_ALPHA8, 97 GL_RGB10_A2, 98 GL_RGB10_A2UI, 99 GL_RGBA4, 100 GL_RGB5_A1, 101 GL_RGBA8_SNORM, 102 GL_RGB8, 103 GL_RGB565, 104 GL_R11F_G11F_B10F, 105 GL_RGB32F, 106 GL_RGB32I, 107 GL_RGB32UI, 108 GL_RGB16F, 109 GL_RGB16I, 110 GL_RGB16UI, 111 GL_RGB8_SNORM, 112 GL_RGB8I, 113 GL_RGB8UI, 114 GL_SRGB8, 115 GL_RGB9_E5, 116 GL_RG32F, 117 GL_RG32I, 118 GL_RG32UI, 119 GL_RG16F, 120 GL_RG16I, 121 GL_RG16UI, 122 GL_RG8, 123 GL_RG8I, 124 GL_RG8UI, 125 GL_RG8_SNORM, 126 GL_R32F, 127 GL_R32I, 128 GL_R32UI, 129 GL_R16F, 130 GL_R16I, 131 GL_R16UI, 132 GL_R8, 133 GL_R8I, 134 GL_R8UI, 135 GL_R8_SNORM 136 }; 137 138 static const GLenum s_testWrapModes[] = 139 { 140 GL_CLAMP_TO_EDGE, 141 GL_REPEAT, 142 GL_MIRRORED_REPEAT, 143 }; 144 145 static const GLenum s_testMinFilters[] = 146 { 147 GL_NEAREST, 148 GL_LINEAR, 149 GL_NEAREST_MIPMAP_NEAREST, 150 GL_LINEAR_MIPMAP_NEAREST, 151 GL_NEAREST_MIPMAP_LINEAR, 152 GL_LINEAR_MIPMAP_LINEAR 153 }; 154 155 static const GLenum s_testNonMipmapMinFilters[] = 156 { 157 GL_NEAREST, 158 GL_LINEAR 159 }; 160 161 static const GLenum s_testNearestMinFilters[] = 162 { 163 GL_NEAREST, 164 GL_NEAREST_MIPMAP_NEAREST 165 }; 166 167 static const GLenum s_testMagFilters[] = 168 { 169 GL_NEAREST, 170 GL_LINEAR 171 }; 172 173 static const GLenum s_cubeFaceTargets[] = 174 { 175 GL_TEXTURE_CUBE_MAP_POSITIVE_X, 176 GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 177 GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 178 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 179 GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 180 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 181 }; 182 183 // Extend a 3x3 transformation matrix to an equivalent 4x4 transformation matrix (i.e. 1.0 in right-down cell, 0.0's in other new cells). 184 static Mat4 matExtend3To4 (const Mat3& mat) 185 { 186 Mat4 res; 187 for (int rowNdx = 0; rowNdx < 3; rowNdx++) 188 { 189 Vec3 row = mat.getRow(rowNdx); 190 res.setRow(rowNdx, Vec4(row.x(), row.y(), row.z(), 0.0f)); 191 } 192 res.setRow(3, Vec4(0.0f, 0.0f, 0.0f, 1.0f)); 193 194 return res; 195 } 196 197 static string generateMultiTexFragmentShader (int numUnits, const vector<GLenum>& unitTypes, const vector<glu::DataType>& samplerTypes) 198 { 199 // The fragment shader calculates the average of a set of textures. 200 201 string samplersStr; 202 string matricesStr; 203 string scalesStr; 204 string biasesStr; 205 string lookupsStr; 206 207 string colorMultiplier = "(1.0/" + de::toString(numUnits) + ".0)"; 208 209 for (int ndx = 0; ndx < numUnits; ndx++) 210 { 211 string ndxStr = de::toString(ndx); 212 string samplerName = "u_sampler" + ndxStr; 213 string transformationName = "u_trans" + ndxStr; 214 string scaleName = "u_texScale" + ndxStr; 215 string biasName = "u_texBias" + ndxStr; 216 217 samplersStr += string("") + "uniform highp " + glu::getDataTypeName(samplerTypes[ndx]) + " " + samplerName + ";\n"; 218 matricesStr += "uniform highp mat4 " + transformationName + ";\n"; 219 scalesStr += "uniform highp vec4 " + scaleName + ";\n"; 220 biasesStr += "uniform highp vec4 " + biasName + ";\n"; 221 222 string lookupCoord = transformationName + "*vec4(v_coord, 1.0, 1.0)"; 223 224 if (unitTypes[ndx] == GL_TEXTURE_2D) 225 lookupCoord = "vec2(" + lookupCoord + ")"; 226 else 227 lookupCoord = "vec3(" + lookupCoord + ")"; 228 229 lookupsStr += "\tcolor += " + colorMultiplier + "*(vec4(texture(" + samplerName + ", " + lookupCoord + "))*" + scaleName + " + " + biasName + ");\n"; 230 } 231 232 return "#version 300 es\n" 233 "layout(location = 0) out mediump vec4 o_color;\n" + 234 samplersStr + 235 matricesStr + 236 scalesStr + 237 biasesStr + 238 "in highp vec2 v_coord;\n" 239 "\n" 240 "void main (void)\n" 241 "{\n" 242 " mediump vec4 color = vec4(0.0);\n" + 243 lookupsStr + 244 " o_color = color;\n" 245 "}\n"; 246 } 247 248 static sglr::pdec::ShaderProgramDeclaration generateShaderProgramDeclaration (int numUnits, const vector<GLenum>& unitTypes, const vector<glu::DataType>& samplerTypes) 249 { 250 sglr::pdec::ShaderProgramDeclaration decl; 251 252 decl << sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT); 253 decl << sglr::pdec::VertexAttribute("a_coord", rr::GENERICVECTYPE_FLOAT); 254 decl << sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT); 255 decl << sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT); 256 257 for (int ndx = 0; ndx < numUnits; ++ndx) 258 { 259 string samplerName = "u_sampler" + de::toString(ndx); 260 string transformationName = "u_trans" + de::toString(ndx); 261 string scaleName = "u_texScale" + de::toString(ndx); 262 string biasName = "u_texBias" + de::toString(ndx); 263 264 decl << sglr::pdec::Uniform(samplerName, samplerTypes[ndx]); 265 decl << sglr::pdec::Uniform(transformationName, glu::TYPE_FLOAT_MAT4); 266 decl << sglr::pdec::Uniform(scaleName, glu::TYPE_FLOAT_VEC4); 267 decl << sglr::pdec::Uniform(biasName, glu::TYPE_FLOAT_VEC4); 268 } 269 270 decl << sglr::pdec::VertexSource("#version 300 es\n" 271 "in highp vec4 a_position;\n" 272 "in highp vec2 a_coord;\n" 273 "out highp vec2 v_coord;\n" 274 "\n" 275 "void main (void)\n" 276 "{\n" 277 " gl_Position = a_position;\n" 278 " v_coord = a_coord;\n" 279 "}\n"); 280 decl << sglr::pdec::FragmentSource(generateMultiTexFragmentShader(numUnits, unitTypes, samplerTypes)); 281 282 return decl; 283 } 284 285 // Calculates values that will be used in calculateLod(). 286 static tcu::Vector<tcu::Vec2, 3> calculateLodDerivateParts (const Mat4& transformation) 287 { 288 // Calculate transformed coordinates of three screen corners. 289 Vec3 trans00 = (transformation * Vec4(0.0f, 0.0f, 1.0f, 1.0f)).xyz(); 290 Vec3 trans01 = (transformation * Vec4(0.0f, 1.0f, 1.0f, 1.0f)).xyz(); 291 Vec3 trans10 = (transformation * Vec4(1.0f, 0.0f, 1.0f, 1.0f)).xyz(); 292 293 return tcu::Vector<tcu::Vec2, 3>(Vec2(trans10.x() - trans00.x(), trans01.x() - trans00.x()), 294 Vec2(trans10.y() - trans00.y(), trans01.y() - trans00.y()), 295 Vec2(trans10.z() - trans00.z(), trans01.z() - trans00.z())); 296 } 297 298 // Calculates the maximum allowed lod from derivates 299 static float calculateLodMax(const tcu::Vector<tcu::Vec2, 3>& derivateParts, const tcu::IVec3& textureSize, const Vec2& screenDerivate) 300 { 301 float dudx = derivateParts[0].x() * (float)textureSize.x() * screenDerivate.x(); 302 float dudy = derivateParts[0].y() * (float)textureSize.x() * screenDerivate.y(); 303 float dvdx = derivateParts[1].x() * (float)textureSize.y() * screenDerivate.x(); 304 float dvdy = derivateParts[1].y() * (float)textureSize.y() * screenDerivate.y(); 305 float dwdx = derivateParts[2].x() * (float)textureSize.z() * screenDerivate.x(); 306 float dwdy = derivateParts[2].y() * (float)textureSize.z() * screenDerivate.y(); 307 308 const float mu = de::max(de::abs(dudx), de::abs(dudy)); 309 const float mv = de::max(de::abs(dvdx), de::abs(dvdy)); 310 const float mw = de::max(de::abs(dwdx), de::abs(dwdy)); 311 return deFloatLog2(mu + mv + mw); 312 } 313 314 // Calculates the minimum allowed lod from derivates 315 static float calculateLodMin(const tcu::Vector<tcu::Vec2, 3>& derivateParts, const tcu::IVec3& textureSize, const Vec2& screenDerivate) 316 { 317 float dudx = derivateParts[0].x() * (float)textureSize.x() * screenDerivate.x(); 318 float dudy = derivateParts[0].y() * (float)textureSize.x() * screenDerivate.y(); 319 float dvdx = derivateParts[1].x() * (float)textureSize.y() * screenDerivate.x(); 320 float dvdy = derivateParts[1].y() * (float)textureSize.y() * screenDerivate.y(); 321 float dwdx = derivateParts[2].x() * (float)textureSize.z() * screenDerivate.x(); 322 float dwdy = derivateParts[2].y() * (float)textureSize.z() * screenDerivate.y(); 323 324 const float mu = de::max(de::abs(dudx), de::abs(dudy)); 325 const float mv = de::max(de::abs(dvdx), de::abs(dvdy)); 326 const float mw = de::max(de::abs(dwdx), de::abs(dwdy)); 327 return deFloatLog2(de::max(mu, de::max(mv, mw))); 328 } 329 330 class MultiTexShader : public sglr::ShaderProgram 331 { 332 public: 333 MultiTexShader (deUint32 randSeed, 334 int numUnits, 335 const vector<GLenum>& unitTypes, 336 const vector<glu::DataType>& samplerTypes, 337 const vector<Vec4>& texScales, 338 const vector<Vec4>& texBiases, 339 const vector<int>& num2dArrayLayers); // \note 2d array layer "coordinate" isn't normalized, so this is needed here. 340 341 void setUniforms (sglr::Context& context, deUint32 program) const; 342 void makeSafeLods (const vector<IVec3>& textureSizes, const IVec2& viewportSize); // Modifies texture coordinates so that LODs aren't too close to x.5 or 0.0 . 343 344 private: 345 void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const; 346 void shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const; 347 348 int m_numUnits; 349 vector<GLenum> m_unitTypes; // 2d, cube map, 2d array or 3d. 350 vector<Vec4> m_texScales; 351 vector<Vec4> m_texBiases; 352 vector<Mat4> m_transformations; 353 vector<tcu::Vector<tcu::Vec2, 3> > m_lodDerivateParts; // Parts of lod derivates; computed in init(), used in eval(). 354 }; 355 356 MultiTexShader::MultiTexShader (deUint32 randSeed, 357 int numUnits, 358 const vector<GLenum>& unitTypes, 359 const vector<glu::DataType>& samplerTypes, 360 const vector<Vec4>& texScales, 361 const vector<Vec4>& texBiases, 362 const vector<int>& num2dArrayLayers) 363 : sglr::ShaderProgram (generateShaderProgramDeclaration(numUnits, unitTypes, samplerTypes)) 364 , m_numUnits (numUnits) 365 , m_unitTypes (unitTypes) 366 , m_texScales (texScales) 367 , m_texBiases (texBiases) 368 { 369 // 2d-to-cube-face transformations. 370 // \note 2d coordinates range from 0 to 1 and cube face coordinates from -1 to 1, so scaling is done as well. 371 static const float s_cubeTransforms[][3*3] = 372 { 373 // Face -X: (x, y, 1) -> (-1, -(2*y-1), +(2*x-1)) 374 { 0.0f, 0.0f, -1.0f, 375 0.0f, -2.0f, 1.0f, 376 2.0f, 0.0f, -1.0f }, 377 // Face +X: (x, y, 1) -> (+1, -(2*y-1), -(2*x-1)) 378 { 0.0f, 0.0f, 1.0f, 379 0.0f, -2.0f, 1.0f, 380 -2.0f, 0.0f, 1.0f }, 381 // Face -Y: (x, y, 1) -> (+(2*x-1), -1, -(2*y-1)) 382 { 2.0f, 0.0f, -1.0f, 383 0.0f, 0.0f, -1.0f, 384 0.0f, -2.0f, 1.0f }, 385 // Face +Y: (x, y, 1) -> (+(2*x-1), +1, +(2*y-1)) 386 { 2.0f, 0.0f, -1.0f, 387 0.0f, 0.0f, 1.0f, 388 0.0f, 2.0f, -1.0f }, 389 // Face -Z: (x, y, 1) -> (-(2*x-1), -(2*y-1), -1) 390 { -2.0f, 0.0f, 1.0f, 391 0.0f, -2.0f, 1.0f, 392 0.0f, 0.0f, -1.0f }, 393 // Face +Z: (x, y, 1) -> (+(2*x-1), -(2*y-1), +1) 394 { 2.0f, 0.0f, -1.0f, 395 0.0f, -2.0f, 1.0f, 396 0.0f, 0.0f, 1.0f } 397 }; 398 399 // Generate transformation matrices. 400 401 de::Random rnd(randSeed); 402 403 m_transformations.reserve(m_numUnits); 404 m_lodDerivateParts.reserve(m_numUnits); 405 406 int tex2dArrayNdx = 0; // Keep track of 2d texture array index. 407 408 DE_ASSERT((int)m_unitTypes.size() == m_numUnits); 409 410 for (int unitNdx = 0; unitNdx < m_numUnits; unitNdx++) 411 { 412 if (m_unitTypes[unitNdx] == GL_TEXTURE_2D) 413 { 414 float rotAngle = rnd.getFloat(0.0f, 2.0f*DE_PI); 415 float xScaleFactor = rnd.getFloat(0.7f, 1.5f); 416 float yScaleFactor = rnd.getFloat(0.7f, 1.5f); 417 float xShearAmount = rnd.getFloat(0.0f, 0.5f); 418 float yShearAmount = rnd.getFloat(0.0f, 0.5f); 419 float xTranslationAmount = rnd.getFloat(-0.5f, 0.5f); 420 float yTranslationAmount = rnd.getFloat(-0.5f, 0.5f); 421 422 static const float tempOffsetData[3*3] = // For temporarily centering the coordinates to get nicer transformations. 423 { 424 1.0f, 0.0f, -0.5f, 425 0.0f, 1.0f, -0.5f, 426 0.0f, 0.0f, 1.0f 427 }; 428 float rotTransfData[3*3] = 429 { 430 deFloatCos(rotAngle), -deFloatSin(rotAngle), 0.0f, 431 deFloatSin(rotAngle), deFloatCos(rotAngle), 0.0f, 432 0.0f, 0.0f, 1.0f 433 }; 434 float scaleTransfData[3*3] = 435 { 436 xScaleFactor, 0.0f, 0.0f, 437 0.0f, yScaleFactor, 0.0f, 438 0.0f, 0.0f, 1.0f 439 }; 440 float xShearTransfData[3*3] = 441 { 442 1.0f, xShearAmount, 0.0f, 443 0.0f, 1.0f, 0.0f, 444 0.0f, 0.0f, 1.0f 445 }; 446 float yShearTransfData[3*3] = 447 { 448 1.0f, 0.0f, 0.0f, 449 yShearAmount, 1.0f, 0.0f, 450 0.0f, 0.0f, 1.0f 451 }; 452 float translationTransfData[3*3] = 453 { 454 1.0f, 0.0f, xTranslationAmount, 455 0.0f, 1.0f, yTranslationAmount, 456 0.0f, 0.0f, 1.0f 457 }; 458 459 Mat4 transformation = matExtend3To4(Mat3(tempOffsetData) * 460 Mat3(translationTransfData) * 461 Mat3(rotTransfData) * 462 Mat3(scaleTransfData) * 463 Mat3(xShearTransfData) * 464 Mat3(yShearTransfData) * 465 (Mat3(tempOffsetData) * (-1.0f))); 466 467 m_lodDerivateParts.push_back(calculateLodDerivateParts(transformation)); 468 m_transformations.push_back(transformation); 469 } 470 else if (m_unitTypes[unitNdx] == GL_TEXTURE_CUBE_MAP) 471 { 472 DE_STATIC_ASSERT((int)tcu::CUBEFACE_LAST == DE_LENGTH_OF_ARRAY(s_cubeTransforms)); 473 474 float planarTransData[3*3]; 475 476 // In case of a cube map, we only want to render one face, so the transformation needs to be restricted - only enlarging scaling is done. 477 478 for (int i = 0; i < DE_LENGTH_OF_ARRAY(planarTransData); i++) 479 { 480 if (i == 0 || i == 4) 481 planarTransData[i] = rnd.getFloat(0.1f, 0.9f); // Two first diagonal cells control the scaling. 482 else if (i == 8) 483 planarTransData[i] = 1.0f; 484 else 485 planarTransData[i] = 0.0f; 486 } 487 488 int faceNdx = rnd.getInt(0, (int)tcu::CUBEFACE_LAST - 1); 489 Mat3 planarTrans (planarTransData); // Planar, face-agnostic transformation. 490 Mat4 finalTrans = matExtend3To4(Mat3(s_cubeTransforms[faceNdx]) * planarTrans); // Final transformation from planar to cube map coordinates, including the transformation just generated. 491 Mat4 planarTrans4x4 = matExtend3To4(planarTrans); 492 493 m_lodDerivateParts.push_back(calculateLodDerivateParts(planarTrans4x4)); 494 m_transformations.push_back(finalTrans); 495 } 496 else 497 { 498 DE_ASSERT(m_unitTypes[unitNdx] == GL_TEXTURE_3D || m_unitTypes[unitNdx] == GL_TEXTURE_2D_ARRAY); 499 500 float transData[4*4]; 501 502 for (int i = 0; i < 4*4; i++) 503 { 504 float sign = rnd.getBool() ? 1.0f : -1.0f; 505 transData[i] = rnd.getFloat(0.7f, 1.4f) * sign; 506 } 507 508 Mat4 transformation(transData); 509 510 if (m_unitTypes[unitNdx] == GL_TEXTURE_2D_ARRAY) 511 { 512 // Z direction: Translate by 0.5 and scale by layer amount. 513 514 float numLayers = (float)num2dArrayLayers[tex2dArrayNdx]; 515 516 static const float zTranslationTransfData[4*4] = 517 { 518 1.0f, 0.0f, 0.0f, 0.0f, 519 0.0f, 1.0f, 0.0f, 0.0f, 520 0.0f, 0.0f, 1.0f, 0.5f, 521 0.0f, 0.0f, 0.0f, 1.0f 522 }; 523 524 float zScaleTransfData[4*4] = 525 { 526 1.0f, 0.0f, 0.0f, 0.0f, 527 0.0f, 1.0f, 0.0f, 0.0f, 528 0.0f, 0.0f, numLayers, 0.0f, 529 0.0f, 0.0f, 0.0f, 1.0f 530 }; 531 532 transformation = transformation * Mat4(zScaleTransfData) * Mat4(zTranslationTransfData); 533 534 tex2dArrayNdx++; 535 } 536 537 m_lodDerivateParts.push_back(calculateLodDerivateParts(transformation)); 538 m_transformations.push_back(Mat4(transformation)); 539 } 540 } 541 } 542 543 void MultiTexShader::setUniforms (sglr::Context& ctx, deUint32 program) const 544 { 545 ctx.useProgram(program); 546 547 // Sampler and matrix uniforms. 548 549 for (int ndx = 0; ndx < m_numUnits; ndx++) 550 { 551 string ndxStr = de::toString(ndx); 552 553 ctx.uniform1i(ctx.getUniformLocation(program, ("u_sampler" + ndxStr).c_str()), ndx); 554 ctx.uniformMatrix4fv(ctx.getUniformLocation(program, ("u_trans" + ndxStr).c_str()), 1, GL_FALSE, (GLfloat*)&m_transformations[ndx].getColumnMajorData()[0]); 555 ctx.uniform4fv(ctx.getUniformLocation(program, ("u_texScale" + ndxStr).c_str()), 1, m_texScales[ndx].getPtr()); 556 ctx.uniform4fv(ctx.getUniformLocation(program, ("u_texBias" + ndxStr).c_str()), 1, m_texBiases[ndx].getPtr()); 557 } 558 } 559 560 void MultiTexShader::makeSafeLods (const vector<IVec3>& textureSizes, const IVec2& viewportSize) 561 { 562 DE_ASSERT((int)textureSizes.size() == m_numUnits); 563 564 static const float shrinkScaleMat2dData[3*3] = 565 { 566 0.95f, 0.0f, 0.0f, 567 0.0f, 0.95f, 0.0f, 568 0.0f, 0.0f, 1.0f 569 }; 570 static const float shrinkScaleMat3dData[3*3] = 571 { 572 0.95f, 0.0f, 0.0f, 573 0.0f, 0.95f, 0.0f, 574 0.0f, 0.0f, 0.95f 575 }; 576 Mat4 shrinkScaleMat2d = matExtend3To4(Mat3(shrinkScaleMat2dData)); 577 Mat4 shrinkScaleMat3d = matExtend3To4(Mat3(shrinkScaleMat3dData)); 578 579 Vec2 screenDerivate(1.0f / (float)viewportSize.x(), 1.0f / (float)viewportSize.y()); 580 581 for (int unitNdx = 0; unitNdx < m_numUnits; unitNdx++) 582 { 583 // As long as LOD is too close to 0.0 or is positive and too close to a something-and-a-half (0.5, 1.5, 2.5 etc) or allowed lod range could round to different levels, zoom in a little to get a safer LOD. 584 for (;;) 585 { 586 const float threshold = 0.1f; 587 const float epsilon = 0.01f; 588 589 const float lodMax = calculateLodMax(m_lodDerivateParts[unitNdx], textureSizes[unitNdx], screenDerivate); 590 const float lodMin = calculateLodMin(m_lodDerivateParts[unitNdx], textureSizes[unitNdx], screenDerivate); 591 592 const deInt32 maxLevel = (lodMax + epsilon < 0.5f) ? (0) : (deCeilFloatToInt32(lodMax + epsilon + 0.5f) - 1); 593 const deInt32 minLevel = (lodMin - epsilon < 0.5f) ? (0) : (deCeilFloatToInt32(lodMin - epsilon + 0.5f) - 1); 594 595 if (de::abs(lodMax) < threshold || (lodMax > 0.0f && de::abs(deFloatFrac(lodMax) - 0.5f) < threshold) || 596 de::abs(lodMin) < threshold || (lodMin > 0.0f && de::abs(deFloatFrac(lodMin) - 0.5f) < threshold) || 597 maxLevel != minLevel) 598 { 599 m_transformations[unitNdx] = (m_unitTypes[unitNdx] == GL_TEXTURE_3D ? shrinkScaleMat3d : shrinkScaleMat2d) * m_transformations[unitNdx]; 600 m_lodDerivateParts[unitNdx] = calculateLodDerivateParts(m_transformations[unitNdx]); 601 } 602 else 603 break; 604 } 605 } 606 } 607 608 void MultiTexShader::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const 609 { 610 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx) 611 { 612 rr::VertexPacket& packet = *(packets[packetNdx]); 613 614 packet.position = rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx); 615 packet.outputs[0] = rr::readVertexAttribFloat(inputs[1], packet.instanceNdx, packet.vertexNdx); 616 } 617 } 618 619 void MultiTexShader::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const 620 { 621 DE_ASSERT((int)m_unitTypes.size() == m_numUnits); 622 DE_ASSERT((int)m_transformations.size() == m_numUnits); 623 DE_ASSERT((int)m_lodDerivateParts.size() == m_numUnits); 624 625 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx) 626 { 627 rr::FragmentPacket& packet = packets[packetNdx]; 628 const float colorMultiplier = 1.0f / (float)m_numUnits; 629 Vec4 outColors[4] = { Vec4(0.0f), Vec4(0.0f), Vec4(0.0f), Vec4(0.0f) }; 630 631 for (int unitNdx = 0; unitNdx < m_numUnits; unitNdx++) 632 { 633 tcu::Vec4 texSamples[4]; 634 635 // Read tex coords 636 const tcu::Vec2 texCoords[4] = 637 { 638 rr::readTriangleVarying<float>(packet, context, 0, 0).xy(), 639 rr::readTriangleVarying<float>(packet, context, 0, 1).xy(), 640 rr::readTriangleVarying<float>(packet, context, 0, 2).xy(), 641 rr::readTriangleVarying<float>(packet, context, 0, 3).xy(), 642 }; 643 644 // Transform 645 tcu::Vec3 coords3D[4] = 646 { 647 (m_transformations[unitNdx] * Vec4(texCoords[0].x(), texCoords[0].y(), 1.0f, 1.0f)).xyz(), 648 (m_transformations[unitNdx] * Vec4(texCoords[1].x(), texCoords[1].y(), 1.0f, 1.0f)).xyz(), 649 (m_transformations[unitNdx] * Vec4(texCoords[2].x(), texCoords[2].y(), 1.0f, 1.0f)).xyz(), 650 (m_transformations[unitNdx] * Vec4(texCoords[3].x(), texCoords[3].y(), 1.0f, 1.0f)).xyz(), 651 }; 652 653 // To 2D 654 const tcu::Vec2 coords2D[4] = 655 { 656 coords3D[0].xy(), 657 coords3D[1].xy(), 658 coords3D[2].xy(), 659 coords3D[3].xy(), 660 }; 661 662 // Sample 663 switch (m_unitTypes[unitNdx]) 664 { 665 case GL_TEXTURE_2D: m_uniforms[4*unitNdx].sampler.tex2D->sample4(texSamples, coords2D); break; 666 case GL_TEXTURE_CUBE_MAP: m_uniforms[4*unitNdx].sampler.texCube->sample4(texSamples, coords3D); break; 667 case GL_TEXTURE_2D_ARRAY: m_uniforms[4*unitNdx].sampler.tex2DArray->sample4(texSamples, coords3D); break; 668 case GL_TEXTURE_3D: m_uniforms[4*unitNdx].sampler.tex3D->sample4(texSamples, coords3D); break; 669 default: 670 DE_ASSERT(DE_FALSE); 671 } 672 673 // Add to sum 674 for (int fragNdx = 0; fragNdx < 4; ++fragNdx) 675 outColors[fragNdx] += colorMultiplier * (texSamples[fragNdx]*m_texScales[unitNdx] + m_texBiases[unitNdx]); 676 } 677 678 // output 679 for (int fragNdx = 0; fragNdx < 4; ++fragNdx) 680 rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, outColors[fragNdx]); 681 } 682 } 683 684 class TextureUnitCase : public TestCase 685 { 686 public: 687 enum CaseType 688 { 689 CASE_ONLY_2D = 0, 690 CASE_ONLY_CUBE, 691 CASE_ONLY_2D_ARRAY, 692 CASE_ONLY_3D, 693 CASE_MIXED, 694 695 CASE_LAST 696 }; 697 TextureUnitCase (Context& context, const char* name, const char* desc, int numUnits /* \note If non-positive, use all units */, CaseType caseType, deUint32 randSeed); 698 ~TextureUnitCase (void); 699 700 void init (void); 701 void deinit (void); 702 IterateResult iterate (void); 703 704 private: 705 struct TextureParameters 706 { 707 GLenum internalFormat; 708 GLenum wrapModeS; 709 GLenum wrapModeT; 710 GLenum wrapModeR; 711 GLenum minFilter; 712 GLenum magFilter; 713 }; 714 715 TextureUnitCase (const TextureUnitCase& other); 716 TextureUnitCase& operator= (const TextureUnitCase& other); 717 718 void upload2dTexture (int texNdx, sglr::Context& context); 719 void uploadCubeTexture (int texNdx, sglr::Context& context); 720 void upload2dArrayTexture (int texNdx, sglr::Context& context); 721 void upload3dTexture (int texNdx, sglr::Context& context); 722 723 void render (sglr::Context& context); 724 725 const int m_numUnitsParam; 726 const CaseType m_caseType; 727 const deUint32 m_randSeed; 728 729 int m_numTextures; //!< \note Needed in addition to m_numUnits since same texture may be bound to many texture units. 730 int m_numUnits; //!< = m_numUnitsParam > 0 ? m_numUnitsParam : implementationDefinedMaximum 731 732 vector<GLenum> m_textureTypes; 733 vector<TextureParameters> m_textureParams; 734 vector<tcu::Texture2D*> m_textures2d; 735 vector<tcu::TextureCube*> m_texturesCube; 736 vector<tcu::Texture2DArray*> m_textures2dArray; 737 vector<tcu::Texture3D*> m_textures3d; 738 vector<int> m_unitTextures; //!< Which texture is used in a particular unit. 739 vector<int> m_ndxTexType; //!< Index of a texture in m_textures2d, m_texturesCube, m_textures2dArray or m_textures3d, depending on texture type. 740 MultiTexShader* m_shader; 741 }; 742 743 TextureUnitCase::TextureUnitCase (Context& context, const char* name, const char* desc, int numUnits, CaseType caseType, deUint32 randSeed) 744 : TestCase (context, tcu::NODETYPE_SELF_VALIDATE, name, desc) 745 , m_numUnitsParam (numUnits) 746 , m_caseType (caseType) 747 , m_randSeed (randSeed) 748 , m_shader (DE_NULL) 749 { 750 } 751 752 TextureUnitCase::~TextureUnitCase (void) 753 { 754 TextureUnitCase::deinit(); 755 } 756 757 void TextureUnitCase::deinit (void) 758 { 759 for (vector<tcu::Texture2D*>::iterator i = m_textures2d.begin(); i != m_textures2d.end(); i++) 760 delete *i; 761 m_textures2d.clear(); 762 763 for (vector<tcu::TextureCube*>::iterator i = m_texturesCube.begin(); i != m_texturesCube.end(); i++) 764 delete *i; 765 m_texturesCube.clear(); 766 767 for (vector<tcu::Texture2DArray*>::iterator i = m_textures2dArray.begin(); i != m_textures2dArray.end(); i++) 768 delete *i; 769 m_textures2dArray.clear(); 770 771 for (vector<tcu::Texture3D*>::iterator i = m_textures3d.begin(); i != m_textures3d.end(); i++) 772 delete *i; 773 m_textures3d.clear(); 774 775 delete m_shader; 776 m_shader = DE_NULL; 777 } 778 779 void TextureUnitCase::init (void) 780 { 781 m_numUnits = m_numUnitsParam > 0 ? m_numUnitsParam : m_context.getContextInfo().getInt(GL_MAX_TEXTURE_IMAGE_UNITS); 782 783 // Make the textures. 784 785 try 786 { 787 tcu::TestLog& log = m_testCtx.getLog(); 788 de::Random rnd (m_randSeed); 789 790 if (rnd.getFloat() < 0.7f) 791 m_numTextures = m_numUnits; // In most cases use one unit per texture. 792 else 793 m_numTextures = rnd.getInt(deMax32(1, m_numUnits - 2), m_numUnits); // Sometimes assign same texture to multiple units. 794 795 log << tcu::TestLog::Message << ("Using " + de::toString(m_numUnits) + " texture unit(s) and " + de::toString(m_numTextures) + " texture(s)").c_str() << tcu::TestLog::EndMessage; 796 797 m_textureTypes.reserve(m_numTextures); 798 m_textureParams.reserve(m_numTextures); 799 m_ndxTexType.reserve(m_numTextures); 800 801 // Generate textures. 802 803 for (int texNdx = 0; texNdx < m_numTextures; texNdx++) 804 { 805 // Either fixed or randomized target types, and randomized parameters for every texture. 806 807 TextureParameters params; 808 809 DE_STATIC_ASSERT(CASE_ONLY_2D == 0 && CASE_MIXED + 1 == CASE_LAST); 810 811 int texType = m_caseType == CASE_MIXED ? rnd.getInt(0, (int)CASE_MIXED - 1) : (int)m_caseType; 812 bool is2dTex = texType == 0; 813 bool isCubeTex = texType == 1; 814 bool is2dArrayTex = texType == 2; 815 bool is3dTex = texType == 3; 816 817 DE_ASSERT(is2dTex || isCubeTex || is2dArrayTex || is3dTex); 818 819 GLenum type = is2dTex ? GL_TEXTURE_2D : isCubeTex ? GL_TEXTURE_CUBE_MAP : is2dArrayTex ? GL_TEXTURE_2D_ARRAY : GL_TEXTURE_3D; 820 const int texWidth = is2dTex ? TEXTURE_WIDTH_2D : isCubeTex ? TEXTURE_WIDTH_CUBE : is2dArrayTex ? TEXTURE_WIDTH_2D_ARRAY : TEXTURE_WIDTH_3D; 821 const int texHeight = is2dTex ? TEXTURE_HEIGHT_2D : isCubeTex ? TEXTURE_HEIGHT_CUBE : is2dArrayTex ? TEXTURE_HEIGHT_2D_ARRAY : TEXTURE_HEIGHT_3D; 822 823 const int texDepth = is3dTex ? TEXTURE_DEPTH_3D : 1; 824 const int texLayers = is2dArrayTex ? TEXTURE_LAYERS_2D_ARRAY : 1; 825 826 bool mipmaps = (deIsPowerOfTwo32(texWidth) && deIsPowerOfTwo32(texHeight) && deIsPowerOfTwo32(texDepth)); 827 int numLevels = mipmaps ? deLog2Floor32(de::max(de::max(texWidth, texHeight), texDepth))+1 : 1; 828 829 params.internalFormat = s_testSizedInternalFormats[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testSizedInternalFormats) - 1)]; 830 831 bool isFilterable = glu::isGLInternalColorFormatFilterable(params.internalFormat); 832 833 params.wrapModeS = s_testWrapModes[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testWrapModes) - 1)]; 834 params.wrapModeT = s_testWrapModes[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testWrapModes) - 1)]; 835 params.wrapModeR = s_testWrapModes[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testWrapModes) - 1)]; 836 837 params.magFilter = isFilterable ? s_testMagFilters[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testMagFilters) - 1)] : GL_NEAREST; 838 839 if (mipmaps) 840 params.minFilter = isFilterable ? 841 s_testMinFilters [rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testMinFilters) - 1)] : 842 s_testNearestMinFilters [rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testNearestMinFilters) - 1)]; 843 else 844 params.minFilter = isFilterable ? 845 s_testNonMipmapMinFilters [rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testNonMipmapMinFilters) - 1)] : 846 GL_NEAREST; 847 848 m_textureTypes.push_back(type); 849 m_textureParams.push_back(params); 850 851 // Create new texture. 852 853 tcu::TextureFormat texFormat = glu::mapGLInternalFormat((deUint32)params.internalFormat); 854 855 if (is2dTex) 856 { 857 m_ndxTexType.push_back((int)m_textures2d.size()); // Remember the index this texture has in the 2d texture vector. 858 m_textures2d.push_back(new tcu::Texture2D(texFormat, texWidth, texHeight)); 859 } 860 else if (isCubeTex) 861 { 862 m_ndxTexType.push_back((int)m_texturesCube.size()); // Remember the index this texture has in the cube texture vector. 863 DE_ASSERT(texWidth == texHeight); 864 m_texturesCube.push_back(new tcu::TextureCube(texFormat, texWidth)); 865 } 866 else if (is2dArrayTex) 867 { 868 m_ndxTexType.push_back((int)m_textures2dArray.size()); // Remember the index this texture has in the 2d array texture vector. 869 m_textures2dArray.push_back(new tcu::Texture2DArray(texFormat, texWidth, texHeight, texLayers)); 870 } 871 else 872 { 873 m_ndxTexType.push_back((int)m_textures3d.size()); // Remember the index this texture has in the 3d vector. 874 m_textures3d.push_back(new tcu::Texture3D(texFormat, texWidth, texHeight, texDepth)); 875 } 876 877 tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(texFormat); 878 Vec4 cBias = fmtInfo.valueMin; 879 Vec4 cScale = fmtInfo.valueMax-fmtInfo.valueMin; 880 881 // Fill with grid texture. 882 883 int numFaces = isCubeTex ? (int)tcu::CUBEFACE_LAST : 1; 884 885 for (int face = 0; face < numFaces; face++) 886 { 887 deUint32 rgb = rnd.getUint32() & 0x00ffffff; 888 deUint32 alpha = 0xff000000; 889 890 deUint32 colorA = alpha | rgb; 891 deUint32 colorB = alpha | ((~rgb) & 0x00ffffff); 892 893 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 894 { 895 if (is2dTex) 896 m_textures2d.back()->allocLevel(levelNdx); 897 else if (isCubeTex) 898 m_texturesCube.back()->allocLevel((tcu::CubeFace)face, levelNdx); 899 else if (is2dArrayTex) 900 m_textures2dArray.back()->allocLevel(levelNdx); 901 else 902 m_textures3d.back()->allocLevel(levelNdx); 903 904 int curCellSize = deMax32(1, GRID_CELL_SIZE >> levelNdx); // \note Scale grid cell size for mipmaps. 905 906 tcu::PixelBufferAccess access = is2dTex ? m_textures2d.back()->getLevel(levelNdx) 907 : isCubeTex ? m_texturesCube.back()->getLevelFace(levelNdx, (tcu::CubeFace)face) 908 : is2dArrayTex ? m_textures2dArray.back()->getLevel(levelNdx) 909 : m_textures3d.back()->getLevel(levelNdx); 910 911 tcu::fillWithGrid(access, curCellSize, toVec4(tcu::RGBA(colorA))*cScale + cBias, toVec4(tcu::RGBA(colorB))*cScale + cBias); 912 } 913 } 914 } 915 916 // Assign a texture index to each unit. 917 918 m_unitTextures.reserve(m_numUnits); 919 920 // \note Every texture is used at least once. 921 for (int i = 0; i < m_numTextures; i++) 922 m_unitTextures.push_back(i); 923 924 // Assign a random texture to remaining units. 925 while ((int)m_unitTextures.size() < m_numUnits) 926 m_unitTextures.push_back(rnd.getInt(0, m_numTextures - 1)); 927 928 rnd.shuffle(m_unitTextures.begin(), m_unitTextures.end()); 929 930 // Generate information for shader. 931 932 vector<GLenum> unitTypes; 933 vector<Vec4> texScales; 934 vector<Vec4> texBiases; 935 vector<glu::DataType> samplerTypes; 936 vector<int> num2dArrayLayers; 937 938 unitTypes.reserve(m_numUnits); 939 texScales.reserve(m_numUnits); 940 texBiases.reserve(m_numUnits); 941 samplerTypes.reserve(m_numUnits); 942 num2dArrayLayers.reserve(m_numUnits); 943 944 for (int i = 0; i < m_numUnits; i++) 945 { 946 int texNdx = m_unitTextures[i]; 947 GLenum type = m_textureTypes[texNdx]; 948 tcu::TextureFormat fmt = glu::mapGLInternalFormat(m_textureParams[texNdx].internalFormat); 949 tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(fmt); 950 951 unitTypes.push_back(type); 952 953 if (type == GL_TEXTURE_2D_ARRAY) 954 num2dArrayLayers.push_back(m_textures2dArray[m_ndxTexType[texNdx]]->getNumLayers()); 955 956 texScales.push_back(fmtInfo.lookupScale); 957 texBiases.push_back(fmtInfo.lookupBias); 958 959 switch (type) 960 { 961 case GL_TEXTURE_2D: samplerTypes.push_back(glu::getSampler2DType(fmt)); break; 962 case GL_TEXTURE_CUBE_MAP: samplerTypes.push_back(glu::getSamplerCubeType(fmt)); break; 963 case GL_TEXTURE_2D_ARRAY: samplerTypes.push_back(glu::getSampler2DArrayType(fmt)); break; 964 case GL_TEXTURE_3D: samplerTypes.push_back(glu::getSampler3DType(fmt)); break; 965 default: 966 DE_ASSERT(DE_FALSE); 967 } 968 } 969 970 // Create shader. 971 972 DE_ASSERT(m_shader == DE_NULL); 973 m_shader = new MultiTexShader(rnd.getUint32(), m_numUnits, unitTypes, samplerTypes, texScales, texBiases, num2dArrayLayers); 974 } 975 catch (const std::exception&) 976 { 977 // Clean up to save memory. 978 TextureUnitCase::deinit(); 979 throw; 980 } 981 } 982 983 TextureUnitCase::IterateResult TextureUnitCase::iterate (void) 984 { 985 glu::RenderContext& renderCtx = m_context.getRenderContext(); 986 const tcu::RenderTarget& renderTarget = renderCtx.getRenderTarget(); 987 tcu::TestLog& log = m_testCtx.getLog(); 988 de::Random rnd (m_randSeed); 989 990 int viewportWidth = deMin32(VIEWPORT_WIDTH, renderTarget.getWidth()); 991 int viewportHeight = deMin32(VIEWPORT_HEIGHT, renderTarget.getHeight()); 992 int viewportX = rnd.getInt(0, renderTarget.getWidth() - viewportWidth); 993 int viewportY = rnd.getInt(0, renderTarget.getHeight() - viewportHeight); 994 995 tcu::Surface gles3Frame (viewportWidth, viewportHeight); 996 tcu::Surface refFrame (viewportWidth, viewportHeight); 997 998 { 999 // First we do some tricks to make the LODs safer wrt. precision issues. See MultiTexShader::makeSafeLods(). 1000 1001 vector<IVec3> texSizes; 1002 texSizes.reserve(m_numUnits); 1003 1004 for (int i = 0; i < m_numUnits; i++) 1005 { 1006 int texNdx = m_unitTextures[i]; 1007 int texNdxInType = m_ndxTexType[texNdx]; 1008 GLenum type = m_textureTypes[texNdx]; 1009 1010 switch (type) 1011 { 1012 case GL_TEXTURE_2D: texSizes.push_back(IVec3(m_textures2d[texNdxInType]->getWidth(), m_textures2d[texNdxInType]->getHeight(), 0)); break; 1013 case GL_TEXTURE_CUBE_MAP: texSizes.push_back(IVec3(m_texturesCube[texNdxInType]->getSize(), m_texturesCube[texNdxInType]->getSize(), 0)); break; 1014 case GL_TEXTURE_2D_ARRAY: texSizes.push_back(IVec3(m_textures2dArray[texNdxInType]->getWidth(), m_textures2dArray[texNdxInType]->getHeight(), 0)); break; 1015 case GL_TEXTURE_3D: texSizes.push_back(IVec3(m_textures3d[texNdxInType]->getWidth(), m_textures3d[texNdxInType]->getHeight(), m_textures3d[texNdxInType]->getDepth())); break; 1016 default: 1017 DE_ASSERT(DE_FALSE); 1018 } 1019 } 1020 1021 m_shader->makeSafeLods(texSizes, IVec2(viewportWidth, viewportHeight)); 1022 } 1023 1024 // Render using GLES3. 1025 { 1026 sglr::GLContext context(renderCtx, log, sglr::GLCONTEXT_LOG_CALLS|sglr::GLCONTEXT_LOG_PROGRAMS, tcu::IVec4(viewportX, viewportY, viewportWidth, viewportHeight)); 1027 1028 render(context); 1029 1030 context.readPixels(gles3Frame, 0, 0, viewportWidth, viewportHeight); 1031 } 1032 1033 // Render reference image. 1034 { 1035 sglr::ReferenceContextBuffers buffers (tcu::PixelFormat(8,8,8,renderTarget.getPixelFormat().alphaBits?8:0), 0 /* depth */, 0 /* stencil */, viewportWidth, viewportHeight); 1036 sglr::ReferenceContext context (sglr::ReferenceContextLimits(renderCtx), buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer()); 1037 1038 render(context); 1039 1040 context.readPixels(refFrame, 0, 0, viewportWidth, viewportHeight); 1041 } 1042 1043 // Compare images. 1044 const float threshold = 0.001f; 1045 bool isOk = tcu::fuzzyCompare(log, "ComparisonResult", "Image comparison result", refFrame, gles3Frame, threshold, tcu::COMPARE_LOG_RESULT); 1046 1047 // Store test result. 1048 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 1049 isOk ? "Pass" : "Image comparison failed"); 1050 1051 return STOP; 1052 } 1053 1054 void TextureUnitCase::upload2dTexture (int texNdx, sglr::Context& context) 1055 { 1056 int ndx2d = m_ndxTexType[texNdx]; 1057 const tcu::Texture2D* texture = m_textures2d[ndx2d]; 1058 glu::TransferFormat formatGl = glu::getTransferFormat(glu::mapGLInternalFormat(m_textureParams[texNdx].internalFormat)); 1059 1060 context.pixelStorei(GL_UNPACK_ALIGNMENT, 1); 1061 1062 for (int levelNdx = 0; levelNdx < texture->getNumLevels(); levelNdx++) 1063 { 1064 if (texture->isLevelEmpty(levelNdx)) 1065 continue; 1066 1067 tcu::ConstPixelBufferAccess access = texture->getLevel(levelNdx); 1068 int width = access.getWidth(); 1069 int height = access.getHeight(); 1070 1071 DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize()*width); 1072 1073 context.texImage2D(GL_TEXTURE_2D, levelNdx, m_textureParams[texNdx].internalFormat, width, height, 0 /* border */, formatGl.format, formatGl.dataType, access.getDataPtr()); 1074 GLU_EXPECT_NO_ERROR(context.getError(), "Set 2d texture image data"); 1075 } 1076 } 1077 1078 void TextureUnitCase::uploadCubeTexture (int texNdx, sglr::Context& context) 1079 { 1080 int ndxCube = m_ndxTexType[texNdx]; 1081 const tcu::TextureCube* texture = m_texturesCube[ndxCube]; 1082 glu::TransferFormat formatGl = glu::getTransferFormat(glu::mapGLInternalFormat(m_textureParams[texNdx].internalFormat)); 1083 1084 context.pixelStorei(GL_UNPACK_ALIGNMENT, 1); 1085 1086 for (int face = 0; face < (int)tcu::CUBEFACE_LAST; face++) 1087 { 1088 for (int levelNdx = 0; levelNdx < texture->getNumLevels(); levelNdx++) 1089 { 1090 if (texture->isLevelEmpty((tcu::CubeFace)face, levelNdx)) 1091 continue; 1092 1093 tcu::ConstPixelBufferAccess access = texture->getLevelFace(levelNdx, (tcu::CubeFace)face); 1094 int width = access.getWidth(); 1095 int height = access.getHeight(); 1096 1097 DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize()*width); 1098 1099 context.texImage2D(s_cubeFaceTargets[face], levelNdx, m_textureParams[texNdx].internalFormat, width, height, 0 /* border */, formatGl.format, formatGl.dataType, access.getDataPtr()); 1100 GLU_EXPECT_NO_ERROR(context.getError(), "Set cube map image data"); 1101 } 1102 } 1103 } 1104 1105 void TextureUnitCase::upload2dArrayTexture (int texNdx, sglr::Context& context) 1106 { 1107 int ndx2dArray = m_ndxTexType[texNdx]; 1108 const tcu::Texture2DArray* texture = m_textures2dArray[ndx2dArray]; 1109 glu::TransferFormat formatGl = glu::getTransferFormat(glu::mapGLInternalFormat(m_textureParams[texNdx].internalFormat)); 1110 1111 context.pixelStorei(GL_UNPACK_ALIGNMENT, 1); 1112 1113 for (int levelNdx = 0; levelNdx < texture->getNumLevels(); levelNdx++) 1114 { 1115 if (texture->isLevelEmpty(levelNdx)) 1116 continue; 1117 1118 tcu::ConstPixelBufferAccess access = texture->getLevel(levelNdx); 1119 int width = access.getWidth(); 1120 int height = access.getHeight(); 1121 int layers = access.getDepth(); 1122 1123 DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize()*width); 1124 DE_ASSERT(access.getSlicePitch() == access.getFormat().getPixelSize()*width*height); 1125 1126 context.texImage3D(GL_TEXTURE_2D_ARRAY, levelNdx, m_textureParams[texNdx].internalFormat, width, height, layers, 0 /* border */, formatGl.format, formatGl.dataType, access.getDataPtr()); 1127 GLU_EXPECT_NO_ERROR(context.getError(), "Set 2d array texture image data"); 1128 } 1129 } 1130 1131 void TextureUnitCase::upload3dTexture (int texNdx, sglr::Context& context) 1132 { 1133 int ndx3d = m_ndxTexType[texNdx]; 1134 const tcu::Texture3D* texture = m_textures3d[ndx3d]; 1135 glu::TransferFormat formatGl = glu::getTransferFormat(glu::mapGLInternalFormat(m_textureParams[texNdx].internalFormat)); 1136 1137 context.pixelStorei(GL_UNPACK_ALIGNMENT, 1); 1138 1139 for (int levelNdx = 0; levelNdx < texture->getNumLevels(); levelNdx++) 1140 { 1141 if (texture->isLevelEmpty(levelNdx)) 1142 continue; 1143 1144 tcu::ConstPixelBufferAccess access = texture->getLevel(levelNdx); 1145 int width = access.getWidth(); 1146 int height = access.getHeight(); 1147 int depth = access.getDepth(); 1148 1149 DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize()*width); 1150 DE_ASSERT(access.getSlicePitch() == access.getFormat().getPixelSize()*width*height); 1151 1152 context.texImage3D(GL_TEXTURE_3D, levelNdx, m_textureParams[texNdx].internalFormat, width, height, depth, 0 /* border */, formatGl.format, formatGl.dataType, access.getDataPtr()); 1153 GLU_EXPECT_NO_ERROR(context.getError(), "Set 3d texture image data"); 1154 } 1155 } 1156 1157 void TextureUnitCase::render (sglr::Context& context) 1158 { 1159 // Setup textures. 1160 1161 vector<deUint32> textureGLNames; 1162 vector<bool> isTextureSetUp(m_numTextures, false); // \note Same texture may be bound to multiple units, but we only want to set up parameters and data once per texture. 1163 1164 textureGLNames.resize(m_numTextures); 1165 context.genTextures(m_numTextures, &textureGLNames[0]); 1166 GLU_EXPECT_NO_ERROR(context.getError(), "Generate textures"); 1167 1168 for (int unitNdx = 0; unitNdx < m_numUnits; unitNdx++) 1169 { 1170 int texNdx = m_unitTextures[unitNdx]; 1171 1172 // Bind texture to unit. 1173 context.activeTexture(GL_TEXTURE0 + unitNdx); 1174 GLU_EXPECT_NO_ERROR(context.getError(), "Set active texture"); 1175 context.bindTexture(m_textureTypes[texNdx], textureGLNames[texNdx]); 1176 GLU_EXPECT_NO_ERROR(context.getError(), "Bind texture"); 1177 1178 if (!isTextureSetUp[texNdx]) 1179 { 1180 // Binding this texture for first time, so set parameters and data. 1181 1182 context.texParameteri(m_textureTypes[texNdx], GL_TEXTURE_WRAP_S, m_textureParams[texNdx].wrapModeS); 1183 context.texParameteri(m_textureTypes[texNdx], GL_TEXTURE_WRAP_T, m_textureParams[texNdx].wrapModeT); 1184 if (m_textureTypes[texNdx] == GL_TEXTURE_3D) 1185 context.texParameteri(m_textureTypes[texNdx], GL_TEXTURE_WRAP_R, m_textureParams[texNdx].wrapModeR); 1186 context.texParameteri(m_textureTypes[texNdx], GL_TEXTURE_MIN_FILTER, m_textureParams[texNdx].minFilter); 1187 context.texParameteri(m_textureTypes[texNdx], GL_TEXTURE_MAG_FILTER, m_textureParams[texNdx].magFilter); 1188 GLU_EXPECT_NO_ERROR(context.getError(), "Set texture parameters"); 1189 1190 switch (m_textureTypes[texNdx]) 1191 { 1192 case GL_TEXTURE_2D: upload2dTexture(texNdx, context); break; 1193 case GL_TEXTURE_CUBE_MAP: uploadCubeTexture(texNdx, context); break; 1194 case GL_TEXTURE_2D_ARRAY: upload2dArrayTexture(texNdx, context); break; 1195 case GL_TEXTURE_3D: upload3dTexture(texNdx, context); break; 1196 default: 1197 DE_ASSERT(DE_FALSE); 1198 } 1199 1200 isTextureSetUp[texNdx] = true; // Don't set up this texture's parameters and data again later. 1201 } 1202 } 1203 1204 GLU_EXPECT_NO_ERROR(context.getError(), "Set textures"); 1205 1206 // Setup shader 1207 1208 deUint32 shaderID = context.createProgram(m_shader); 1209 1210 // Draw. 1211 1212 context.clearColor(0.125f, 0.25f, 0.5f, 1.0f); 1213 context.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 1214 m_shader->setUniforms(context, shaderID); 1215 sglr::drawQuad(context, shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1216 GLU_EXPECT_NO_ERROR(context.getError(), "Draw"); 1217 1218 // Delete previously generated texture names. 1219 1220 context.deleteTextures(m_numTextures, &textureGLNames[0]); 1221 GLU_EXPECT_NO_ERROR(context.getError(), "Delete textures"); 1222 } 1223 1224 TextureUnitTests::TextureUnitTests (Context& context) 1225 : TestCaseGroup(context, "units", "Texture Unit Usage Tests") 1226 { 1227 } 1228 1229 TextureUnitTests::~TextureUnitTests (void) 1230 { 1231 } 1232 1233 void TextureUnitTests::init (void) 1234 { 1235 const int numTestsPerGroup = 10; 1236 1237 static const int unitCounts[] = 1238 { 1239 2, 1240 4, 1241 8, 1242 -1 // \note Negative stands for the implementation-specified maximum. 1243 }; 1244 1245 for (int unitCountNdx = 0; unitCountNdx < DE_LENGTH_OF_ARRAY(unitCounts); unitCountNdx++) 1246 { 1247 int numUnits = unitCounts[unitCountNdx]; 1248 1249 string countGroupName = (unitCounts[unitCountNdx] < 0 ? "all" : de::toString(numUnits)) + "_units"; 1250 1251 tcu::TestCaseGroup* countGroup = new tcu::TestCaseGroup(m_testCtx, countGroupName.c_str(), ""); 1252 addChild(countGroup); 1253 1254 DE_STATIC_ASSERT((int)TextureUnitCase::CASE_ONLY_2D == 0); 1255 1256 for (int caseType = (int)TextureUnitCase::CASE_ONLY_2D; caseType < (int)TextureUnitCase::CASE_LAST; caseType++) 1257 { 1258 const char* caseTypeGroupName = (TextureUnitCase::CaseType)caseType == TextureUnitCase::CASE_ONLY_2D ? "only_2d" 1259 : (TextureUnitCase::CaseType)caseType == TextureUnitCase::CASE_ONLY_CUBE ? "only_cube" 1260 : (TextureUnitCase::CaseType)caseType == TextureUnitCase::CASE_ONLY_2D_ARRAY ? "only_2d_array" 1261 : (TextureUnitCase::CaseType)caseType == TextureUnitCase::CASE_ONLY_3D ? "only_3d" 1262 : (TextureUnitCase::CaseType)caseType == TextureUnitCase::CASE_MIXED ? "mixed" 1263 : DE_NULL; 1264 1265 DE_ASSERT(caseTypeGroupName != DE_NULL); 1266 1267 tcu::TestCaseGroup* caseTypeGroup = new tcu::TestCaseGroup(m_testCtx, caseTypeGroupName, ""); 1268 countGroup->addChild(caseTypeGroup); 1269 1270 for (int testNdx = 0; testNdx < numTestsPerGroup; testNdx++) 1271 caseTypeGroup->addChild(new TextureUnitCase(m_context, de::toString(testNdx).c_str(), "", numUnits, (TextureUnitCase::CaseType)caseType, deUint32Hash((deUint32)testNdx))); 1272 } 1273 } 1274 } 1275 1276 } // Functional 1277 } // gles3 1278 } // deqp 1279
