1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL (ES) Module 3 * ----------------------------------------------- 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Shader execute test. 22 * 23 * \todo [petri] Multiple grid with differing constants/uniforms. 24 * \todo [petri] 25 *//*--------------------------------------------------------------------*/ 26 27 #include "glsShaderRenderCase.hpp" 28 29 #include "tcuSurface.hpp" 30 #include "tcuVector.hpp" 31 #include "tcuImageCompare.hpp" 32 #include "tcuTestLog.hpp" 33 #include "tcuRenderTarget.hpp" 34 35 #include "gluPixelTransfer.hpp" 36 #include "gluTexture.hpp" 37 #include "gluTextureUtil.hpp" 38 #include "gluDrawUtil.hpp" 39 40 #include "glwFunctions.hpp" 41 #include "glwEnums.hpp" 42 43 #include "deRandom.hpp" 44 #include "deMemory.h" 45 #include "deString.h" 46 #include "deMath.h" 47 #include "deStringUtil.hpp" 48 49 #include <stdio.h> 50 #include <vector> 51 #include <string> 52 53 namespace deqp 54 { 55 namespace gls 56 { 57 58 using namespace std; 59 using namespace tcu; 60 using namespace glu; 61 62 static const int GRID_SIZE = 64; 63 static const int MAX_RENDER_WIDTH = 128; 64 static const int MAX_RENDER_HEIGHT = 112; 65 static const tcu::Vec4 DEFAULT_CLEAR_COLOR = tcu::Vec4(0.125f, 0.25f, 0.5f, 1.0f); 66 67 // TextureBinding 68 69 TextureBinding::TextureBinding (const glu::Texture2D* tex2D, const tcu::Sampler& sampler) 70 : m_type (TYPE_2D) 71 , m_sampler (sampler) 72 { 73 m_binding.tex2D = tex2D; 74 } 75 76 TextureBinding::TextureBinding (const glu::TextureCube* texCube, const tcu::Sampler& sampler) 77 : m_type (TYPE_CUBE_MAP) 78 , m_sampler (sampler) 79 { 80 m_binding.texCube = texCube; 81 } 82 83 TextureBinding::TextureBinding (const glu::Texture2DArray* tex2DArray, const tcu::Sampler& sampler) 84 : m_type (TYPE_2D_ARRAY) 85 , m_sampler (sampler) 86 { 87 m_binding.tex2DArray = tex2DArray; 88 } 89 90 TextureBinding::TextureBinding (const glu::Texture3D* tex3D, const tcu::Sampler& sampler) 91 : m_type (TYPE_3D) 92 , m_sampler (sampler) 93 { 94 m_binding.tex3D = tex3D; 95 } 96 97 TextureBinding::TextureBinding (void) 98 : m_type (TYPE_NONE) 99 { 100 m_binding.tex2D = DE_NULL; 101 } 102 103 void TextureBinding::setSampler (const tcu::Sampler& sampler) 104 { 105 m_sampler = sampler; 106 } 107 108 void TextureBinding::setTexture (const glu::Texture2D* tex2D) 109 { 110 m_type = TYPE_2D; 111 m_binding.tex2D = tex2D; 112 } 113 114 void TextureBinding::setTexture (const glu::TextureCube* texCube) 115 { 116 m_type = TYPE_CUBE_MAP; 117 m_binding.texCube = texCube; 118 } 119 120 void TextureBinding::setTexture (const glu::Texture2DArray* tex2DArray) 121 { 122 m_type = TYPE_2D_ARRAY; 123 m_binding.tex2DArray = tex2DArray; 124 } 125 126 void TextureBinding::setTexture (const glu::Texture3D* tex3D) 127 { 128 m_type = TYPE_3D; 129 m_binding.tex3D = tex3D; 130 } 131 132 // QuadGrid. 133 134 class QuadGrid 135 { 136 public: 137 QuadGrid (int gridSize, int screenWidth, int screenHeight, const Vec4& constCoords, const vector<Mat4>& userAttribTransforms, const vector<TextureBinding>& textures); 138 ~QuadGrid (void); 139 140 int getGridSize (void) const { return m_gridSize; } 141 int getNumVertices (void) const { return m_numVertices; } 142 int getNumTriangles (void) const { return m_numTriangles; } 143 const Vec4& getConstCoords (void) const { return m_constCoords; } 144 const vector<Mat4> getUserAttribTransforms (void) const { return m_userAttribTransforms; } 145 const vector<TextureBinding>& getTextures (void) const { return m_textures; } 146 147 const Vec4* getPositions (void) const { return &m_positions[0]; } 148 const float* getAttribOne (void) const { return &m_attribOne[0]; } 149 const Vec4* getCoords (void) const { return &m_coords[0]; } 150 const Vec4* getUnitCoords (void) const { return &m_unitCoords[0]; } 151 const Vec4* getUserAttrib (int attribNdx) const { return &m_userAttribs[attribNdx][0]; } 152 const deUint16* getIndices (void) const { return &m_indices[0]; } 153 154 Vec4 getCoords (float sx, float sy) const; 155 Vec4 getUnitCoords (float sx, float sy) const; 156 157 int getNumUserAttribs (void) const { return (int)m_userAttribTransforms.size(); } 158 Vec4 getUserAttrib (int attribNdx, float sx, float sy) const; 159 160 private: 161 int m_gridSize; 162 int m_numVertices; 163 int m_numTriangles; 164 Vec4 m_constCoords; 165 vector<Mat4> m_userAttribTransforms; 166 vector<TextureBinding> m_textures; 167 168 vector<Vec4> m_screenPos; 169 vector<Vec4> m_positions; 170 vector<Vec4> m_coords; //!< Near-unit coordinates, roughly [-2.0 .. 2.0]. 171 vector<Vec4> m_unitCoords; //!< Positive-only coordinates [0.0 .. 1.5]. 172 vector<float> m_attribOne; 173 vector<Vec4> m_userAttribs[ShaderEvalContext::MAX_TEXTURES]; 174 vector<deUint16> m_indices; 175 }; 176 177 QuadGrid::QuadGrid (int gridSize, int width, int height, const Vec4& constCoords, const vector<Mat4>& userAttribTransforms, const vector<TextureBinding>& textures) 178 : m_gridSize (gridSize) 179 , m_numVertices ((gridSize + 1) * (gridSize + 1)) 180 , m_numTriangles (gridSize * gridSize * 2) 181 , m_constCoords (constCoords) 182 , m_userAttribTransforms (userAttribTransforms) 183 , m_textures (textures) 184 { 185 Vec4 viewportScale = Vec4((float)width, (float)height, 0.0f, 0.0f); 186 187 // Compute vertices. 188 m_positions.resize(m_numVertices); 189 m_coords.resize(m_numVertices); 190 m_unitCoords.resize(m_numVertices); 191 m_attribOne.resize(m_numVertices); 192 m_screenPos.resize(m_numVertices); 193 194 // User attributes. 195 for (int i = 0; i < DE_LENGTH_OF_ARRAY(m_userAttribs); i++) 196 m_userAttribs[i].resize(m_numVertices); 197 198 for (int y = 0; y < gridSize+1; y++) 199 for (int x = 0; x < gridSize+1; x++) 200 { 201 float sx = (float)x / (float)gridSize; 202 float sy = (float)y / (float)gridSize; 203 float fx = 2.0f * sx - 1.0f; 204 float fy = 2.0f * sy - 1.0f; 205 int vtxNdx = ((y * (gridSize+1)) + x); 206 207 m_positions[vtxNdx] = Vec4(fx, fy, 0.0f, 1.0f); 208 m_attribOne[vtxNdx] = 1.0f; 209 m_screenPos[vtxNdx] = Vec4(sx, sy, 0.0f, 1.0f) * viewportScale; 210 m_coords[vtxNdx] = getCoords(sx, sy); 211 m_unitCoords[vtxNdx] = getUnitCoords(sx, sy); 212 213 for (int attribNdx = 0; attribNdx < getNumUserAttribs(); attribNdx++) 214 m_userAttribs[attribNdx][vtxNdx] = getUserAttrib(attribNdx, sx, sy); 215 } 216 217 // Compute indices. 218 m_indices.resize(3 * m_numTriangles); 219 for (int y = 0; y < gridSize; y++) 220 for (int x = 0; x < gridSize; x++) 221 { 222 int stride = gridSize + 1; 223 int v00 = (y * stride) + x; 224 int v01 = (y * stride) + x + 1; 225 int v10 = ((y+1) * stride) + x; 226 int v11 = ((y+1) * stride) + x + 1; 227 228 int baseNdx = ((y * gridSize) + x) * 6; 229 m_indices[baseNdx + 0] = (deUint16)v10; 230 m_indices[baseNdx + 1] = (deUint16)v00; 231 m_indices[baseNdx + 2] = (deUint16)v01; 232 233 m_indices[baseNdx + 3] = (deUint16)v10; 234 m_indices[baseNdx + 4] = (deUint16)v01; 235 m_indices[baseNdx + 5] = (deUint16)v11; 236 } 237 } 238 239 QuadGrid::~QuadGrid (void) 240 { 241 } 242 243 inline Vec4 QuadGrid::getCoords (float sx, float sy) const 244 { 245 float fx = 2.0f * sx - 1.0f; 246 float fy = 2.0f * sy - 1.0f; 247 return Vec4(fx, fy, -fx + 0.33f*fy, -0.275f*fx - fy); 248 } 249 250 inline Vec4 QuadGrid::getUnitCoords (float sx, float sy) const 251 { 252 return Vec4(sx, sy, 0.33f*sx + 0.5f*sy, 0.5f*sx + 0.25f*sy); 253 } 254 255 inline Vec4 QuadGrid::getUserAttrib (int attribNdx, float sx, float sy) const 256 { 257 // homogeneous normalized screen-space coordinates 258 return m_userAttribTransforms[attribNdx] * Vec4(sx, sy, 0.0f, 1.0f); 259 } 260 261 // ShaderEvalContext. 262 263 ShaderEvalContext::ShaderEvalContext (const QuadGrid& quadGrid_) 264 : constCoords (quadGrid_.getConstCoords()) 265 , isDiscarded (false) 266 , quadGrid (quadGrid_) 267 { 268 const vector<TextureBinding>& bindings = quadGrid.getTextures(); 269 DE_ASSERT((int)bindings.size() <= MAX_TEXTURES); 270 271 // Fill in texture array. 272 for (int ndx = 0; ndx < (int)bindings.size(); ndx++) 273 { 274 const TextureBinding& binding = bindings[ndx]; 275 276 if (binding.getType() == TextureBinding::TYPE_NONE) 277 continue; 278 279 textures[ndx].sampler = binding.getSampler(); 280 281 switch (binding.getType()) 282 { 283 case TextureBinding::TYPE_2D: textures[ndx].tex2D = &binding.get2D()->getRefTexture(); break; 284 case TextureBinding::TYPE_CUBE_MAP: textures[ndx].texCube = &binding.getCube()->getRefTexture(); break; 285 case TextureBinding::TYPE_2D_ARRAY: textures[ndx].tex2DArray = &binding.get2DArray()->getRefTexture(); break; 286 case TextureBinding::TYPE_3D: textures[ndx].tex3D = &binding.get3D()->getRefTexture(); break; 287 default: 288 DE_ASSERT(DE_FALSE); 289 } 290 } 291 } 292 293 ShaderEvalContext::~ShaderEvalContext (void) 294 { 295 } 296 297 void ShaderEvalContext::reset (float sx, float sy) 298 { 299 // Clear old values 300 color = Vec4(0.0f, 0.0f, 0.0f, 1.0f); 301 isDiscarded = false; 302 303 // Compute coords 304 coords = quadGrid.getCoords(sx, sy); 305 unitCoords = quadGrid.getUnitCoords(sx, sy); 306 307 // Compute user attributes. 308 int numAttribs = quadGrid.getNumUserAttribs(); 309 DE_ASSERT(numAttribs <= MAX_USER_ATTRIBS); 310 for (int attribNdx = 0; attribNdx < numAttribs; attribNdx++) 311 in[attribNdx] = quadGrid.getUserAttrib(attribNdx, sx, sy); 312 } 313 314 tcu::Vec4 ShaderEvalContext::texture2D (int unitNdx, const tcu::Vec2& texCoords) 315 { 316 if (textures[unitNdx].tex2D) 317 return textures[unitNdx].tex2D->sample(textures[unitNdx].sampler, texCoords.x(), texCoords.y(), 0.0f); 318 else 319 return tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f); 320 } 321 322 // ShaderEvaluator 323 324 ShaderEvaluator::ShaderEvaluator (void) 325 : m_evalFunc(DE_NULL) 326 { 327 } 328 329 ShaderEvaluator::ShaderEvaluator (ShaderEvalFunc evalFunc) 330 : m_evalFunc(evalFunc) 331 { 332 } 333 334 ShaderEvaluator::~ShaderEvaluator (void) 335 { 336 } 337 338 void ShaderEvaluator::evaluate (ShaderEvalContext& ctx) 339 { 340 DE_ASSERT(m_evalFunc); 341 m_evalFunc(ctx); 342 } 343 344 // ShaderRenderCase. 345 346 ShaderRenderCase::ShaderRenderCase (TestContext& testCtx, RenderContext& renderCtx, const ContextInfo& ctxInfo, const char* name, const char* description, bool isVertexCase, ShaderEvalFunc evalFunc) 347 : TestCase (testCtx, name, description) 348 , m_renderCtx (renderCtx) 349 , m_ctxInfo (ctxInfo) 350 , m_isVertexCase (isVertexCase) 351 , m_defaultEvaluator (evalFunc) 352 , m_evaluator (m_defaultEvaluator) 353 , m_clearColor (DEFAULT_CLEAR_COLOR) 354 , m_program (DE_NULL) 355 { 356 } 357 358 ShaderRenderCase::ShaderRenderCase (TestContext& testCtx, RenderContext& renderCtx, const ContextInfo& ctxInfo, const char* name, const char* description, bool isVertexCase, ShaderEvaluator& evaluator) 359 : TestCase (testCtx, name, description) 360 , m_renderCtx (renderCtx) 361 , m_ctxInfo (ctxInfo) 362 , m_isVertexCase (isVertexCase) 363 , m_defaultEvaluator (DE_NULL) 364 , m_evaluator (evaluator) 365 , m_clearColor (DEFAULT_CLEAR_COLOR) 366 , m_program (DE_NULL) 367 { 368 } 369 370 ShaderRenderCase::~ShaderRenderCase (void) 371 { 372 ShaderRenderCase::deinit(); 373 } 374 375 void ShaderRenderCase::init (void) 376 { 377 TestLog& log = m_testCtx.getLog(); 378 const glw::Functions& gl = m_renderCtx.getFunctions(); 379 380 GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderRenderCase::init() begin"); 381 382 if (m_vertShaderSource.empty() || m_fragShaderSource.empty()) 383 { 384 DE_ASSERT(m_vertShaderSource.empty() && m_fragShaderSource.empty()); 385 setupShaderData(); 386 } 387 388 DE_ASSERT(!m_program); 389 m_program = new ShaderProgram(m_renderCtx, makeVtxFragSources(m_vertShaderSource, m_fragShaderSource)); 390 391 try 392 { 393 log << *m_program; // Always log shader program. 394 395 if (!m_program->isOk()) 396 throw CompileFailed(__FILE__, __LINE__); 397 398 GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderRenderCase::init() end"); 399 } 400 catch (const std::exception&) 401 { 402 // Clean up. 403 ShaderRenderCase::deinit(); 404 throw; 405 } 406 } 407 408 void ShaderRenderCase::deinit (void) 409 { 410 delete m_program; 411 m_program = DE_NULL; 412 } 413 414 tcu::IVec2 ShaderRenderCase::getViewportSize (void) const 415 { 416 return tcu::IVec2(de::min(m_renderCtx.getRenderTarget().getWidth(), MAX_RENDER_WIDTH), 417 de::min(m_renderCtx.getRenderTarget().getHeight(), MAX_RENDER_HEIGHT)); 418 } 419 420 TestNode::IterateResult ShaderRenderCase::iterate (void) 421 { 422 const glw::Functions& gl = m_renderCtx.getFunctions(); 423 424 GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderRenderCase::iterate() begin"); 425 426 DE_ASSERT(m_program); 427 deUint32 programID = m_program->getProgram(); 428 gl.useProgram(programID); 429 430 // Create quad grid. 431 IVec2 viewportSize = getViewportSize(); 432 int width = viewportSize.x(); 433 int height = viewportSize.y(); 434 435 // \todo [petri] Better handling of constCoords (render in multiple chunks, vary coords). 436 QuadGrid quadGrid(m_isVertexCase ? GRID_SIZE : 4, width, height, Vec4(0.125f, 0.25f, 0.5f, 1.0f), m_userAttribTransforms, m_textures); 437 438 // Render result. 439 Surface resImage(width, height); 440 render(resImage, programID, quadGrid); 441 442 // Compute reference. 443 Surface refImage (width, height); 444 if (m_isVertexCase) 445 computeVertexReference(refImage, quadGrid); 446 else 447 computeFragmentReference(refImage, quadGrid); 448 449 // Compare. 450 bool testOk = compareImages(resImage, refImage, 0.05f); 451 452 // De-initialize. 453 gl.useProgram(0); 454 455 m_testCtx.setTestResult(testOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 456 testOk ? "Pass" : "Fail"); 457 return TestNode::STOP; 458 } 459 460 void ShaderRenderCase::setupShaderData (void) 461 { 462 } 463 464 void ShaderRenderCase::setup (int programID) 465 { 466 DE_UNREF(programID); 467 } 468 469 void ShaderRenderCase::setupUniforms (int programID, const Vec4& constCoords) 470 { 471 DE_UNREF(programID); 472 DE_UNREF(constCoords); 473 } 474 475 void ShaderRenderCase::setupDefaultInputs (int programID) 476 { 477 const glw::Functions& gl = m_renderCtx.getFunctions(); 478 479 // SETUP UNIFORMS. 480 481 setupDefaultUniforms(m_renderCtx, programID); 482 483 GLU_EXPECT_NO_ERROR(gl.getError(), "post uniform setup"); 484 485 // SETUP TEXTURES. 486 487 for (int ndx = 0; ndx < (int)m_textures.size(); ndx++) 488 { 489 const TextureBinding& tex = m_textures[ndx]; 490 const tcu::Sampler& sampler = tex.getSampler(); 491 deUint32 texTarget = GL_NONE; 492 deUint32 texObj = 0; 493 494 if (tex.getType() == TextureBinding::TYPE_NONE) 495 continue; 496 497 // Feature check. 498 if (m_renderCtx.getType().getAPI() == glu::ApiType::es(2,0)) 499 { 500 if (tex.getType() == TextureBinding::TYPE_2D_ARRAY) 501 throw tcu::NotSupportedError("2D array texture binding is not supported"); 502 503 if (tex.getType() == TextureBinding::TYPE_3D) 504 throw tcu::NotSupportedError("3D texture binding is not supported"); 505 506 if (sampler.compare != tcu::Sampler::COMPAREMODE_NONE) 507 throw tcu::NotSupportedError("Shadow lookups are not supported"); 508 } 509 510 switch (tex.getType()) 511 { 512 case TextureBinding::TYPE_2D: texTarget = GL_TEXTURE_2D; texObj = tex.get2D()->getGLTexture(); break; 513 case TextureBinding::TYPE_CUBE_MAP: texTarget = GL_TEXTURE_CUBE_MAP; texObj = tex.getCube()->getGLTexture(); break; 514 case TextureBinding::TYPE_2D_ARRAY: texTarget = GL_TEXTURE_2D_ARRAY; texObj = tex.get2DArray()->getGLTexture(); break; 515 case TextureBinding::TYPE_3D: texTarget = GL_TEXTURE_3D; texObj = tex.get3D()->getGLTexture(); break; 516 default: 517 DE_ASSERT(DE_FALSE); 518 } 519 520 gl.activeTexture(GL_TEXTURE0+ndx); 521 gl.bindTexture(texTarget, texObj); 522 gl.texParameteri(texTarget, GL_TEXTURE_WRAP_S, glu::getGLWrapMode(sampler.wrapS)); 523 gl.texParameteri(texTarget, GL_TEXTURE_WRAP_T, glu::getGLWrapMode(sampler.wrapT)); 524 gl.texParameteri(texTarget, GL_TEXTURE_MIN_FILTER, glu::getGLFilterMode(sampler.minFilter)); 525 gl.texParameteri(texTarget, GL_TEXTURE_MAG_FILTER, glu::getGLFilterMode(sampler.magFilter)); 526 527 if (texTarget == GL_TEXTURE_3D) 528 gl.texParameteri(texTarget, GL_TEXTURE_WRAP_R, glu::getGLWrapMode(sampler.wrapR)); 529 530 if (sampler.compare != tcu::Sampler::COMPAREMODE_NONE) 531 { 532 gl.texParameteri(texTarget, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); 533 gl.texParameteri(texTarget, GL_TEXTURE_COMPARE_FUNC, glu::getGLCompareFunc(sampler.compare)); 534 } 535 } 536 537 GLU_EXPECT_NO_ERROR(gl.getError(), "texture sampler setup"); 538 } 539 540 static void getDefaultVertexArrays (const glw::Functions& gl, const QuadGrid& quadGrid, deUint32 program, vector<VertexArrayBinding>& vertexArrays) 541 { 542 const int numElements = quadGrid.getNumVertices(); 543 544 vertexArrays.push_back(va::Float("a_position", 4, numElements, 0, (const float*)quadGrid.getPositions())); 545 vertexArrays.push_back(va::Float("a_coords", 4, numElements, 0, (const float*)quadGrid.getCoords())); 546 vertexArrays.push_back(va::Float("a_unitCoords", 4, numElements, 0, (const float*)quadGrid.getUnitCoords())); 547 vertexArrays.push_back(va::Float("a_one", 1, numElements, 0, quadGrid.getAttribOne())); 548 549 // a_inN. 550 for (int userNdx = 0; userNdx < quadGrid.getNumUserAttribs(); userNdx++) 551 { 552 string name = string("a_in") + de::toString(userNdx); 553 vertexArrays.push_back(va::Float(name, 4, numElements, 0, (const float*)quadGrid.getUserAttrib(userNdx))); 554 } 555 556 // Matrix attributes - these are set by location 557 static const struct 558 { 559 const char* name; 560 int numCols; 561 int numRows; 562 } matrices[] = 563 { 564 { "a_mat2", 2, 2 }, 565 { "a_mat2x3", 2, 3 }, 566 { "a_mat2x4", 2, 4 }, 567 { "a_mat3x2", 3, 2 }, 568 { "a_mat3", 3, 3 }, 569 { "a_mat3x4", 3, 4 }, 570 { "a_mat4x2", 4, 2 }, 571 { "a_mat4x3", 4, 3 }, 572 { "a_mat4", 4, 4 } 573 }; 574 575 for (int matNdx = 0; matNdx < DE_LENGTH_OF_ARRAY(matrices); matNdx++) 576 { 577 int loc = gl.getAttribLocation(program, matrices[matNdx].name); 578 579 if (loc < 0) 580 continue; // Not used in shader. 581 582 int numRows = matrices[matNdx].numRows; 583 int numCols = matrices[matNdx].numCols; 584 585 for (int colNdx = 0; colNdx < numCols; colNdx++) 586 vertexArrays.push_back(va::Float(loc+colNdx, numRows, numElements, 4*(int)sizeof(float), (const float*)quadGrid.getUserAttrib(colNdx))); 587 } 588 } 589 590 void ShaderRenderCase::render (Surface& result, int programID, const QuadGrid& quadGrid) 591 { 592 const glw::Functions& gl = m_renderCtx.getFunctions(); 593 594 GLU_EXPECT_NO_ERROR(gl.getError(), "pre render"); 595 596 // Buffer info. 597 int width = result.getWidth(); 598 int height = result.getHeight(); 599 600 int xOffsetMax = m_renderCtx.getRenderTarget().getWidth() - width; 601 int yOffsetMax = m_renderCtx.getRenderTarget().getHeight() - height; 602 603 deUint32 hash = deStringHash(m_vertShaderSource.c_str()) + deStringHash(m_fragShaderSource.c_str()); 604 de::Random rnd (hash); 605 606 int xOffset = rnd.getInt(0, xOffsetMax); 607 int yOffset = rnd.getInt(0, yOffsetMax); 608 609 gl.viewport(xOffset, yOffset, width, height); 610 611 // Setup program. 612 setupUniforms(programID, quadGrid.getConstCoords()); 613 setupDefaultInputs(programID); 614 615 // Clear. 616 gl.clearColor(m_clearColor.x(), m_clearColor.y(), m_clearColor.z(), m_clearColor.w()); 617 gl.clear(GL_COLOR_BUFFER_BIT); 618 619 // Draw. 620 { 621 std::vector<VertexArrayBinding> vertexArrays; 622 const int numElements = quadGrid.getNumTriangles()*3; 623 624 getDefaultVertexArrays(gl, quadGrid, programID, vertexArrays); 625 draw(m_renderCtx, programID, (int)vertexArrays.size(), &vertexArrays[0], pr::Triangles(numElements, quadGrid.getIndices())); 626 } 627 GLU_EXPECT_NO_ERROR(gl.getError(), "draw"); 628 629 // Read back results. 630 glu::readPixels(m_renderCtx, xOffset, yOffset, result.getAccess()); 631 632 GLU_EXPECT_NO_ERROR(gl.getError(), "post render"); 633 } 634 635 void ShaderRenderCase::computeVertexReference (Surface& result, const QuadGrid& quadGrid) 636 { 637 // Buffer info. 638 int width = result.getWidth(); 639 int height = result.getHeight(); 640 int gridSize = quadGrid.getGridSize(); 641 int stride = gridSize + 1; 642 bool hasAlpha = m_renderCtx.getRenderTarget().getPixelFormat().alphaBits > 0; 643 ShaderEvalContext evalCtx (quadGrid); 644 645 // Evaluate color for each vertex. 646 vector<Vec4> colors((gridSize+1)*(gridSize+1)); 647 for (int y = 0; y < gridSize+1; y++) 648 for (int x = 0; x < gridSize+1; x++) 649 { 650 float sx = (float)x / (float)gridSize; 651 float sy = (float)y / (float)gridSize; 652 int vtxNdx = ((y * (gridSize+1)) + x); 653 654 evalCtx.reset(sx, sy); 655 m_evaluator.evaluate(evalCtx); 656 DE_ASSERT(!evalCtx.isDiscarded); // Discard is not available in vertex shader. 657 Vec4 color = evalCtx.color; 658 659 if (!hasAlpha) 660 color.w() = 1.0f; 661 662 colors[vtxNdx] = color; 663 } 664 665 // Render quads. 666 for (int y = 0; y < gridSize; y++) 667 for (int x = 0; x < gridSize; x++) 668 { 669 float x0 = (float)x / (float)gridSize; 670 float x1 = (float)(x + 1) / (float)gridSize; 671 float y0 = (float)y / (float)gridSize; 672 float y1 = (float)(y + 1) / (float)gridSize; 673 674 float sx0 = x0 * (float)width; 675 float sx1 = x1 * (float)width; 676 float sy0 = y0 * (float)height; 677 float sy1 = y1 * (float)height; 678 float oosx = 1.0f / (sx1 - sx0); 679 float oosy = 1.0f / (sy1 - sy0); 680 681 int ix0 = deCeilFloatToInt32(sx0 - 0.5f); 682 int ix1 = deCeilFloatToInt32(sx1 - 0.5f); 683 int iy0 = deCeilFloatToInt32(sy0 - 0.5f); 684 int iy1 = deCeilFloatToInt32(sy1 - 0.5f); 685 686 int v00 = (y * stride) + x; 687 int v01 = (y * stride) + x + 1; 688 int v10 = ((y + 1) * stride) + x; 689 int v11 = ((y + 1) * stride) + x + 1; 690 Vec4 c00 = colors[v00]; 691 Vec4 c01 = colors[v01]; 692 Vec4 c10 = colors[v10]; 693 Vec4 c11 = colors[v11]; 694 695 //printf("(%d,%d) -> (%f..%f, %f..%f) (%d..%d, %d..%d)\n", x, y, sx0, sx1, sy0, sy1, ix0, ix1, iy0, iy1); 696 697 for (int iy = iy0; iy < iy1; iy++) 698 for (int ix = ix0; ix < ix1; ix++) 699 { 700 DE_ASSERT(deInBounds32(ix, 0, width)); 701 DE_ASSERT(deInBounds32(iy, 0, height)); 702 703 float sfx = (float)ix + 0.5f; 704 float sfy = (float)iy + 0.5f; 705 float fx1 = deFloatClamp((sfx - sx0) * oosx, 0.0f, 1.0f); 706 float fy1 = deFloatClamp((sfy - sy0) * oosy, 0.0f, 1.0f); 707 708 // Triangle quad interpolation. 709 bool tri = fx1 + fy1 <= 1.0f; 710 float tx = tri ? fx1 : (1.0f-fx1); 711 float ty = tri ? fy1 : (1.0f-fy1); 712 const Vec4& t0 = tri ? c00 : c11; 713 const Vec4& t1 = tri ? c01 : c10; 714 const Vec4& t2 = tri ? c10 : c01; 715 Vec4 color = t0 + (t1-t0)*tx + (t2-t0)*ty; 716 717 result.setPixel(ix, iy, tcu::RGBA(color)); 718 } 719 } 720 } 721 722 void ShaderRenderCase::computeFragmentReference (Surface& result, const QuadGrid& quadGrid) 723 { 724 // Buffer info. 725 int width = result.getWidth(); 726 int height = result.getHeight(); 727 bool hasAlpha = m_renderCtx.getRenderTarget().getPixelFormat().alphaBits > 0; 728 ShaderEvalContext evalCtx (quadGrid); 729 730 // Render. 731 for (int y = 0; y < height; y++) 732 for (int x = 0; x < width; x++) 733 { 734 float sx = ((float)x + 0.5f) / (float)width; 735 float sy = ((float)y + 0.5f) / (float)height; 736 737 evalCtx.reset(sx, sy); 738 m_evaluator.evaluate(evalCtx); 739 // Select either clear color or computed color based on discarded bit. 740 Vec4 color = evalCtx.isDiscarded ? m_clearColor : evalCtx.color; 741 742 if (!hasAlpha) 743 color.w() = 1.0f; 744 745 result.setPixel(x, y, tcu::RGBA(color)); 746 } 747 } 748 749 bool ShaderRenderCase::compareImages (const Surface& resImage, const Surface& refImage, float errorThreshold) 750 { 751 return tcu::fuzzyCompare(m_testCtx.getLog(), "ComparisonResult", "Image comparison result", refImage, resImage, errorThreshold, tcu::COMPARE_LOG_RESULT); 752 } 753 754 // Uniform name helpers. 755 756 const char* getIntUniformName (int number) 757 { 758 switch (number) 759 { 760 case 0: return "ui_zero"; 761 case 1: return "ui_one"; 762 case 2: return "ui_two"; 763 case 3: return "ui_three"; 764 case 4: return "ui_four"; 765 case 5: return "ui_five"; 766 case 6: return "ui_six"; 767 case 7: return "ui_seven"; 768 case 8: return "ui_eight"; 769 case 101: return "ui_oneHundredOne"; 770 default: 771 DE_ASSERT(false); 772 return ""; 773 } 774 } 775 776 const char* getFloatUniformName (int number) 777 { 778 switch (number) 779 { 780 case 0: return "uf_zero"; 781 case 1: return "uf_one"; 782 case 2: return "uf_two"; 783 case 3: return "uf_three"; 784 case 4: return "uf_four"; 785 case 5: return "uf_five"; 786 case 6: return "uf_six"; 787 case 7: return "uf_seven"; 788 case 8: return "uf_eight"; 789 default: 790 DE_ASSERT(false); 791 return ""; 792 } 793 } 794 795 const char* getFloatFractionUniformName (int number) 796 { 797 switch (number) 798 { 799 case 1: return "uf_one"; 800 case 2: return "uf_half"; 801 case 3: return "uf_third"; 802 case 4: return "uf_fourth"; 803 case 5: return "uf_fifth"; 804 case 6: return "uf_sixth"; 805 case 7: return "uf_seventh"; 806 case 8: return "uf_eighth"; 807 default: 808 DE_ASSERT(false); 809 return ""; 810 } 811 } 812 813 void setupDefaultUniforms (const glu::RenderContext& context, deUint32 programID) 814 { 815 const glw::Functions& gl = context.getFunctions(); 816 817 // Bool. 818 struct BoolUniform { const char* name; bool value; }; 819 static const BoolUniform s_boolUniforms[] = 820 { 821 { "ub_true", true }, 822 { "ub_false", false }, 823 }; 824 825 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_boolUniforms); i++) 826 { 827 int uniLoc = gl.getUniformLocation(programID, s_boolUniforms[i].name); 828 if (uniLoc != -1) 829 gl.uniform1i(uniLoc, s_boolUniforms[i].value); 830 } 831 832 // BVec4. 833 struct BVec4Uniform { const char* name; BVec4 value; }; 834 static const BVec4Uniform s_bvec4Uniforms[] = 835 { 836 { "ub4_true", BVec4(true) }, 837 { "ub4_false", BVec4(false) }, 838 }; 839 840 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_bvec4Uniforms); i++) 841 { 842 const BVec4Uniform& uni = s_bvec4Uniforms[i]; 843 int arr[4]; 844 arr[0] = (int)uni.value.x(); 845 arr[1] = (int)uni.value.y(); 846 arr[2] = (int)uni.value.z(); 847 arr[3] = (int)uni.value.w(); 848 int uniLoc = gl.getUniformLocation(programID, uni.name); 849 if (uniLoc != -1) 850 gl.uniform4iv(uniLoc, 1, &arr[0]); 851 } 852 853 // Int. 854 struct IntUniform { const char* name; int value; }; 855 static const IntUniform s_intUniforms[] = 856 { 857 { "ui_minusOne", -1 }, 858 { "ui_zero", 0 }, 859 { "ui_one", 1 }, 860 { "ui_two", 2 }, 861 { "ui_three", 3 }, 862 { "ui_four", 4 }, 863 { "ui_five", 5 }, 864 { "ui_six", 6 }, 865 { "ui_seven", 7 }, 866 { "ui_eight", 8 }, 867 { "ui_oneHundredOne", 101 } 868 }; 869 870 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_intUniforms); i++) 871 { 872 int uniLoc = gl.getUniformLocation(programID, s_intUniforms[i].name); 873 if (uniLoc != -1) 874 gl.uniform1i(uniLoc, s_intUniforms[i].value); 875 } 876 877 // IVec2. 878 struct IVec2Uniform { const char* name; IVec2 value; }; 879 static const IVec2Uniform s_ivec2Uniforms[] = 880 { 881 { "ui2_minusOne", IVec2(-1) }, 882 { "ui2_zero", IVec2(0) }, 883 { "ui2_one", IVec2(1) }, 884 { "ui2_two", IVec2(2) }, 885 { "ui2_four", IVec2(4) }, 886 { "ui2_five", IVec2(5) } 887 }; 888 889 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_ivec2Uniforms); i++) 890 { 891 int uniLoc = gl.getUniformLocation(programID, s_ivec2Uniforms[i].name); 892 if (uniLoc != -1) 893 gl.uniform2iv(uniLoc, 1, s_ivec2Uniforms[i].value.getPtr()); 894 } 895 896 // IVec3. 897 struct IVec3Uniform { const char* name; IVec3 value; }; 898 static const IVec3Uniform s_ivec3Uniforms[] = 899 { 900 { "ui3_minusOne", IVec3(-1) }, 901 { "ui3_zero", IVec3(0) }, 902 { "ui3_one", IVec3(1) }, 903 { "ui3_two", IVec3(2) }, 904 { "ui3_four", IVec3(4) }, 905 { "ui3_five", IVec3(5) } 906 }; 907 908 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_ivec3Uniforms); i++) 909 { 910 int uniLoc = gl.getUniformLocation(programID, s_ivec3Uniforms[i].name); 911 if (uniLoc != -1) 912 gl.uniform3iv(uniLoc, 1, s_ivec3Uniforms[i].value.getPtr()); 913 } 914 915 // IVec4. 916 struct IVec4Uniform { const char* name; IVec4 value; }; 917 static const IVec4Uniform s_ivec4Uniforms[] = 918 { 919 { "ui4_minusOne", IVec4(-1) }, 920 { "ui4_zero", IVec4(0) }, 921 { "ui4_one", IVec4(1) }, 922 { "ui4_two", IVec4(2) }, 923 { "ui4_four", IVec4(4) }, 924 { "ui4_five", IVec4(5) } 925 }; 926 927 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_ivec4Uniforms); i++) 928 { 929 int uniLoc = gl.getUniformLocation(programID, s_ivec4Uniforms[i].name); 930 if (uniLoc != -1) 931 gl.uniform4iv(uniLoc, 1, s_ivec4Uniforms[i].value.getPtr()); 932 } 933 934 // Float. 935 struct FloatUniform { const char* name; float value; }; 936 static const FloatUniform s_floatUniforms[] = 937 { 938 { "uf_zero", 0.0f }, 939 { "uf_one", 1.0f }, 940 { "uf_two", 2.0f }, 941 { "uf_three", 3.0f }, 942 { "uf_four", 4.0f }, 943 { "uf_five", 5.0f }, 944 { "uf_six", 6.0f }, 945 { "uf_seven", 7.0f }, 946 { "uf_eight", 8.0f }, 947 { "uf_half", 1.0f / 2.0f }, 948 { "uf_third", 1.0f / 3.0f }, 949 { "uf_fourth", 1.0f / 4.0f }, 950 { "uf_fifth", 1.0f / 5.0f }, 951 { "uf_sixth", 1.0f / 6.0f }, 952 { "uf_seventh", 1.0f / 7.0f }, 953 { "uf_eighth", 1.0f / 8.0f } 954 }; 955 956 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_floatUniforms); i++) 957 { 958 int uniLoc = gl.getUniformLocation(programID, s_floatUniforms[i].name); 959 if (uniLoc != -1) 960 gl.uniform1f(uniLoc, s_floatUniforms[i].value); 961 } 962 963 // Vec2. 964 struct Vec2Uniform { const char* name; Vec2 value; }; 965 static const Vec2Uniform s_vec2Uniforms[] = 966 { 967 { "uv2_minusOne", Vec2(-1.0f) }, 968 { "uv2_zero", Vec2(0.0f) }, 969 { "uv2_half", Vec2(0.5f) }, 970 { "uv2_one", Vec2(1.0f) }, 971 { "uv2_two", Vec2(2.0f) }, 972 }; 973 974 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_vec2Uniforms); i++) 975 { 976 int uniLoc = gl.getUniformLocation(programID, s_vec2Uniforms[i].name); 977 if (uniLoc != -1) 978 gl.uniform2fv(uniLoc, 1, s_vec2Uniforms[i].value.getPtr()); 979 } 980 981 // Vec3. 982 struct Vec3Uniform { const char* name; Vec3 value; }; 983 static const Vec3Uniform s_vec3Uniforms[] = 984 { 985 { "uv3_minusOne", Vec3(-1.0f) }, 986 { "uv3_zero", Vec3(0.0f) }, 987 { "uv3_half", Vec3(0.5f) }, 988 { "uv3_one", Vec3(1.0f) }, 989 { "uv3_two", Vec3(2.0f) }, 990 }; 991 992 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_vec3Uniforms); i++) 993 { 994 int uniLoc = gl.getUniformLocation(programID, s_vec3Uniforms[i].name); 995 if (uniLoc != -1) 996 gl.uniform3fv(uniLoc, 1, s_vec3Uniforms[i].value.getPtr()); 997 } 998 999 // Vec4. 1000 struct Vec4Uniform { const char* name; Vec4 value; }; 1001 static const Vec4Uniform s_vec4Uniforms[] = 1002 { 1003 { "uv4_minusOne", Vec4(-1.0f) }, 1004 { "uv4_zero", Vec4(0.0f) }, 1005 { "uv4_half", Vec4(0.5f) }, 1006 { "uv4_one", Vec4(1.0f) }, 1007 { "uv4_two", Vec4(2.0f) }, 1008 { "uv4_black", Vec4(0.0f, 0.0f, 0.0f, 1.0f) }, 1009 { "uv4_gray", Vec4(0.5f, 0.5f, 0.5f, 1.0f) }, 1010 { "uv4_white", Vec4(1.0f, 1.0f, 1.0f, 1.0f) }, 1011 }; 1012 1013 for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_vec4Uniforms); i++) 1014 { 1015 int uniLoc = gl.getUniformLocation(programID, s_vec4Uniforms[i].name); 1016 if (uniLoc != -1) 1017 gl.uniform4fv(uniLoc, 1, s_vec4Uniforms[i].value.getPtr()); 1018 } 1019 } 1020 1021 } // gls 1022 } // deqp 1023
