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 Clipping tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es3fClippingTests.hpp" 25 #include "tcuRenderTarget.hpp" 26 #include "tcuTextureUtil.hpp" 27 #include "tcuImageCompare.hpp" 28 #include "tcuVectorUtil.hpp" 29 #include "deStringUtil.hpp" 30 #include "deRandom.hpp" 31 32 #include "sglrReferenceContext.hpp" 33 #include "sglrGLContext.hpp" 34 35 #include "glwEnums.hpp" 36 #include "glwDefs.hpp" 37 #include "glwFunctions.hpp" 38 39 using namespace glw; // GLint and other GL types 40 41 namespace deqp 42 { 43 namespace gles3 44 { 45 namespace Functional 46 { 47 namespace 48 { 49 50 using tcu::PixelBufferAccess; 51 using tcu::ConstPixelBufferAccess; 52 using tcu::TestLog; 53 54 static const tcu::Vec4 MASK_COLOR_OK = tcu::Vec4(0.0f, 0.1f, 0.0f, 1.0f); 55 static const tcu::Vec4 MASK_COLOR_DEV = tcu::Vec4(0.8f, 0.5f, 0.0f, 1.0f); 56 static const tcu::Vec4 MASK_COLOR_FAIL = tcu::Vec4(1.0f, 0.0f, 1.0f, 1.0f); 57 58 const int TEST_CANVAS_SIZE = 200; 59 const rr::WindowRectangle VIEWPORT_WHOLE (0, 0, TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 60 const rr::WindowRectangle VIEWPORT_CENTER (TEST_CANVAS_SIZE/4, TEST_CANVAS_SIZE/4, TEST_CANVAS_SIZE/2, TEST_CANVAS_SIZE/2); 61 const rr::WindowRectangle VIEWPORT_CORNER (TEST_CANVAS_SIZE/2, TEST_CANVAS_SIZE/2, TEST_CANVAS_SIZE/2, TEST_CANVAS_SIZE/2); 62 63 64 const char* shaderSourceVertex = "#version 300 es\n" 65 "in highp vec4 a_position;\n" 66 "in highp vec4 a_color;\n" 67 "in highp float a_pointSize;\n" 68 "out highp vec4 varFragColor;\n" 69 "void main (void)\n" 70 "{\n" 71 " gl_Position = a_position;\n" 72 " gl_PointSize = a_pointSize;\n" 73 " varFragColor = a_color;\n" 74 "}\n"; 75 const char* shaderSourceFragment = "#version 300 es\n" 76 "layout(location = 0) out mediump vec4 fragColor;" 77 "in highp vec4 varFragColor;\n" 78 "void main (void)\n" 79 "{\n" 80 " fragColor = varFragColor;\n" 81 "}\n"; 82 83 inline bool isBlack (const tcu::IVec4& a) 84 { 85 return a.x() == 0 && a.y() == 0 && a.z() == 0; 86 } 87 88 inline bool isHalfFilled (const tcu::IVec4& a) 89 { 90 const tcu::IVec4 halfFilled (127, 0, 0, 0); 91 const tcu::IVec4 threshold (20, 256, 256, 256); 92 93 return tcu::boolAll(tcu::lessThanEqual(tcu::abs(a - halfFilled), threshold)); 94 } 95 96 inline bool isLessThanHalfFilled (const tcu::IVec4& a) 97 { 98 const int halfFilled = 127; 99 const int threshold = 20; 100 101 return a.x() + threshold < halfFilled; 102 } 103 104 inline bool compareBlackNonBlackPixels (const tcu::IVec4& a, const tcu::IVec4& b) 105 { 106 return isBlack(a) == isBlack(b); 107 } 108 109 inline bool compareColoredPixels (const tcu::IVec4& a, const tcu::IVec4& b) 110 { 111 const bool aIsBlack = isBlack(a); 112 const bool bIsBlack = isBlack(b); 113 const tcu::IVec4 threshold(20, 20, 20, 0); 114 115 if (aIsBlack && bIsBlack) 116 return true; 117 if (aIsBlack != bIsBlack) 118 return false; 119 120 return tcu::boolAll(tcu::lessThanEqual(tcu::abs(a - b), threshold)); 121 } 122 123 void blitImageOnBlackSurface(const ConstPixelBufferAccess& src, const PixelBufferAccess& dst) 124 { 125 const int height = src.getHeight(); 126 const int width = src.getWidth(); 127 128 for (int y = 0; y < height; y++) 129 for (int x = 0; x < width; x++) 130 { 131 const tcu::IVec4 cSrc = src.getPixelInt(x, y); 132 const tcu::IVec4 cDst = tcu::IVec4(cSrc.x(), cSrc.y(), cSrc.z(), 255); 133 134 dst.setPixel(cDst, x, y); 135 } 136 } 137 138 /*--------------------------------------------------------------------*//*! 139 * \brief Pixelwise comparison of two images. 140 * \note copied & modified from glsRasterizationTests 141 * 142 * Kernel radius defines maximum allowed distance. If radius is 0, only 143 * perfect match is allowed. Radius of 1 gives a 3x3 kernel. Pixels are 144 * equal if pixelCmp returns true.. 145 * 146 * Return values: -1 = Perfect match 147 * 0 = Deviation within kernel 148 * >0 = Number of faulty pixels 149 *//*--------------------------------------------------------------------*/ 150 inline int compareImages (tcu::TestLog& log, const ConstPixelBufferAccess& test, const ConstPixelBufferAccess& ref, const PixelBufferAccess& diffMask, int kernelRadius, bool (*pixelCmp)(const tcu::IVec4& a, const tcu::IVec4& b)) 151 { 152 const int height = test.getHeight(); 153 const int width = test.getWidth(); 154 int deviatingPixels = 0; 155 int faultyPixels = 0; 156 int compareFailed = -1; 157 158 tcu::clear(diffMask, MASK_COLOR_OK); 159 160 for (int y = 0; y < height; y++) 161 { 162 for (int x = 0; x < width; x++) 163 { 164 const tcu::IVec4 cRef = ref.getPixelInt(x, y); 165 const tcu::IVec4 cTest = test.getPixelInt(x, y); 166 167 // Pixelwise match, no deviation or fault 168 if ((*pixelCmp)(cRef, cTest)) 169 continue; 170 171 // Deviation 172 { 173 const int radius = kernelRadius; 174 bool foundRef = false; 175 bool foundTest = false; 176 177 // edges are considered a "deviation" too. The suitable pixel could be "behind" the edge 178 if (y < radius || x < radius || y + radius >= height || x + radius >= width) 179 { 180 foundRef = true; 181 foundTest = true; 182 } 183 else 184 { 185 // find ref 186 for (int kY = y - radius; kY <= y + radius; kY++) 187 for (int kX = x - radius; kX <= x + radius; kX++) 188 { 189 if ((*pixelCmp)(cRef, test.getPixelInt(kX, kY))) 190 { 191 foundRef = true; 192 break; 193 } 194 } 195 196 // find result 197 for (int kY = y - radius; kY <= y + radius; kY++) 198 for (int kX = x - radius; kX <= x + radius; kX++) 199 { 200 if ((*pixelCmp)(cTest, ref.getPixelInt(kX, kY))) 201 { 202 foundTest = true; 203 break; 204 } 205 } 206 } 207 208 // A pixel is deviating if the reference color is found inside the kernel and (~= every pixel reference draws must be drawn by the gl too) 209 // the result color is found in the reference image inside the kernel (~= every pixel gl draws must be drawn by the reference too) 210 if (foundRef && foundTest) 211 { 212 diffMask.setPixel(MASK_COLOR_DEV, x, y); 213 if (compareFailed == -1) 214 compareFailed = 0; 215 deviatingPixels++; 216 continue; 217 } 218 } 219 220 diffMask.setPixel(MASK_COLOR_FAIL, x, y); 221 faultyPixels++; // The pixel is faulty if the color is not found 222 compareFailed = 1; 223 } 224 } 225 226 log << TestLog::Message << deviatingPixels << " deviating pixel(s) found." << TestLog::EndMessage; 227 log << TestLog::Message << faultyPixels << " faulty pixel(s) found." << TestLog::EndMessage; 228 229 return (compareFailed == 1 ? faultyPixels : compareFailed); 230 } 231 232 /*--------------------------------------------------------------------*//*! 233 * \brief Pixelwise comparison of two images. 234 * 235 * Kernel radius defines maximum allowed distance. If radius is 0, only 236 * perfect match is allowed. Radius of 1 gives a 3x3 kernel. Pixels are 237 * equal if they both are black, or both are non-black. 238 * 239 * Return values: -1 = Perfect match 240 * 0 = Deviation within kernel 241 * >0 = Number of faulty pixels 242 *//*--------------------------------------------------------------------*/ 243 int compareBlackNonBlackImages (tcu::TestLog& log, const ConstPixelBufferAccess& test, const ConstPixelBufferAccess& ref, const PixelBufferAccess& diffMask, int kernelRadius) 244 { 245 return compareImages(log, test, ref, diffMask, kernelRadius, compareBlackNonBlackPixels); 246 } 247 248 /*--------------------------------------------------------------------*//*! 249 * \brief Pixelwise comparison of two images. 250 * 251 * Kernel radius defines maximum allowed distance. If radius is 0, only 252 * perfect match is allowed. Radius of 1 gives a 3x3 kernel. Pixels are 253 * equal if they both are black, or both are non-black with color values 254 * close to each other. 255 * 256 * Return values: -1 = Perfect match 257 * 0 = Deviation within kernel 258 * >0 = Number of faulty pixels 259 *//*--------------------------------------------------------------------*/ 260 int compareColoredImages (tcu::TestLog& log, const ConstPixelBufferAccess& test, const ConstPixelBufferAccess& ref, const PixelBufferAccess& diffMask, int kernelRadius) 261 { 262 return compareImages(log, test, ref, diffMask, kernelRadius, compareColoredPixels); 263 } 264 265 /*--------------------------------------------------------------------*//*! 266 * \brief Overdraw check verification 267 * 268 * Check that image does not have at any point a 269 * pixel with red component value > 0.5 270 * 271 * Return values: false = area not filled, or leaking 272 *//*--------------------------------------------------------------------*/ 273 bool checkHalfFilledImageOverdraw (tcu::TestLog& log, const tcu::RenderTarget& m_renderTarget, const ConstPixelBufferAccess& image, const PixelBufferAccess& output) 274 { 275 const int height = image.getHeight(); 276 const int width = image.getWidth(); 277 278 bool faulty = false; 279 280 tcu::clear(output, MASK_COLOR_OK); 281 282 for (int y = 0; y < height; y++) 283 { 284 for (int x = 0; x < width; x++) 285 { 286 const tcu::IVec4 cTest = image.getPixelInt(x, y); 287 288 const bool pixelValid = isBlack(cTest) || isHalfFilled(cTest) || (m_renderTarget.getNumSamples() > 1 && isLessThanHalfFilled(cTest)); 289 290 if (!pixelValid) 291 { 292 output.setPixel(MASK_COLOR_FAIL, x, y); 293 faulty = true; 294 } 295 } 296 } 297 298 if (faulty) 299 log << TestLog::Message << "Faulty pixel(s) found." << TestLog::EndMessage; 300 301 return !faulty; 302 } 303 304 void checkPointSize (const glw::Functions& gl, float pointSize) 305 { 306 GLfloat pointSizeRange[2] = {0,0}; 307 gl.getFloatv(GL_ALIASED_POINT_SIZE_RANGE, pointSizeRange); 308 if (pointSizeRange[1] < pointSize) 309 throw tcu::NotSupportedError("Maximum point size is too low for this test"); 310 } 311 312 void checkLineWidth (const glw::Functions& gl, float lineWidth) 313 { 314 GLfloat lineWidthRange[2] = {0,0}; 315 gl.getFloatv(GL_ALIASED_LINE_WIDTH_RANGE, lineWidthRange); 316 if (lineWidthRange[1] < lineWidth) 317 throw tcu::NotSupportedError("Maximum line width is too low for this test"); 318 } 319 320 tcu::Vec3 IVec3ToVec3 (const tcu::IVec3& v) 321 { 322 return tcu::Vec3((float)v.x(), (float)v.y(), (float)v.z()); 323 } 324 325 bool pointOnTriangle (const tcu::IVec3& p, const tcu::IVec3& t0, const tcu::IVec3& t1, const tcu::IVec3& t2) 326 { 327 // Must be on the plane 328 const tcu::IVec3 n = tcu::cross(t1 - t0, t2 - t0); 329 const tcu::IVec3 d = (p - t0); 330 331 if (tcu::dot(n, d)) 332 return false; 333 334 // Must be within the triangle area 335 if (deSign32(tcu::dot(n, tcu::cross(t1 - t0, p - t0))) == deSign32(tcu::dot(n, tcu::cross(t2 - t0, p - t0)))) 336 return false; 337 if (deSign32(tcu::dot(n, tcu::cross(t2 - t1, p - t1))) == deSign32(tcu::dot(n, tcu::cross(t0 - t1, p - t1)))) 338 return false; 339 if (deSign32(tcu::dot(n, tcu::cross(t0 - t2, p - t2))) == deSign32(tcu::dot(n, tcu::cross(t1 - t2, p - t2)))) 340 return false; 341 342 return true; 343 } 344 345 bool pointsOnLine (const tcu::IVec2& t0, const tcu::IVec2& t1, const tcu::IVec2& t2) 346 { 347 return (t1 - t0).x() * (t2 - t0).y() - (t2 - t0).x() * (t1 - t0).y() == 0; 348 } 349 350 // returns true for cases where polygon is (almost) along xz or yz planes (normal.z < 0.1) 351 // \note[jarkko] Doesn't have to be accurate, just to detect some obviously bad cases 352 bool twoPointClippedTriangleInvisible(const tcu::Vec3& p, const tcu::IVec3& dir1, const tcu::IVec3& dir2) 353 { 354 // fixed-point-like coords 355 const deInt64 fixedScale = 64; 356 const deInt64 farValue = 1024; 357 const tcu::Vector<deInt64, 3> d1 = tcu::Vector<deInt64, 3>(dir1.x(), dir1.y(), dir1.z()); 358 const tcu::Vector<deInt64, 3> d2 = tcu::Vector<deInt64, 3>(dir2.x(), dir2.y(), dir2.z()); 359 const tcu::Vector<deInt64, 3> pfixed = tcu::Vector<deInt64, 3>(deFloorFloatToInt32(p.x() * fixedScale), deFloorFloatToInt32(p.y() * fixedScale), deFloorFloatToInt32(p.z() * fixedScale)); 360 const tcu::Vector<deInt64, 3> normalDir = tcu::cross(d1*farValue - pfixed, d2*farValue - pfixed); 361 const deInt64 normalLen2 = tcu::lengthSquared(normalDir); 362 363 return (normalDir.z() * normalDir.z() - normalLen2/100) < 0; 364 } 365 366 std::string genClippingPointInfoString(const tcu::Vec4& p) 367 { 368 std::ostringstream msg; 369 370 if (p.x() < -p.w()) msg << "\t(-X clip)"; 371 if (p.x() > p.w()) msg << "\t(+X clip)"; 372 if (p.y() < -p.w()) msg << "\t(-Y clip)"; 373 if (p.y() > p.w()) msg << "\t(+Y clip)"; 374 if (p.z() < -p.w()) msg << "\t(-Z clip)"; 375 if (p.z() > p.w()) msg << "\t(+Z clip)"; 376 377 return msg.str(); 378 } 379 380 std::string genColorString(const tcu::Vec4& p) 381 { 382 const tcu::Vec4 white (1.0f, 1.0f, 1.0f, 1.0f); 383 const tcu::Vec4 red (1.0f, 0.0f, 0.0f, 1.0f); 384 const tcu::Vec4 yellow (1.0f, 1.0f, 0.0f, 1.0f); 385 const tcu::Vec4 blue (0.0f, 0.0f, 1.0f, 1.0f); 386 387 if (p == white) return "(white)"; 388 if (p == red) return "(red)"; 389 if (p == yellow) return "(yellow)"; 390 if (p == blue) return "(blue)"; 391 return ""; 392 } 393 394 class PositionColorShader : public sglr::ShaderProgram 395 { 396 public: 397 enum 398 { 399 VARYINGLOC_COLOR = 0 400 }; 401 402 PositionColorShader (void); 403 404 void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const; 405 void shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const; 406 }; 407 408 PositionColorShader::PositionColorShader (void) 409 : sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration() 410 << sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT) 411 << sglr::pdec::VertexAttribute("a_color", rr::GENERICVECTYPE_FLOAT) 412 << sglr::pdec::VertexAttribute("a_pointSize", rr::GENERICVECTYPE_FLOAT) 413 << sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT) 414 << sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT) 415 << sglr::pdec::VertexSource(shaderSourceVertex) 416 << sglr::pdec::FragmentSource(shaderSourceFragment)) 417 { 418 } 419 420 void PositionColorShader::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const 421 { 422 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx) 423 { 424 const int positionAttrLoc = 0; 425 const int colorAttrLoc = 1; 426 const int pointSizeAttrLoc = 2; 427 428 rr::VertexPacket& packet = *packets[packetNdx]; 429 430 // Transform to position 431 packet.position = rr::readVertexAttribFloat(inputs[positionAttrLoc], packet.instanceNdx, packet.vertexNdx); 432 433 // output point size 434 packet.pointSize = rr::readVertexAttribFloat(inputs[pointSizeAttrLoc], packet.instanceNdx, packet.vertexNdx).x(); 435 436 // Pass color to FS 437 packet.outputs[VARYINGLOC_COLOR] = rr::readVertexAttribFloat(inputs[colorAttrLoc], packet.instanceNdx, packet.vertexNdx); 438 } 439 } 440 441 void PositionColorShader::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const 442 { 443 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx) 444 { 445 rr::FragmentPacket& packet = packets[packetNdx]; 446 447 for (int fragNdx = 0; fragNdx < 4; ++fragNdx) 448 rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, rr::readVarying<float>(packet, context, VARYINGLOC_COLOR, fragNdx)); 449 } 450 } 451 452 class RenderTestCase : public TestCase 453 { 454 public: 455 RenderTestCase (Context& context, const char* name, const char* description); 456 457 virtual void testRender (void) = DE_NULL; 458 virtual void init (void) { } 459 460 IterateResult iterate (void); 461 }; 462 463 RenderTestCase::RenderTestCase (Context& context, const char* name, const char* description) 464 : TestCase (context, name, description) 465 { 466 } 467 468 RenderTestCase::IterateResult RenderTestCase::iterate (void) 469 { 470 const int width = m_context.getRenderTarget().getWidth(); 471 const int height = m_context.getRenderTarget().getHeight(); 472 473 m_testCtx.getLog() << TestLog::Message << "Render target size: " << width << "x" << height << TestLog::EndMessage; 474 if (width < TEST_CANVAS_SIZE || height < TEST_CANVAS_SIZE) 475 throw tcu::NotSupportedError(std::string("Render target size must be at least ") + de::toString(TEST_CANVAS_SIZE) + "x" + de::toString(TEST_CANVAS_SIZE)); 476 477 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); // success by default 478 testRender(); 479 480 return STOP; 481 } 482 483 class PointCase : public RenderTestCase 484 { 485 public: 486 PointCase (Context& context, const char* name, const char* description, const tcu::Vec4* pointsBegin, const tcu::Vec4* pointsEnd, float pointSize, const rr::WindowRectangle& viewport); 487 488 void init (void); 489 void testRender (void); 490 491 private: 492 const std::vector<tcu::Vec4> m_points; 493 const float m_pointSize; 494 const rr::WindowRectangle m_viewport; 495 }; 496 497 PointCase::PointCase (Context& context, const char* name, const char* description, const tcu::Vec4* pointsBegin, const tcu::Vec4* pointsEnd, float pointSize, const rr::WindowRectangle& viewport) 498 : RenderTestCase(context, name, description) 499 , m_points (pointsBegin, pointsEnd) 500 , m_pointSize (pointSize) 501 , m_viewport (viewport) 502 { 503 } 504 505 void PointCase::init (void) 506 { 507 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 508 checkPointSize (gl, m_pointSize); 509 } 510 511 void PointCase::testRender (void) 512 { 513 using tcu::TestLog; 514 515 const int numSamples = de::max(m_context.getRenderTarget().getNumSamples(), 1); 516 517 tcu::TestLog& log = m_testCtx.getLog(); 518 sglr::GLContext glesContext (m_context.getRenderContext(), log, 0, tcu::IVec4(0, 0, TEST_CANVAS_SIZE, TEST_CANVAS_SIZE)); 519 sglr::ReferenceContextLimits limits; 520 sglr::ReferenceContextBuffers buffers (m_context.getRenderTarget().getPixelFormat(), m_context.getRenderTarget().getDepthBits(), 0, TEST_CANVAS_SIZE, TEST_CANVAS_SIZE, numSamples); 521 sglr::ReferenceContext refContext (limits, buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer()); 522 PositionColorShader program; 523 tcu::Surface testSurface (TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 524 tcu::Surface refSurface (TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 525 sglr::Context* contexts[2] = {&glesContext, &refContext}; 526 tcu::Surface* surfaces[2] = {&testSurface, &refSurface}; 527 528 // log the purpose of the test 529 log << TestLog::Message << "Viewport: left=" << m_viewport.left << "\tbottom=" << m_viewport.bottom << "\twidth=" << m_viewport.width << "\theight=" << m_viewport.height << TestLog::EndMessage; 530 log << TestLog::Message << "Rendering points with point size " << m_pointSize << ". Coordinates:" << TestLog::EndMessage; 531 for (size_t ndx = 0; ndx < m_points.size(); ++ndx) 532 log << TestLog::Message 533 << "\tx=" << m_points[ndx].x() 534 << "\ty=" << m_points[ndx].y() 535 << "\tz=" << m_points[ndx].z() 536 << "\tw=" << m_points[ndx].w() 537 << "\t" << genClippingPointInfoString(m_points[ndx]) 538 << TestLog::EndMessage; 539 540 for (int contextNdx = 0; contextNdx < 2; ++contextNdx) 541 { 542 sglr::Context& ctx = *contexts[contextNdx]; 543 tcu::Surface& dstSurface = *surfaces[contextNdx]; 544 const deUint32 programId = ctx.createProgram(&program); 545 const GLint positionLoc = ctx.getAttribLocation(programId, "a_position"); 546 const GLint pointSizeLoc = ctx.getAttribLocation(programId, "a_pointSize"); 547 const GLint colorLoc = ctx.getAttribLocation(programId, "a_color"); 548 549 ctx.clearColor (0, 0, 0, 1); 550 ctx.clearDepthf (1.0f); 551 ctx.clear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 552 ctx.viewport (m_viewport.left, m_viewport.bottom, m_viewport.width, m_viewport.height); 553 ctx.useProgram (programId); 554 ctx.enableVertexAttribArray (positionLoc); 555 ctx.vertexAttribPointer (positionLoc, 4, GL_FLOAT, GL_FALSE, 0, &m_points[0]); 556 ctx.vertexAttrib1f (pointSizeLoc, m_pointSize); 557 ctx.vertexAttrib4f (colorLoc, 1.0f, 1.0f, 1.0f, 1.0f); 558 ctx.drawArrays (GL_POINTS, 0, (glw::GLsizei)m_points.size()); 559 ctx.disableVertexAttribArray (positionLoc); 560 ctx.useProgram (0); 561 ctx.deleteProgram (programId); 562 ctx.finish (); 563 564 ctx.readPixels(dstSurface, 0, 0, TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 565 } 566 567 // do the comparison 568 { 569 tcu::Surface diffMask (TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 570 const int kernelRadius = 1; 571 int faultyPixels; 572 573 log << TestLog::Message << "Comparing images... " << TestLog::EndMessage; 574 log << TestLog::Message << "Deviation within radius of " << kernelRadius << " is allowed." << TestLog::EndMessage; 575 576 faultyPixels = compareBlackNonBlackImages(log, testSurface.getAccess(), refSurface.getAccess(), diffMask.getAccess(), kernelRadius); 577 578 if (faultyPixels > 0) 579 { 580 log << TestLog::ImageSet("Images", "Image comparison") 581 << TestLog::Image("TestImage", "Test image", testSurface.getAccess()) 582 << TestLog::Image("ReferenceImage", "Reference image", refSurface.getAccess()) 583 << TestLog::Image("DifferenceMask", "Difference mask", diffMask.getAccess()) 584 << TestLog::EndImageSet 585 << tcu::TestLog::Message << "Got " << faultyPixels << " faulty pixel(s)." << tcu::TestLog::EndMessage; 586 587 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got faulty pixels"); 588 } 589 } 590 } 591 592 class LineRenderTestCase : public RenderTestCase 593 { 594 public: 595 struct ColoredLineData 596 { 597 tcu::Vec4 p0; 598 tcu::Vec4 c0; 599 tcu::Vec4 p1; 600 tcu::Vec4 c1; 601 }; 602 603 struct ColorlessLineData 604 { 605 tcu::Vec4 p0; 606 tcu::Vec4 p1; 607 }; 608 LineRenderTestCase (Context& context, const char* name, const char* description, const ColoredLineData* linesBegin, const ColoredLineData* linesEnd, float lineWidth, const rr::WindowRectangle& viewport); 609 LineRenderTestCase (Context& context, const char* name, const char* description, const ColorlessLineData* linesBegin, const ColorlessLineData* linesEnd, float lineWidth, const rr::WindowRectangle& viewport); 610 611 virtual void verifyImage (const tcu::ConstPixelBufferAccess& testImageAccess, const tcu::ConstPixelBufferAccess& referenceImageAccess) = DE_NULL; 612 void init (void); 613 void testRender (void); 614 615 protected: 616 const float m_lineWidth; 617 618 private: 619 std::vector<ColoredLineData> convertToColoredLines (const ColorlessLineData* linesBegin, const ColorlessLineData* linesEnd); 620 621 const std::vector<ColoredLineData> m_lines; 622 const rr::WindowRectangle m_viewport; 623 }; 624 625 LineRenderTestCase::LineRenderTestCase (Context& context, const char* name, const char* description, const ColoredLineData* linesBegin, const ColoredLineData* linesEnd, float lineWidth, const rr::WindowRectangle& viewport) 626 : RenderTestCase (context, name, description) 627 , m_lineWidth (lineWidth) 628 , m_lines (linesBegin, linesEnd) 629 , m_viewport (viewport) 630 { 631 } 632 633 LineRenderTestCase::LineRenderTestCase (Context& context, const char* name, const char* description, const ColorlessLineData* linesBegin, const ColorlessLineData* linesEnd, float lineWidth, const rr::WindowRectangle& viewport) 634 : RenderTestCase (context, name, description) 635 , m_lineWidth (lineWidth) 636 , m_lines (convertToColoredLines(linesBegin, linesEnd)) 637 , m_viewport (viewport) 638 { 639 } 640 641 void LineRenderTestCase::init (void) 642 { 643 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 644 checkLineWidth (gl, m_lineWidth); 645 } 646 647 void LineRenderTestCase::testRender (void) 648 { 649 using tcu::TestLog; 650 651 const int numSamples = de::max(m_context.getRenderTarget().getNumSamples(), 1); 652 const int verticesPerLine = 2; 653 654 tcu::TestLog& log = m_testCtx.getLog(); 655 sglr::GLContext glesContext (m_context.getRenderContext(), log, 0, tcu::IVec4(0, 0, TEST_CANVAS_SIZE, TEST_CANVAS_SIZE)); 656 sglr::ReferenceContextLimits limits; 657 sglr::ReferenceContextBuffers buffers (m_context.getRenderTarget().getPixelFormat(), m_context.getRenderTarget().getDepthBits(), 0, TEST_CANVAS_SIZE, TEST_CANVAS_SIZE, numSamples); 658 sglr::ReferenceContext refContext (limits, buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer()); 659 PositionColorShader program; 660 tcu::Surface testSurface (TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 661 tcu::Surface refSurface (TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 662 sglr::Context* contexts[2] = {&glesContext, &refContext}; 663 tcu::Surface* surfaces[2] = {&testSurface, &refSurface}; 664 665 // log the purpose of the test 666 log << TestLog::Message << "Viewport: left=" << m_viewport.left << "\tbottom=" << m_viewport.bottom << "\twidth=" << m_viewport.width << "\theight=" << m_viewport.height << TestLog::EndMessage; 667 log << TestLog::Message << "Rendering lines with line width " << m_lineWidth << ". Coordinates:" << TestLog::EndMessage; 668 for (size_t ndx = 0; ndx < m_lines.size(); ++ndx) 669 { 670 const std::string fromProperties = genClippingPointInfoString(m_lines[ndx].p0); 671 const std::string toProperties = genClippingPointInfoString(m_lines[ndx].p1); 672 673 log << TestLog::Message << "\tfrom (x=" << m_lines[ndx].p0.x() << "\ty=" << m_lines[ndx].p0.y() << "\tz=" << m_lines[ndx].p0.z() << "\tw=" << m_lines[ndx].p0.w() << ")\t" << fromProperties << TestLog::EndMessage; 674 log << TestLog::Message << "\tto (x=" << m_lines[ndx].p1.x() << "\ty=" << m_lines[ndx].p1.y() << "\tz=" << m_lines[ndx].p1.z() << "\tw=" << m_lines[ndx].p1.w() << ")\t" << toProperties << TestLog::EndMessage; 675 log << TestLog::Message << TestLog::EndMessage; 676 } 677 678 // render test image 679 for (int contextNdx = 0; contextNdx < 2; ++contextNdx) 680 { 681 sglr::Context& ctx = *contexts[contextNdx]; 682 tcu::Surface& dstSurface = *surfaces[contextNdx]; 683 const deUint32 programId = ctx.createProgram(&program); 684 const GLint positionLoc = ctx.getAttribLocation(programId, "a_position"); 685 const GLint colorLoc = ctx.getAttribLocation(programId, "a_color"); 686 687 ctx.clearColor (0, 0, 0, 1); 688 ctx.clearDepthf (1.0f); 689 ctx.clear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 690 ctx.viewport (m_viewport.left, m_viewport.bottom, m_viewport.width, m_viewport.height); 691 ctx.useProgram (programId); 692 ctx.enableVertexAttribArray (positionLoc); 693 ctx.enableVertexAttribArray (colorLoc); 694 ctx.vertexAttribPointer (positionLoc, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat[8]), &m_lines[0].p0); 695 ctx.vertexAttribPointer (colorLoc, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat[8]), &m_lines[0].c0); 696 ctx.lineWidth (m_lineWidth); 697 ctx.drawArrays (GL_LINES, 0, verticesPerLine * (glw::GLsizei)m_lines.size()); 698 ctx.disableVertexAttribArray (positionLoc); 699 ctx.disableVertexAttribArray (colorLoc); 700 ctx.useProgram (0); 701 ctx.deleteProgram (programId); 702 ctx.finish (); 703 704 ctx.readPixels(dstSurface, 0, 0, TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 705 } 706 707 // compare 708 verifyImage(testSurface.getAccess(), refSurface.getAccess()); 709 } 710 711 std::vector<LineRenderTestCase::ColoredLineData> LineRenderTestCase::convertToColoredLines(const ColorlessLineData* linesBegin, const ColorlessLineData* linesEnd) 712 { 713 std::vector<ColoredLineData> ret; 714 715 for (const ColorlessLineData* it = linesBegin; it != linesEnd; ++it) 716 { 717 ColoredLineData r; 718 719 r.p0 = (*it).p0; 720 r.c0 = tcu::Vec4(1, 1, 1, 1); 721 r.p1 = (*it).p1; 722 r.c1 = tcu::Vec4(1, 1, 1, 1); 723 724 ret.push_back(r); 725 } 726 727 return ret; 728 } 729 730 class LineCase : public LineRenderTestCase 731 { 732 public: 733 LineCase (Context& context, const char* name, const char* description, const LineRenderTestCase::ColorlessLineData* linesBegin, const LineRenderTestCase::ColorlessLineData* linesEnd, float lineWidth, const rr::WindowRectangle& viewport, int searchKernelSize = 1); 734 735 void verifyImage (const tcu::ConstPixelBufferAccess& testImageAccess, const tcu::ConstPixelBufferAccess& referenceImageAccess); 736 737 private: 738 const int m_searchKernelSize; 739 }; 740 741 LineCase::LineCase (Context& context, const char* name, const char* description, const LineRenderTestCase::ColorlessLineData* linesBegin, const LineRenderTestCase::ColorlessLineData* linesEnd, float lineWidth, const rr::WindowRectangle& viewport, int searchKernelSize) 742 : LineRenderTestCase (context, name, description, linesBegin, linesEnd, lineWidth, viewport) 743 , m_searchKernelSize (searchKernelSize) 744 { 745 } 746 747 void LineCase::verifyImage (const tcu::ConstPixelBufferAccess& testImageAccess, const tcu::ConstPixelBufferAccess& referenceImageAccess) 748 { 749 const int faultyLimit = 6; 750 int faultyPixels; 751 752 const bool isMsaa = m_context.getRenderTarget().getNumSamples() > 1; 753 tcu::TestLog& log = m_testCtx.getLog(); 754 tcu::Surface diffMask (TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 755 756 log << TestLog::Message << "Comparing images... " << TestLog::EndMessage; 757 log << TestLog::Message << "Deviation within radius of " << m_searchKernelSize << " is allowed." << TestLog::EndMessage; 758 log << TestLog::Message << faultyLimit << " faulty pixels are allowed." << TestLog::EndMessage; 759 760 faultyPixels = compareBlackNonBlackImages(log, testImageAccess, referenceImageAccess, diffMask.getAccess(), m_searchKernelSize); 761 762 if (faultyPixels > faultyLimit) 763 { 764 log << TestLog::ImageSet("Images", "Image comparison") 765 << TestLog::Image("TestImage", "Test image", testImageAccess) 766 << TestLog::Image("ReferenceImage", "Reference image", referenceImageAccess) 767 << TestLog::Image("DifferenceMask", "Difference mask", diffMask.getAccess()) 768 << TestLog::EndImageSet 769 << tcu::TestLog::Message << "Got " << faultyPixels << " faulty pixel(s)." << tcu::TestLog::EndMessage; 770 771 if (m_lineWidth != 1.0f && isMsaa) 772 { 773 log << TestLog::Message << "Wide line support is optional, reporting compatibility warning." << TestLog::EndMessage; 774 m_testCtx.setTestResult(QP_TEST_RESULT_COMPATIBILITY_WARNING, "Wide line clipping failed"); 775 } 776 else 777 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got faulty pixels"); 778 } 779 } 780 781 class ColoredLineCase : public LineRenderTestCase 782 { 783 public: 784 ColoredLineCase (Context& context, const char* name, const char* description, const LineRenderTestCase::ColoredLineData* linesBegin, const LineRenderTestCase::ColoredLineData* linesEnd, float lineWidth, const rr::WindowRectangle& viewport); 785 786 void verifyImage (const tcu::ConstPixelBufferAccess& testImageAccess, const tcu::ConstPixelBufferAccess& referenceImageAccess); 787 }; 788 789 ColoredLineCase::ColoredLineCase (Context& context, const char* name, const char* description, const LineRenderTestCase::ColoredLineData* linesBegin, const LineRenderTestCase::ColoredLineData* linesEnd, float lineWidth, const rr::WindowRectangle& viewport) 790 : LineRenderTestCase (context, name, description, linesBegin, linesEnd, lineWidth, viewport) 791 { 792 } 793 794 void ColoredLineCase::verifyImage (const tcu::ConstPixelBufferAccess& testImageAccess, const tcu::ConstPixelBufferAccess& referenceImageAccess) 795 { 796 const bool msaa = m_context.getRenderTarget().getNumSamples() > 1; 797 tcu::TestLog& log = m_testCtx.getLog(); 798 799 if (!msaa) 800 { 801 const int kernelRadius = 1; 802 const int faultyLimit = 6; 803 int faultyPixels; 804 805 tcu::Surface diffMask(TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 806 807 log << TestLog::Message << "Comparing images... " << TestLog::EndMessage; 808 log << TestLog::Message << "Deviation within radius of " << kernelRadius << " is allowed." << TestLog::EndMessage; 809 log << TestLog::Message << faultyLimit << " faulty pixels are allowed." << TestLog::EndMessage; 810 811 faultyPixels = compareColoredImages(log, testImageAccess, referenceImageAccess, diffMask.getAccess(), kernelRadius); 812 813 if (faultyPixels > faultyLimit) 814 { 815 log << TestLog::ImageSet("Images", "Image comparison") 816 << TestLog::Image("TestImage", "Test image", testImageAccess) 817 << TestLog::Image("ReferenceImage", "Reference image", referenceImageAccess) 818 << TestLog::Image("DifferenceMask", "Difference mask", diffMask.getAccess()) 819 << TestLog::EndImageSet 820 << tcu::TestLog::Message << "Got " << faultyPixels << " faulty pixel(s)." << tcu::TestLog::EndMessage; 821 822 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got faulty pixels"); 823 } 824 } 825 else 826 { 827 const float threshold = 0.3f; 828 if (!tcu::fuzzyCompare(log, "Images", "", referenceImageAccess, testImageAccess, threshold, tcu::COMPARE_LOG_ON_ERROR)) 829 { 830 if (m_lineWidth != 1.0f) 831 { 832 log << TestLog::Message << "Wide line support is optional, reporting compatibility warning." << TestLog::EndMessage; 833 m_testCtx.setTestResult(QP_TEST_RESULT_COMPATIBILITY_WARNING, "Wide line clipping failed"); 834 } 835 else 836 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got faulty pixels"); 837 } 838 } 839 } 840 841 class TriangleCaseBase : public RenderTestCase 842 { 843 public: 844 struct TriangleData 845 { 846 tcu::Vec4 p0; 847 tcu::Vec4 c0; 848 tcu::Vec4 p1; 849 tcu::Vec4 c1; 850 tcu::Vec4 p2; 851 tcu::Vec4 c2; 852 }; 853 854 TriangleCaseBase (Context& context, const char* name, const char* description, const TriangleData* polysBegin, const TriangleData* polysEnd, const rr::WindowRectangle& viewport); 855 856 virtual void verifyImage (const tcu::ConstPixelBufferAccess& testImageAccess, const tcu::ConstPixelBufferAccess& referenceImageAccess) = DE_NULL; 857 void testRender (void); 858 859 private: 860 const std::vector<TriangleData> m_polys; 861 const rr::WindowRectangle m_viewport; 862 }; 863 864 TriangleCaseBase::TriangleCaseBase (Context& context, const char* name, const char* description, const TriangleData* polysBegin, const TriangleData* polysEnd, const rr::WindowRectangle& viewport) 865 : RenderTestCase(context, name, description) 866 , m_polys (polysBegin, polysEnd) 867 , m_viewport (viewport) 868 { 869 } 870 871 void TriangleCaseBase::testRender (void) 872 { 873 using tcu::TestLog; 874 875 const int numSamples = de::max(m_context.getRenderTarget().getNumSamples(), 1); 876 const int verticesPerTriangle = 3; 877 878 tcu::TestLog& log = m_testCtx.getLog(); 879 sglr::GLContext glesContext (m_context.getRenderContext(), log, 0, tcu::IVec4(0, 0, TEST_CANVAS_SIZE, TEST_CANVAS_SIZE)); 880 sglr::ReferenceContextLimits limits; 881 sglr::ReferenceContextBuffers buffers (m_context.getRenderTarget().getPixelFormat(), m_context.getRenderTarget().getDepthBits(), 0, TEST_CANVAS_SIZE, TEST_CANVAS_SIZE, numSamples); 882 sglr::ReferenceContext refContext (limits, buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer()); 883 PositionColorShader program; 884 tcu::Surface testSurface (TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 885 tcu::Surface refSurface (TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 886 sglr::Context* contexts[2] = {&glesContext, &refContext}; 887 tcu::Surface* surfaces[2] = {&testSurface, &refSurface}; 888 889 // log the purpose of the test 890 log << TestLog::Message << "Viewport: left=" << m_viewport.left << "\tbottom=" << m_viewport.bottom << "\twidth=" << m_viewport.width << "\theight=" << m_viewport.height << TestLog::EndMessage; 891 log << TestLog::Message << "Rendering triangles. Coordinates:" << TestLog::EndMessage; 892 for (size_t ndx = 0; ndx < m_polys.size(); ++ndx) 893 { 894 const std::string v0Properties = genClippingPointInfoString(m_polys[ndx].p0); 895 const std::string v1Properties = genClippingPointInfoString(m_polys[ndx].p1); 896 const std::string v2Properties = genClippingPointInfoString(m_polys[ndx].p2); 897 const std::string c0Properties = genColorString(m_polys[ndx].c0); 898 const std::string c1Properties = genColorString(m_polys[ndx].c1); 899 const std::string c2Properties = genColorString(m_polys[ndx].c2); 900 901 log << TestLog::Message << "\tv0 (x=" << m_polys[ndx].p0.x() << "\ty=" << m_polys[ndx].p0.y() << "\tz=" << m_polys[ndx].p0.z() << "\tw=" << m_polys[ndx].p0.w() << ")\t" << v0Properties << "\t" << c0Properties << TestLog::EndMessage; 902 log << TestLog::Message << "\tv1 (x=" << m_polys[ndx].p1.x() << "\ty=" << m_polys[ndx].p1.y() << "\tz=" << m_polys[ndx].p1.z() << "\tw=" << m_polys[ndx].p1.w() << ")\t" << v1Properties << "\t" << c1Properties << TestLog::EndMessage; 903 log << TestLog::Message << "\tv2 (x=" << m_polys[ndx].p2.x() << "\ty=" << m_polys[ndx].p2.y() << "\tz=" << m_polys[ndx].p2.z() << "\tw=" << m_polys[ndx].p2.w() << ")\t" << v2Properties << "\t" << c2Properties << TestLog::EndMessage; 904 log << TestLog::Message << TestLog::EndMessage; 905 } 906 907 // render test image 908 for (int contextNdx = 0; contextNdx < 2; ++contextNdx) 909 { 910 sglr::Context& ctx = *contexts[contextNdx]; 911 tcu::Surface& dstSurface = *surfaces[contextNdx]; 912 const deUint32 programId = ctx.createProgram(&program); 913 const GLint positionLoc = ctx.getAttribLocation(programId, "a_position"); 914 const GLint colorLoc = ctx.getAttribLocation(programId, "a_color"); 915 916 ctx.clearColor (0, 0, 0, 1); 917 ctx.clearDepthf (1.0f); 918 ctx.clear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 919 ctx.viewport (m_viewport.left, m_viewport.bottom, m_viewport.width, m_viewport.height); 920 ctx.useProgram (programId); 921 ctx.enableVertexAttribArray (positionLoc); 922 ctx.enableVertexAttribArray (colorLoc); 923 ctx.vertexAttribPointer (positionLoc, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat[8]), &m_polys[0].p0); 924 ctx.vertexAttribPointer (colorLoc, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat[8]), &m_polys[0].c0); 925 ctx.drawArrays (GL_TRIANGLES, 0, verticesPerTriangle * (glw::GLsizei)m_polys.size()); 926 ctx.disableVertexAttribArray (positionLoc); 927 ctx.disableVertexAttribArray (colorLoc); 928 ctx.useProgram (0); 929 ctx.deleteProgram (programId); 930 ctx.finish (); 931 932 ctx.readPixels(dstSurface, 0, 0, TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 933 } 934 935 verifyImage(testSurface.getAccess(), refSurface.getAccess()); 936 } 937 938 class TriangleCase : public TriangleCaseBase 939 { 940 public: 941 TriangleCase (Context& context, const char* name, const char* description, const TriangleData* polysBegin, const TriangleData* polysEnd, const rr::WindowRectangle& viewport); 942 943 void verifyImage (const tcu::ConstPixelBufferAccess& testImageAccess, const tcu::ConstPixelBufferAccess& referenceImageAccess); 944 }; 945 946 TriangleCase::TriangleCase (Context& context, const char* name, const char* description, const TriangleData* polysBegin, const TriangleData* polysEnd, const rr::WindowRectangle& viewport) 947 : TriangleCaseBase(context, name, description, polysBegin, polysEnd, viewport) 948 { 949 } 950 951 void TriangleCase::verifyImage (const tcu::ConstPixelBufferAccess& testImageAccess, const tcu::ConstPixelBufferAccess& referenceImageAccess) 952 { 953 const int kernelRadius = 1; 954 const int faultyLimit = 6; 955 tcu::TestLog& log = m_testCtx.getLog(); 956 tcu::Surface diffMask (TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 957 int faultyPixels; 958 959 log << TestLog::Message << "Comparing images... " << TestLog::EndMessage; 960 log << TestLog::Message << "Deviation within radius of " << kernelRadius << " is allowed." << TestLog::EndMessage; 961 log << TestLog::Message << faultyLimit << " faulty pixels are allowed." << TestLog::EndMessage; 962 963 faultyPixels = compareBlackNonBlackImages(log, testImageAccess, referenceImageAccess, diffMask.getAccess(), kernelRadius); 964 965 if (faultyPixels > faultyLimit) 966 { 967 log << TestLog::ImageSet("Images", "Image comparison") 968 << TestLog::Image("TestImage", "Test image", testImageAccess) 969 << TestLog::Image("ReferenceImage", "Reference image", referenceImageAccess) 970 << TestLog::Image("DifferenceMask", "Difference mask", diffMask.getAccess()) 971 << TestLog::EndImageSet 972 << tcu::TestLog::Message << "Got " << faultyPixels << " faulty pixel(s)." << tcu::TestLog::EndMessage; 973 974 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got faulty pixels"); 975 } 976 } 977 978 class TriangleAttributeCase : public TriangleCaseBase 979 { 980 public: 981 TriangleAttributeCase (Context& context, const char* name, const char* description, const TriangleData* polysBegin, const TriangleData* polysEnd, const rr::WindowRectangle& viewport); 982 983 void verifyImage (const tcu::ConstPixelBufferAccess& testImageAccess, const tcu::ConstPixelBufferAccess& referenceImageAccess); 984 }; 985 986 TriangleAttributeCase::TriangleAttributeCase (Context& context, const char* name, const char* description, const TriangleData* polysBegin, const TriangleData* polysEnd, const rr::WindowRectangle& viewport) 987 : TriangleCaseBase(context, name, description, polysBegin, polysEnd, viewport) 988 { 989 } 990 991 void TriangleAttributeCase::verifyImage (const tcu::ConstPixelBufferAccess& testImageAccess, const tcu::ConstPixelBufferAccess& referenceImageAccess) 992 { 993 const bool msaa = m_context.getRenderTarget().getNumSamples() > 1; 994 tcu::TestLog& log = m_testCtx.getLog(); 995 996 if (!msaa) 997 { 998 const int kernelRadius = 1; 999 const int faultyLimit = 6; 1000 int faultyPixels; 1001 tcu::Surface diffMask (TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 1002 1003 log << TestLog::Message << "Comparing images... " << TestLog::EndMessage; 1004 log << TestLog::Message << "Deviation within radius of " << kernelRadius << " is allowed." << TestLog::EndMessage; 1005 log << TestLog::Message << faultyLimit << " faulty pixels are allowed." << TestLog::EndMessage; 1006 faultyPixels = compareColoredImages(log, testImageAccess, referenceImageAccess, diffMask.getAccess(), kernelRadius); 1007 1008 if (faultyPixels > faultyLimit) 1009 { 1010 log << TestLog::ImageSet("Images", "Image comparison") 1011 << TestLog::Image("TestImage", "Test image", testImageAccess) 1012 << TestLog::Image("ReferenceImage", "Reference image", referenceImageAccess) 1013 << TestLog::Image("DifferenceMask", "Difference mask", diffMask.getAccess()) 1014 << TestLog::EndImageSet 1015 << tcu::TestLog::Message << "Got " << faultyPixels << " faulty pixel(s)." << tcu::TestLog::EndMessage; 1016 1017 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got faulty pixels"); 1018 } 1019 } 1020 else 1021 { 1022 const float threshold = 0.3f; 1023 if (!tcu::fuzzyCompare(log, "Images", "", referenceImageAccess, testImageAccess, threshold, tcu::COMPARE_LOG_ON_ERROR)) 1024 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got faulty pixels"); 1025 } 1026 } 1027 1028 class FillTest : public RenderTestCase 1029 { 1030 public: 1031 FillTest (Context& context, const char* name, const char* description, const rr::WindowRectangle& viewport); 1032 1033 virtual void render (sglr::Context& ctx) = DE_NULL; 1034 void testRender (void); 1035 1036 protected: 1037 const rr::WindowRectangle m_viewport; 1038 }; 1039 1040 FillTest::FillTest (Context& context, const char* name, const char* description, const rr::WindowRectangle& viewport) 1041 : RenderTestCase(context, name, description) 1042 , m_viewport (viewport) 1043 { 1044 } 1045 1046 void FillTest::testRender (void) 1047 { 1048 using tcu::TestLog; 1049 1050 const int numSamples = 1; 1051 1052 tcu::TestLog& log = m_testCtx.getLog(); 1053 sglr::GLContext glesContext (m_context.getRenderContext(), log, 0, tcu::IVec4(0, 0, TEST_CANVAS_SIZE, TEST_CANVAS_SIZE)); 1054 sglr::ReferenceContextLimits limits; 1055 sglr::ReferenceContextBuffers buffers (m_context.getRenderTarget().getPixelFormat(), m_context.getRenderTarget().getDepthBits(), 0, TEST_CANVAS_SIZE, TEST_CANVAS_SIZE, numSamples); 1056 sglr::ReferenceContext refContext (limits, buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer()); 1057 tcu::Surface testSurface (TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 1058 tcu::Surface refSurface (TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 1059 1060 render(glesContext); 1061 glesContext.readPixels(testSurface, 0, 0, TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 1062 1063 render(refContext); 1064 refContext.readPixels(refSurface, 0, 0, TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 1065 1066 // check overdraw 1067 { 1068 bool overdrawOk; 1069 tcu::Surface outputImage(TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 1070 1071 log << TestLog::Message << "Checking for overdraw " << TestLog::EndMessage; 1072 overdrawOk = checkHalfFilledImageOverdraw(log, m_context.getRenderTarget(), testSurface.getAccess(), outputImage.getAccess()); 1073 1074 if (!overdrawOk) 1075 { 1076 log << TestLog::ImageSet("Images", "Image comparison") 1077 << TestLog::Image("TestImage", "Test image", testSurface.getAccess()) 1078 << TestLog::Image("InvalidPixels", "Invalid pixels", outputImage.getAccess()) 1079 << TestLog::EndImageSet 1080 << tcu::TestLog::Message << "Got overdraw." << tcu::TestLog::EndMessage; 1081 1082 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got overdraw"); 1083 } 1084 } 1085 1086 // compare & check missing pixels 1087 { 1088 const int kernelRadius = 1; 1089 tcu::Surface diffMask (TEST_CANVAS_SIZE, TEST_CANVAS_SIZE); 1090 int faultyPixels; 1091 1092 log << TestLog::Message << "Comparing images... " << TestLog::EndMessage; 1093 log << TestLog::Message << "Deviation within radius of " << kernelRadius << " is allowed." << TestLog::EndMessage; 1094 1095 blitImageOnBlackSurface(refSurface.getAccess(), refSurface.getAccess()); // makes images look right in Candy 1096 1097 faultyPixels = compareBlackNonBlackImages(log, testSurface.getAccess(), refSurface.getAccess(), diffMask.getAccess(), kernelRadius); 1098 1099 if (faultyPixels > 0) 1100 { 1101 log << TestLog::ImageSet("Images", "Image comparison") 1102 << TestLog::Image("TestImage", "Test image", testSurface.getAccess()) 1103 << TestLog::Image("ReferenceImage", "Reference image", refSurface.getAccess()) 1104 << TestLog::Image("DifferenceMask", "Difference mask", diffMask.getAccess()) 1105 << TestLog::EndImageSet 1106 << tcu::TestLog::Message << "Got " << faultyPixels << " faulty pixel(s)." << tcu::TestLog::EndMessage; 1107 1108 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got faulty pixels"); 1109 } 1110 } 1111 } 1112 1113 class TriangleFillTest : public FillTest 1114 { 1115 public: 1116 struct FillTriangle 1117 { 1118 tcu::Vec4 v0; 1119 tcu::Vec4 c0; 1120 tcu::Vec4 v1; 1121 tcu::Vec4 c1; 1122 tcu::Vec4 v2; 1123 tcu::Vec4 c2; 1124 }; 1125 1126 TriangleFillTest (Context& context, const char* name, const char* description, const rr::WindowRectangle& viewport); 1127 1128 void render (sglr::Context& ctx); 1129 1130 protected: 1131 std::vector<FillTriangle> m_triangles; 1132 }; 1133 1134 TriangleFillTest::TriangleFillTest (Context& context, const char* name, const char* description, const rr::WindowRectangle& viewport) 1135 : FillTest(context, name, description, viewport) 1136 { 1137 } 1138 1139 void TriangleFillTest::render (sglr::Context& ctx) 1140 { 1141 const int verticesPerTriangle = 3; 1142 PositionColorShader program; 1143 const deUint32 programId = ctx.createProgram(&program); 1144 const GLint positionLoc = ctx.getAttribLocation(programId, "a_position"); 1145 const GLint colorLoc = ctx.getAttribLocation(programId, "a_color"); 1146 tcu::TestLog& log = m_testCtx.getLog(); 1147 1148 // log the purpose of the test 1149 log << TestLog::Message << "Viewport: left=" << m_viewport.left << "\tbottom=" << m_viewport.bottom << "\twidth=" << m_viewport.width << "\theight=" << m_viewport.height << TestLog::EndMessage; 1150 log << TestLog::Message << "Rendering triangles. Coordinates:" << TestLog::EndMessage; 1151 for (size_t ndx = 0; ndx < m_triangles.size(); ++ndx) 1152 { 1153 const std::string v0Properties = genClippingPointInfoString(m_triangles[ndx].v0); 1154 const std::string v1Properties = genClippingPointInfoString(m_triangles[ndx].v1); 1155 const std::string v2Properties = genClippingPointInfoString(m_triangles[ndx].v2); 1156 1157 log << TestLog::Message << "\tv0 (x=" << m_triangles[ndx].v0.x() << "\ty=" << m_triangles[ndx].v0.y() << "\tz=" << m_triangles[ndx].v0.z() << "\tw=" << m_triangles[ndx].v0.w() << ")\t" << v0Properties << TestLog::EndMessage; 1158 log << TestLog::Message << "\tv1 (x=" << m_triangles[ndx].v1.x() << "\ty=" << m_triangles[ndx].v1.y() << "\tz=" << m_triangles[ndx].v1.z() << "\tw=" << m_triangles[ndx].v1.w() << ")\t" << v1Properties << TestLog::EndMessage; 1159 log << TestLog::Message << "\tv2 (x=" << m_triangles[ndx].v2.x() << "\ty=" << m_triangles[ndx].v2.y() << "\tz=" << m_triangles[ndx].v2.z() << "\tw=" << m_triangles[ndx].v2.w() << ")\t" << v2Properties << TestLog::EndMessage; 1160 log << TestLog::Message << TestLog::EndMessage; 1161 } 1162 1163 ctx.clearColor (0, 0, 0, 1); 1164 ctx.clearDepthf (1.0f); 1165 ctx.clear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 1166 ctx.viewport (m_viewport.left, m_viewport.bottom, m_viewport.width, m_viewport.height); 1167 ctx.useProgram (programId); 1168 ctx.blendFunc (GL_ONE, GL_ONE); 1169 ctx.enable (GL_BLEND); 1170 ctx.enableVertexAttribArray (positionLoc); 1171 ctx.enableVertexAttribArray (colorLoc); 1172 ctx.vertexAttribPointer (positionLoc, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat[8]), &m_triangles[0].v0); 1173 ctx.vertexAttribPointer (colorLoc, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat[8]), &m_triangles[0].c0); 1174 ctx.drawArrays (GL_TRIANGLES, 0, verticesPerTriangle * (glw::GLsizei)m_triangles.size()); 1175 ctx.disableVertexAttribArray (positionLoc); 1176 ctx.disableVertexAttribArray (colorLoc); 1177 ctx.useProgram (0); 1178 ctx.deleteProgram (programId); 1179 ctx.finish (); 1180 } 1181 1182 class QuadFillTest : public TriangleFillTest 1183 { 1184 public: 1185 QuadFillTest (Context& context, const char* name, const char* description, const rr::WindowRectangle& viewport, const tcu::Vec3& d1, const tcu::Vec3& d2, const tcu::Vec3& center_ = tcu::Vec3(0, 0, 0)); 1186 }; 1187 1188 QuadFillTest::QuadFillTest (Context& context, const char* name, const char* description, const rr::WindowRectangle& viewport, const tcu::Vec3& d1, const tcu::Vec3& d2, const tcu::Vec3& center_) 1189 : TriangleFillTest(context, name, description, viewport) 1190 { 1191 const float radius = 40000.0f; 1192 const tcu::Vec4 center = tcu::Vec4(center_.x(), center_.y(), center_.z(), 1.0f); 1193 const tcu::Vec4 halfWhite = tcu::Vec4(0.5f, 0.5f, 0.5f, 0.5f); 1194 const tcu::Vec4 halfRed = tcu::Vec4(0.5f, 0.0f, 0.0f, 0.5f); 1195 const tcu::Vec4 e1 = radius * tcu::Vec4(d1.x(), d1.y(), d1.z(), 0.0f); 1196 const tcu::Vec4 e2 = radius * tcu::Vec4(d2.x(), d2.y(), d2.z(), 0.0f); 1197 1198 FillTriangle triangle1; 1199 FillTriangle triangle2; 1200 1201 triangle1.c0 = halfWhite; 1202 triangle1.c1 = halfWhite; 1203 triangle1.c2 = halfWhite; 1204 triangle1.v0 = center + e1 + e2; 1205 triangle1.v1 = center + e1 - e2; 1206 triangle1.v2 = center - e1 - e2; 1207 m_triangles.push_back(triangle1); 1208 1209 triangle2.c0 = halfRed; 1210 triangle2.c1 = halfRed; 1211 triangle2.c2 = halfRed; 1212 triangle2.v0 = center + e1 + e2; 1213 triangle2.v1 = center - e1 - e2; 1214 triangle2.v2 = center - e1 + e2; 1215 m_triangles.push_back(triangle2); 1216 } 1217 1218 class TriangleFanFillTest : public TriangleFillTest 1219 { 1220 public: 1221 TriangleFanFillTest (Context& context, const char* name, const char* description, const rr::WindowRectangle& viewport); 1222 }; 1223 1224 TriangleFanFillTest::TriangleFanFillTest (Context& context, const char* name, const char* description, const rr::WindowRectangle& viewport) 1225 : TriangleFillTest(context, name, description, viewport) 1226 { 1227 const float radius = 70000.0f; 1228 const int trianglesPerVisit = 40; 1229 const tcu::Vec4 center = tcu::Vec4(0, 0, 0, 1.0f); 1230 const tcu::Vec4 halfWhite = tcu::Vec4(0.5f, 0.5f, 0.5f, 0.5f); 1231 const tcu::Vec4 oddSliceColor = tcu::Vec4(0.0f, 0.0f, 0.5f, 0.0f); 1232 1233 // create a continuous surface that goes through all 6 clip planes 1234 1235 /* 1236 * / / 1237 * /_ _ _ _ _ /x 1238 * | | | 1239 * | | / 1240 * | / --xe / 1241 * | | | / 1242 * |_ _ _ e _ _|/ 1243 * 1244 * e = enter 1245 * x = exit 1246 */ 1247 const struct ClipPlaneVisit 1248 { 1249 const tcu::Vec3 corner; 1250 const tcu::Vec3 entryPoint; 1251 const tcu::Vec3 exitPoint; 1252 } visits[] = 1253 { 1254 { tcu::Vec3( 1, 1, 1), tcu::Vec3( 0, 1, 1), tcu::Vec3( 1, 0, 1) }, 1255 { tcu::Vec3( 1,-1, 1), tcu::Vec3( 1, 0, 1), tcu::Vec3( 1,-1, 0) }, 1256 { tcu::Vec3( 1,-1,-1), tcu::Vec3( 1,-1, 0), tcu::Vec3( 0,-1,-1) }, 1257 { tcu::Vec3(-1,-1,-1), tcu::Vec3( 0,-1,-1), tcu::Vec3(-1, 0,-1) }, 1258 { tcu::Vec3(-1, 1,-1), tcu::Vec3(-1, 0,-1), tcu::Vec3(-1, 1, 0) }, 1259 { tcu::Vec3(-1, 1, 1), tcu::Vec3(-1, 1, 0), tcu::Vec3( 0, 1, 1) }, 1260 }; 1261 1262 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(visits); ++ndx) 1263 { 1264 const ClipPlaneVisit& visit = visits[ndx]; 1265 1266 for (int tri = 0; tri < trianglesPerVisit; ++tri) 1267 { 1268 tcu::Vec3 vertex0; 1269 tcu::Vec3 vertex1; 1270 1271 if (tri == 0) // first vertex is magic 1272 { 1273 vertex0 = visit.entryPoint; 1274 } 1275 else 1276 { 1277 const tcu::Vec3 v1 = visit.entryPoint - visit.corner; 1278 const tcu::Vec3 v2 = visit.exitPoint - visit.corner; 1279 1280 vertex0 = visit.corner + tcu::normalize(tcu::mix(v1, v2, tcu::Vec3(float(tri)/trianglesPerVisit))); 1281 } 1282 1283 if (tri == trianglesPerVisit-1) // last vertex is magic 1284 { 1285 vertex1 = visit.exitPoint; 1286 } 1287 else 1288 { 1289 const tcu::Vec3 v1 = visit.entryPoint - visit.corner; 1290 const tcu::Vec3 v2 = visit.exitPoint - visit.corner; 1291 1292 vertex1 = visit.corner + tcu::normalize(tcu::mix(v1, v2, tcu::Vec3(float(tri+1)/trianglesPerVisit))); 1293 } 1294 1295 // write vec out 1296 { 1297 FillTriangle triangle; 1298 1299 triangle.c0 = (tri % 2) ? halfWhite : halfWhite + oddSliceColor; 1300 triangle.c1 = (tri % 2) ? halfWhite : halfWhite + oddSliceColor; 1301 triangle.c2 = (tri % 2) ? halfWhite : halfWhite + oddSliceColor; 1302 triangle.v0 = center; 1303 triangle.v1 = tcu::Vec4(vertex0.x() * radius, vertex0.y() * radius, vertex0.z() * radius, 1.0f); 1304 triangle.v2 = tcu::Vec4(vertex1.x() * radius, vertex1.y() * radius, vertex1.z() * radius, 1.0f); 1305 1306 m_triangles.push_back(triangle); 1307 } 1308 1309 } 1310 } 1311 } 1312 1313 class PointsTestGroup : public TestCaseGroup 1314 { 1315 public: 1316 PointsTestGroup (Context& context); 1317 1318 void init (void); 1319 }; 1320 1321 PointsTestGroup::PointsTestGroup (Context& context) 1322 : TestCaseGroup(context, "point", "Point clipping tests") 1323 { 1324 } 1325 1326 void PointsTestGroup::init (void) 1327 { 1328 const float littleOverViewport = 1.0f + (2.0f / (TEST_CANVAS_SIZE)); // one pixel over the viewport edge in VIEWPORT_WHOLE, half pixels over in the reduced viewport. 1329 1330 const tcu::Vec4 viewportTestPoints[] = 1331 { 1332 // in clip volume 1333 tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), 1334 tcu::Vec4( 0.1f, 0.1f, 0.1f, 1.0f), 1335 tcu::Vec4(-0.1f, 0.1f, -0.1f, 1.0f), 1336 tcu::Vec4(-0.1f, -0.1f, 0.1f, 1.0f), 1337 tcu::Vec4( 0.1f, -0.1f, -0.1f, 1.0f), 1338 1339 // in clip volume with w != 1 1340 tcu::Vec4( 2.0f, 2.0f, 2.0f, 3.0f), 1341 tcu::Vec4(-2.0f, -2.0f, 2.0f, 3.0f), 1342 tcu::Vec4( 0.5f, -0.5f, 0.5f, 0.7f), 1343 tcu::Vec4(-0.5f, 0.5f, -0.5f, 0.7f), 1344 1345 // near the edge 1346 tcu::Vec4(-2.0f, -2.0f, 0.0f, 2.2f), 1347 tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.1f), 1348 tcu::Vec4(-1.0f, 1.0f, 0.0f, 1.1f), 1349 1350 // not in the volume but still between near and far planes 1351 tcu::Vec4( 1.3f, 0.0f, 0.0f, 1.0f), 1352 tcu::Vec4(-1.3f, 0.0f, 0.0f, 1.0f), 1353 tcu::Vec4( 0.0f, 1.3f, 0.0f, 1.0f), 1354 tcu::Vec4( 0.0f, -1.3f, 0.0f, 1.0f), 1355 1356 tcu::Vec4(-1.3f, -1.3f, 0.0f, 1.0f), 1357 tcu::Vec4(-1.3f, 1.3f, 0.0f, 1.0f), 1358 tcu::Vec4( 1.3f, 1.3f, 0.0f, 1.0f), 1359 tcu::Vec4( 1.3f, -1.3f, 0.0f, 1.0f), 1360 1361 // outside the viewport, wide points have fragments in the viewport 1362 tcu::Vec4( littleOverViewport, littleOverViewport, 0.0f, 1.0f), 1363 tcu::Vec4( 0.0f, littleOverViewport, 0.0f, 1.0f), 1364 tcu::Vec4( littleOverViewport, 0.0f, 0.0f, 1.0f), 1365 }; 1366 const tcu::Vec4 depthTestPoints[] = 1367 { 1368 // in clip volume 1369 tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), 1370 tcu::Vec4( 0.1f, 0.1f, 0.1f, 1.0f), 1371 tcu::Vec4(-0.1f, 0.1f, -0.1f, 1.0f), 1372 tcu::Vec4(-0.1f, -0.1f, 0.1f, 1.0f), 1373 tcu::Vec4( 0.1f, -0.1f, -0.1f, 1.0f), 1374 1375 // not between the near and the far planes. These should be clipped 1376 tcu::Vec4( 0.1f, 0.0f, 1.1f, 1.0f), 1377 tcu::Vec4(-0.1f, 0.0f, -1.1f, 1.0f), 1378 tcu::Vec4(-0.0f, -0.1f, 1.1f, 1.0f), 1379 tcu::Vec4( 0.0f, 0.1f, -1.1f, 1.0f) 1380 }; 1381 1382 addChild(new PointCase(m_context, "point_z_clip", "point z clipping", DE_ARRAY_BEGIN(depthTestPoints), DE_ARRAY_END(depthTestPoints), 1.0f, VIEWPORT_WHOLE)); 1383 addChild(new PointCase(m_context, "point_z_clip_viewport_center", "point z clipping", DE_ARRAY_BEGIN(depthTestPoints), DE_ARRAY_END(depthTestPoints), 1.0f, VIEWPORT_CENTER)); 1384 addChild(new PointCase(m_context, "point_z_clip_viewport_corner", "point z clipping", DE_ARRAY_BEGIN(depthTestPoints), DE_ARRAY_END(depthTestPoints), 1.0f, VIEWPORT_CORNER)); 1385 1386 addChild(new PointCase(m_context, "point_clip_viewport_center", "point viewport clipping", DE_ARRAY_BEGIN(viewportTestPoints), DE_ARRAY_END(viewportTestPoints), 1.0f, VIEWPORT_CENTER)); 1387 addChild(new PointCase(m_context, "point_clip_viewport_corner", "point viewport clipping", DE_ARRAY_BEGIN(viewportTestPoints), DE_ARRAY_END(viewportTestPoints), 1.0f, VIEWPORT_CORNER)); 1388 1389 addChild(new PointCase(m_context, "wide_point_z_clip", "point z clipping", DE_ARRAY_BEGIN(depthTestPoints), DE_ARRAY_END(depthTestPoints), 5.0f, VIEWPORT_WHOLE)); 1390 addChild(new PointCase(m_context, "wide_point_z_clip_viewport_center", "point z clipping", DE_ARRAY_BEGIN(depthTestPoints), DE_ARRAY_END(depthTestPoints), 5.0f, VIEWPORT_CENTER)); 1391 addChild(new PointCase(m_context, "wide_point_z_clip_viewport_corner", "point z clipping", DE_ARRAY_BEGIN(depthTestPoints), DE_ARRAY_END(depthTestPoints), 5.0f, VIEWPORT_CORNER)); 1392 1393 addChild(new PointCase(m_context, "wide_point_clip", "point viewport clipping", DE_ARRAY_BEGIN(viewportTestPoints), DE_ARRAY_END(viewportTestPoints), 5.0f, VIEWPORT_WHOLE)); 1394 addChild(new PointCase(m_context, "wide_point_clip_viewport_center", "point viewport clipping", DE_ARRAY_BEGIN(viewportTestPoints), DE_ARRAY_END(viewportTestPoints), 5.0f, VIEWPORT_CENTER)); 1395 addChild(new PointCase(m_context, "wide_point_clip_viewport_corner", "point viewport clipping", DE_ARRAY_BEGIN(viewportTestPoints), DE_ARRAY_END(viewportTestPoints), 5.0f, VIEWPORT_CORNER)); 1396 } 1397 1398 class LinesTestGroup : public TestCaseGroup 1399 { 1400 public: 1401 LinesTestGroup (Context& context); 1402 1403 void init (void); 1404 }; 1405 1406 LinesTestGroup::LinesTestGroup (Context& context) 1407 : TestCaseGroup(context, "line", "Line clipping tests") 1408 { 1409 } 1410 1411 void LinesTestGroup::init (void) 1412 { 1413 const float littleOverViewport = 1.0f + (2.0f / (TEST_CANVAS_SIZE)); // one pixel over the viewport edge in VIEWPORT_WHOLE, half pixels over in the reduced viewport. 1414 1415 // lines 1416 const LineRenderTestCase::ColorlessLineData viewportTestLines[] = 1417 { 1418 // from center to outside of viewport 1419 {tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4( 0.0f, 1.5f, 0.0f, 1.0f)}, 1420 {tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4(-1.5f, 1.0f, 0.0f, 1.0f)}, 1421 {tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4(-1.5f, 0.0f, 0.0f, 1.0f)}, 1422 {tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4( 0.2f, 0.4f, 1.5f, 1.0f)}, 1423 {tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4(-2.0f, -1.0f, 0.0f, 1.0f)}, 1424 {tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4( 1.0f, 0.1f, 0.0f, 0.6f)}, 1425 1426 // from outside to inside of viewport 1427 {tcu::Vec4( 1.5f, 0.0f, 0.0f, 1.0f), tcu::Vec4( 0.8f, -0.2f, 0.0f, 1.0f)}, 1428 {tcu::Vec4( 0.0f, -1.5f, 0.0f, 1.0f), tcu::Vec4( 0.9f, -0.7f, 0.0f, 1.0f)}, 1429 1430 // from outside to outside 1431 {tcu::Vec4( 0.0f, -1.3f, 0.0f, 1.0f), tcu::Vec4( 1.3f, 0.0f, 0.0f, 1.0f)}, 1432 1433 // outside the viewport, wide lines have fragments in the viewport 1434 {tcu::Vec4(-0.8f, -littleOverViewport, 0.0f, 1.0f), tcu::Vec4( 0.0f, -littleOverViewport, 0.0f, 1.0f)}, 1435 {tcu::Vec4(-littleOverViewport - 1.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4( 0.0f, -littleOverViewport - 1.0f, 0.0f, 1.0f)}, 1436 }; 1437 const LineRenderTestCase::ColorlessLineData depthTestLines[] = 1438 { 1439 {tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4( 1.3f, 1.0f, 2.0f, 1.0f)}, 1440 {tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4( 1.3f, -1.0f, 2.0f, 1.0f)}, 1441 {tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4(-1.0f, -1.1f, -2.0f, 1.0f)}, 1442 {tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4(-1.0f, 1.1f, -2.0f, 1.0f)}, 1443 {tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4( 1.0f, 0.1f, 2.0f, 0.6f)}, 1444 }; 1445 const LineRenderTestCase::ColorlessLineData longTestLines[] = 1446 { 1447 {tcu::Vec4( -41000.0f, -40000.0f, -1000000.0f, 1.0f), tcu::Vec4( 41000.0f, 40000.0f, 1000000.0f, 1.0f)}, 1448 {tcu::Vec4( 41000.0f, -40000.0f, 1000000.0f, 1.0f), tcu::Vec4(-41000.0f, 40000.0f, -1000000.0f, 1.0f)}, 1449 {tcu::Vec4( 0.5f, -40000.0f, 100000.0f, 1.0f), tcu::Vec4( 0.5f, 40000.0f, -100000.0f, 1.0f)}, 1450 {tcu::Vec4( -0.5f, 40000.0f, 100000.0f, 1.0f), tcu::Vec4(-0.5f, -40000.0f, -100000.0f, 1.0f)}, 1451 }; 1452 1453 // line attribute clipping 1454 const tcu::Vec4 red (1.0f, 0.0f, 0.0f, 1.0f); 1455 const tcu::Vec4 yellow (1.0f, 1.0f, 0.0f, 1.0f); 1456 const tcu::Vec4 lightBlue (0.3f, 0.3f, 1.0f, 1.0f); 1457 const LineRenderTestCase::ColoredLineData colorTestLines[] = 1458 { 1459 {tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), red, tcu::Vec4( 1.3f, 1.0f, 2.0f, 1.0f), yellow }, 1460 {tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), red, tcu::Vec4( 1.3f, -1.0f, 2.0f, 1.0f), lightBlue }, 1461 {tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), red, tcu::Vec4(-1.0f, -1.0f, -2.0f, 1.0f), yellow }, 1462 {tcu::Vec4( 0.0f, 0.0f, 0.0f, 1.0f), red, tcu::Vec4(-1.0f, 1.0f, -2.0f, 1.0f), lightBlue }, 1463 }; 1464 1465 // line clipping 1466 addChild(new LineCase(m_context, "line_z_clip", "line z clipping", DE_ARRAY_BEGIN(depthTestLines), DE_ARRAY_END(depthTestLines), 1.0f, VIEWPORT_WHOLE)); 1467 addChild(new LineCase(m_context, "line_z_clip_viewport_center", "line z clipping", DE_ARRAY_BEGIN(depthTestLines), DE_ARRAY_END(depthTestLines), 1.0f, VIEWPORT_CENTER)); 1468 addChild(new LineCase(m_context, "line_z_clip_viewport_corner", "line z clipping", DE_ARRAY_BEGIN(depthTestLines), DE_ARRAY_END(depthTestLines), 1.0f, VIEWPORT_CORNER)); 1469 1470 addChild(new LineCase(m_context, "line_clip_viewport_center", "line viewport clipping", DE_ARRAY_BEGIN(viewportTestLines), DE_ARRAY_END(viewportTestLines), 1.0f, VIEWPORT_CENTER)); 1471 addChild(new LineCase(m_context, "line_clip_viewport_corner", "line viewport clipping", DE_ARRAY_BEGIN(viewportTestLines), DE_ARRAY_END(viewportTestLines), 1.0f, VIEWPORT_CORNER)); 1472 1473 addChild(new LineCase(m_context, "wide_line_z_clip", "line z clipping", DE_ARRAY_BEGIN(depthTestLines), DE_ARRAY_END(depthTestLines), 5.0f, VIEWPORT_WHOLE)); 1474 addChild(new LineCase(m_context, "wide_line_z_clip_viewport_center", "line z clipping", DE_ARRAY_BEGIN(depthTestLines), DE_ARRAY_END(depthTestLines), 5.0f, VIEWPORT_CENTER)); 1475 addChild(new LineCase(m_context, "wide_line_z_clip_viewport_corner", "line z clipping", DE_ARRAY_BEGIN(depthTestLines), DE_ARRAY_END(depthTestLines), 5.0f, VIEWPORT_CORNER)); 1476 1477 addChild(new LineCase(m_context, "wide_line_clip", "line viewport clipping", DE_ARRAY_BEGIN(viewportTestLines), DE_ARRAY_END(viewportTestLines), 5.0f, VIEWPORT_WHOLE)); 1478 addChild(new LineCase(m_context, "wide_line_clip_viewport_center", "line viewport clipping", DE_ARRAY_BEGIN(viewportTestLines), DE_ARRAY_END(viewportTestLines), 5.0f, VIEWPORT_CENTER)); 1479 addChild(new LineCase(m_context, "wide_line_clip_viewport_corner", "line viewport clipping", DE_ARRAY_BEGIN(viewportTestLines), DE_ARRAY_END(viewportTestLines), 5.0f, VIEWPORT_CORNER)); 1480 1481 addChild(new LineCase(m_context, "long_line_clip", "line viewport clipping", DE_ARRAY_BEGIN(longTestLines), DE_ARRAY_END(longTestLines), 1.0f, VIEWPORT_WHOLE, 2)); 1482 addChild(new LineCase(m_context, "long_wide_line_clip", "line viewport clipping", DE_ARRAY_BEGIN(longTestLines), DE_ARRAY_END(longTestLines), 5.0f, VIEWPORT_WHOLE, 2)); 1483 1484 // line attribute clipping 1485 addChild(new ColoredLineCase(m_context, "line_attrib_clip", "line attribute clipping", DE_ARRAY_BEGIN(colorTestLines), DE_ARRAY_END(colorTestLines), 1.0f, VIEWPORT_WHOLE)); 1486 addChild(new ColoredLineCase(m_context, "wide_line_attrib_clip", "line attribute clipping", DE_ARRAY_BEGIN(colorTestLines), DE_ARRAY_END(colorTestLines), 5.0f, VIEWPORT_WHOLE)); 1487 } 1488 1489 class PolysTestGroup : public TestCaseGroup 1490 { 1491 public: 1492 PolysTestGroup (Context& context); 1493 1494 void init (void); 1495 }; 1496 1497 PolysTestGroup::PolysTestGroup (Context& context) 1498 : TestCaseGroup(context, "polygon", "Polygon clipping tests") 1499 { 1500 } 1501 1502 void PolysTestGroup::init (void) 1503 { 1504 const float large = 100000.0f; 1505 const float offset = 0.9f; 1506 const tcu::Vec4 white (1.0f, 1.0f, 1.0f, 1.0f); 1507 const tcu::Vec4 red (1.0f, 0.0f, 0.0f, 1.0f); 1508 const tcu::Vec4 yellow (1.0f, 1.0f, 0.0f, 1.0f); 1509 const tcu::Vec4 blue (0.0f, 0.0f, 1.0f, 1.0f); 1510 1511 // basic cases 1512 { 1513 const TriangleCase::TriangleData viewportPolys[] = 1514 { 1515 // one vertex clipped 1516 {tcu::Vec4(-0.8f, -0.2f, 0.0f, 1.0f), white, tcu::Vec4(-0.8f, 0.2f, 0.0f, 1.0f), white, tcu::Vec4(-1.3f, 0.05f, 0.0f, 1.0f), white}, 1517 1518 // two vertices clipped 1519 {tcu::Vec4(-0.6f, -1.2f, 0.0f, 1.0f), white, tcu::Vec4(-1.2f, -0.6f, 0.0f, 1.0f), white, tcu::Vec4(-0.6f, -0.6f, 0.0f, 1.0f), white}, 1520 1521 // three vertices clipped 1522 {tcu::Vec4(-1.1f, 0.6f, 0.0f, 1.0f), white, tcu::Vec4(-1.1f, 1.1f, 0.0f, 1.0f), white, tcu::Vec4(-0.6f, 1.1f, 0.0f, 1.0f), white}, 1523 {tcu::Vec4( 0.8f, 1.1f, 0.0f, 1.0f), white, tcu::Vec4( 0.95f,-1.1f, 0.0f, 1.0f), white, tcu::Vec4( 3.0f, 0.0f, 0.0f, 1.0f), white}, 1524 }; 1525 const TriangleCase::TriangleData depthPolys[] = 1526 { 1527 // one vertex clipped to Z+ 1528 {tcu::Vec4(-0.2f, 0.7f, 0.0f, 1.0f), white, tcu::Vec4( 0.2f, 0.7f, 0.0f, 1.0f), white, tcu::Vec4( 0.0f, 0.9f, 2.0f, 1.0f), white}, 1529 1530 // two vertices clipped to Z- 1531 {tcu::Vec4( 0.9f, 0.4f, -1.5f, 1.0f), white, tcu::Vec4( 0.9f, -0.4f, -1.5f, 1.0f), white, tcu::Vec4( 0.6f, 0.0f, 0.0f, 1.0f), white}, 1532 1533 // three vertices clipped 1534 {tcu::Vec4(-0.9f, 0.6f, -2.0f, 1.0f), white, tcu::Vec4(-0.9f, -0.6f, -2.0f, 1.0f), white, tcu::Vec4(-0.4f, 0.0f, 2.0f, 1.0f), white}, 1535 1536 // three vertices clipped by X, Y and Z 1537 {tcu::Vec4( 0.0f, -1.2f, 0.0f, 1.0f), white, tcu::Vec4( 0.0f, 0.5f, -1.5f, 1.0f), white, tcu::Vec4( 1.2f, -0.9f, 0.0f, 1.0f), white}, 1538 }; 1539 const TriangleCase::TriangleData largePolys[] = 1540 { 1541 // one vertex clipped 1542 {tcu::Vec4(-0.2f, -0.3f, 0.0f, 1.0f), white, tcu::Vec4( 0.2f, -0.3f, 0.0f, 1.0f), white, tcu::Vec4( 0.0f, -large, 2.0f, 1.0f), white}, 1543 1544 // two vertices clipped 1545 {tcu::Vec4( 0.5f, 0.5f, 0.0f, 1.0f), white, tcu::Vec4( large, 0.5f, 0.0f, 1.0f), white, tcu::Vec4( 0.5f, large, 0.0f, 1.0f), white}, 1546 1547 // three vertices clipped 1548 {tcu::Vec4(-0.9f, -large, 0.0f, 1.0f), white, tcu::Vec4(-1.1f, -large, 0.0f, 1.0f), white, tcu::Vec4(-0.9f, large, 0.0f, 1.0f), white}, 1549 }; 1550 const TriangleCase::TriangleData largeDepthPolys[] = 1551 { 1552 // one vertex clipped 1553 {tcu::Vec4(-0.2f, -0.3f, 0.0f, 1.0f), white, tcu::Vec4( 0.2f, -0.3f, 0.0f, 1.0f), white, tcu::Vec4( 0.0f, -large, large, 1.0f), white}, 1554 1555 // two vertices clipped 1556 {tcu::Vec4( 0.5f, 0.5f, 0.0f, 1.0f), white, tcu::Vec4( 0.9f, large/2, -large, 1.0f), white, tcu::Vec4( large/4, 0.0f, -large, 1.0f), white}, 1557 1558 // three vertices clipped 1559 {tcu::Vec4(-0.9f, large/4, large, 1.0f), white, tcu::Vec4(-0.5f, -large/4, -large, 1.0f), white, tcu::Vec4(-0.2f, large/4, large, 1.0f), white}, 1560 }; 1561 const TriangleCase::TriangleData attribPolys[] = 1562 { 1563 // one vertex clipped to edge, large 1564 {tcu::Vec4(-0.2f, -0.3f, 0.0f, 1.0f), red, tcu::Vec4( 0.2f, -0.3f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.0f, -large, 2.0f, 1.0f), blue}, 1565 1566 // two vertices clipped to edges 1567 {tcu::Vec4( 0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, 0.6f, 0.0f, 1.0f), blue}, 1568 1569 // two vertices clipped to edges, with non-uniform w 1570 {tcu::Vec4( 0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, -0.6f, 0.0f, 1.0f), yellow, 16.0f*tcu::Vec4( 0.6f, -0.6f, 0.0f, 1.0f), blue}, 1571 1572 // three vertices clipped, large, Z 1573 {tcu::Vec4(-0.9f, large/4, large, 1.0f), red, tcu::Vec4(-0.5f, -large/4, -large, 1.0f), yellow, tcu::Vec4(-0.2f, large/4, large, 1.0f), blue}, 1574 }; 1575 1576 addChild(new TriangleCase(m_context, "poly_clip_viewport_center", "polygon viewport clipping", DE_ARRAY_BEGIN(viewportPolys), DE_ARRAY_END(viewportPolys), VIEWPORT_CENTER)); 1577 addChild(new TriangleCase(m_context, "poly_clip_viewport_corner", "polygon viewport clipping", DE_ARRAY_BEGIN(viewportPolys), DE_ARRAY_END(viewportPolys), VIEWPORT_CORNER)); 1578 1579 addChild(new TriangleCase(m_context, "poly_z_clip", "polygon z clipping", DE_ARRAY_BEGIN(depthPolys), DE_ARRAY_END(depthPolys), VIEWPORT_WHOLE)); 1580 addChild(new TriangleCase(m_context, "poly_z_clip_viewport_center", "polygon z clipping", DE_ARRAY_BEGIN(depthPolys), DE_ARRAY_END(depthPolys), VIEWPORT_CENTER)); 1581 addChild(new TriangleCase(m_context, "poly_z_clip_viewport_corner", "polygon z clipping", DE_ARRAY_BEGIN(depthPolys), DE_ARRAY_END(depthPolys), VIEWPORT_CORNER)); 1582 1583 addChild(new TriangleCase(m_context, "large_poly_clip_viewport_center", "polygon viewport clipping", DE_ARRAY_BEGIN(largePolys), DE_ARRAY_END(largePolys), VIEWPORT_CENTER)); 1584 addChild(new TriangleCase(m_context, "large_poly_clip_viewport_corner", "polygon viewport clipping", DE_ARRAY_BEGIN(largePolys), DE_ARRAY_END(largePolys), VIEWPORT_CORNER)); 1585 1586 addChild(new TriangleCase(m_context, "large_poly_z_clip", "polygon z clipping", DE_ARRAY_BEGIN(largeDepthPolys), DE_ARRAY_END(largeDepthPolys), VIEWPORT_WHOLE)); 1587 addChild(new TriangleCase(m_context, "large_poly_z_clip_viewport_center", "polygon z clipping", DE_ARRAY_BEGIN(largeDepthPolys), DE_ARRAY_END(largeDepthPolys), VIEWPORT_CENTER)); 1588 addChild(new TriangleCase(m_context, "large_poly_z_clip_viewport_corner", "polygon z clipping", DE_ARRAY_BEGIN(largeDepthPolys), DE_ARRAY_END(largeDepthPolys), VIEWPORT_CORNER)); 1589 1590 addChild(new TriangleAttributeCase(m_context, "poly_attrib_clip", "polygon clipping", DE_ARRAY_BEGIN(attribPolys), DE_ARRAY_END(attribPolys), VIEWPORT_WHOLE)); 1591 addChild(new TriangleAttributeCase(m_context, "poly_attrib_clip_viewport_center", "polygon clipping", DE_ARRAY_BEGIN(attribPolys), DE_ARRAY_END(attribPolys), VIEWPORT_CENTER)); 1592 addChild(new TriangleAttributeCase(m_context, "poly_attrib_clip_viewport_corner", "polygon clipping", DE_ARRAY_BEGIN(attribPolys), DE_ARRAY_END(attribPolys), VIEWPORT_CORNER)); 1593 } 1594 1595 // multiple polygons 1596 { 1597 { 1598 const TriangleAttributeCase::TriangleData polys[] = 1599 { 1600 // one vertex clipped to edge 1601 {tcu::Vec4(-0.2f, -0.3f, 0.0f, 1.0f), red, tcu::Vec4( 0.2f, -0.3f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.0f, -offset, 2.0f, 1.0f), blue}, 1602 1603 // two vertices clipped to edges 1604 {tcu::Vec4( 0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, 0.6f, 0.0f, 1.0f), blue}, 1605 1606 // two vertices clipped to edges, with non-uniform w 1607 {tcu::Vec4( 0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, -0.6f, 0.0f, 1.0f), yellow, 16.0f*tcu::Vec4( 0.6f, -0.6f, 0.0f, 1.0f), blue}, 1608 {tcu::Vec4( 0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, 0.6f, 0.0f, 1.0f), yellow, 16.0f*tcu::Vec4( 0.6f, 0.6f, 0.0f, 1.0f), blue}, 1609 {tcu::Vec4(-0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4(-1.2f, 0.6f, 0.0f, 1.0f), yellow, 16.0f*tcu::Vec4(-0.6f, 0.6f, 0.0f, 1.0f), blue}, 1610 {tcu::Vec4(-0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4(-1.2f, -0.6f, 0.0f, 1.0f), yellow, 16.0f*tcu::Vec4(-0.6f, -0.6f, 0.0f, 1.0f), blue}, 1611 1612 // three vertices clipped, Z 1613 {tcu::Vec4(-0.9f, offset/4, offset, 1.0f), red, tcu::Vec4(-0.5f, -offset/4, -offset, 1.0f), yellow, tcu::Vec4(-0.2f, offset/4, offset, 1.0f), blue}, 1614 }; 1615 1616 addChild(new TriangleAttributeCase(m_context, "multiple_0", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_WHOLE)); 1617 addChild(new TriangleAttributeCase(m_context, "multiple_0_viewport_center", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CENTER)); 1618 addChild(new TriangleAttributeCase(m_context, "multiple_0_viewport_corner", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CORNER)); 1619 } 1620 1621 { 1622 const TriangleAttributeCase::TriangleData polys[] = 1623 { 1624 // one vertex clipped to z 1625 {tcu::Vec4(-0.2f, -0.3f, 0.0f, 1.0f), red, tcu::Vec4( 0.2f, -0.3f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.0f, -offset, 2.0f, 1.0f), blue}, 1626 1627 // two vertices clipped to edges 1628 {tcu::Vec4( 0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, 0.6f, 0.0f, 1.0f), blue}, 1629 1630 // two vertices clipped to edges, with non-uniform w 1631 {tcu::Vec4( 0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, -0.6f, 0.0f, 1.0f), yellow, 16.0f*tcu::Vec4( 0.6f, -0.6f, 0.0f, 1.0f), blue}, 1632 {tcu::Vec4( 0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, 0.6f, 0.0f, 1.0f), yellow, 16.0f*tcu::Vec4( 0.6f, 0.6f, 0.0f, 1.0f), blue}, 1633 {tcu::Vec4(-0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4(-1.2f, 0.6f, 0.0f, 1.0f), yellow, 16.0f*tcu::Vec4(-0.6f, 0.6f, 0.0f, 1.0f), blue}, 1634 {tcu::Vec4(-0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4(-1.2f, -0.6f, 0.0f, 1.0f), yellow, 16.0f*tcu::Vec4(-0.6f, -0.6f, 0.0f, 1.0f), blue}, 1635 }; 1636 1637 addChild(new TriangleAttributeCase(m_context, "multiple_1", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_WHOLE)); 1638 addChild(new TriangleAttributeCase(m_context, "multiple_1_viewport_center", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CENTER)); 1639 addChild(new TriangleAttributeCase(m_context, "multiple_1_viewport_corner", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CORNER)); 1640 } 1641 1642 { 1643 const TriangleAttributeCase::TriangleData polys[] = 1644 { 1645 // one vertex clipped to z 1646 {tcu::Vec4(-0.2f, -0.3f, 0.0f, 1.0f), red, tcu::Vec4( 0.2f, -0.3f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.0f, -offset, 2.0f, 1.0f), blue}, 1647 1648 // two vertices clipped to edges 1649 {tcu::Vec4( 0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, 0.6f, 0.0f, 1.0f), blue}, 1650 1651 // two vertices clipped to edges 1652 {tcu::Vec4( 0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, -0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, -0.6f, 0.0f, 1.0f), blue}, 1653 {tcu::Vec4( 0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, 0.6f, 0.0f, 1.0f), blue}, 1654 {tcu::Vec4(-0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4(-1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4(-0.6f, 0.6f, 0.0f, 1.0f), blue}, 1655 {tcu::Vec4(-0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4(-1.2f, -0.6f, 0.0f, 1.0f), yellow, tcu::Vec4(-0.6f, -0.6f, 0.0f, 1.0f), blue}, 1656 }; 1657 1658 addChild(new TriangleAttributeCase(m_context, "multiple_2", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_WHOLE)); 1659 addChild(new TriangleAttributeCase(m_context, "multiple_2_viewport_center", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CENTER)); 1660 addChild(new TriangleAttributeCase(m_context, "multiple_2_viewport_corner", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CORNER)); 1661 } 1662 1663 { 1664 const TriangleAttributeCase::TriangleData polys[] = 1665 { 1666 // one vertex clipped to z 1667 {tcu::Vec4(-0.2f, -0.3f, 0.0f, 1.0f), red, tcu::Vec4( 0.2f, -0.3f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.0f, -offset, -2.0f, 1.0f), blue}, 1668 1669 // two vertices clipped to edges 1670 {tcu::Vec4( 0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, -0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, -0.6f, 0.0f, 1.0f), blue}, 1671 {tcu::Vec4( 0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, 0.6f, 0.0f, 1.0f), blue}, 1672 {tcu::Vec4(-0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4(-1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4(-0.6f, 0.6f, 0.0f, 1.0f), blue}, 1673 {tcu::Vec4(-0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4(-1.2f, -0.6f, 0.0f, 1.0f), yellow, tcu::Vec4(-0.6f, -0.6f, 0.0f, 1.0f), blue}, 1674 }; 1675 1676 addChild(new TriangleAttributeCase(m_context, "multiple_3", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_WHOLE)); 1677 addChild(new TriangleAttributeCase(m_context, "multiple_3_viewport_center", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CENTER)); 1678 addChild(new TriangleAttributeCase(m_context, "multiple_3_viewport_corner", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CORNER)); 1679 } 1680 1681 { 1682 const TriangleAttributeCase::TriangleData polys[] = 1683 { 1684 // one vertex clipped to z 1685 {tcu::Vec4(0.3f, 0.2f, 0.0f, 1.0f), red, tcu::Vec4( 0.3f, -0.2f, 0.0f, 1.0f), yellow, tcu::Vec4( offset, 0.0f, 2.0f, 1.0f), blue}, 1686 1687 // two vertices clipped to edges 1688 {tcu::Vec4( 0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, -0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, -0.6f, 0.0f, 1.0f), blue}, 1689 {tcu::Vec4( 0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, 0.6f, 0.0f, 1.0f), blue}, 1690 {tcu::Vec4(-0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4(-1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4(-0.6f, 0.6f, 0.0f, 1.0f), blue}, 1691 {tcu::Vec4(-0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4(-1.2f, -0.6f, 0.0f, 1.0f), yellow, tcu::Vec4(-0.6f, -0.6f, 0.0f, 1.0f), blue}, 1692 }; 1693 1694 addChild(new TriangleAttributeCase(m_context, "multiple_4", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_WHOLE)); 1695 addChild(new TriangleAttributeCase(m_context, "multiple_4_viewport_center", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CENTER)); 1696 addChild(new TriangleAttributeCase(m_context, "multiple_4_viewport_corner", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CORNER)); 1697 } 1698 1699 { 1700 const TriangleAttributeCase::TriangleData polys[] = 1701 { 1702 // one vertex clipped to z 1703 {tcu::Vec4(-0.3f, 0.2f, 0.0f, 1.0f), red, tcu::Vec4(-0.3f, -0.2f, 0.0f, 1.0f), yellow, tcu::Vec4(-offset, 0.0f, 2.0f, 1.0f), blue}, 1704 1705 // two vertices clipped to edges 1706 {tcu::Vec4( 0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, -0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, -0.6f, 0.0f, 1.0f), blue}, 1707 {tcu::Vec4( 0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, 0.6f, 0.0f, 1.0f), blue}, 1708 {tcu::Vec4(-0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4(-1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4(-0.6f, 0.6f, 0.0f, 1.0f), blue}, 1709 {tcu::Vec4(-0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4(-1.2f, -0.6f, 0.0f, 1.0f), yellow, tcu::Vec4(-0.6f, -0.6f, 0.0f, 1.0f), blue}, 1710 }; 1711 1712 addChild(new TriangleAttributeCase(m_context, "multiple_5", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_WHOLE)); 1713 addChild(new TriangleAttributeCase(m_context, "multiple_5_viewport_center", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CENTER)); 1714 addChild(new TriangleAttributeCase(m_context, "multiple_5_viewport_corner", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CORNER)); 1715 } 1716 1717 { 1718 const TriangleAttributeCase::TriangleData polys[] = 1719 { 1720 // one vertex clipped to z 1721 {tcu::Vec4(-0.2f, 0.3f, 0.0f, 1.0f), red, tcu::Vec4( 0.2f, 0.3f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.0f, offset, 2.0f, 1.0f), blue}, 1722 1723 // two vertices clipped to edges 1724 {tcu::Vec4( 0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, -0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, -0.6f, 0.0f, 1.0f), blue}, 1725 {tcu::Vec4( 0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, 0.6f, 0.0f, 1.0f), blue}, 1726 {tcu::Vec4(-0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4(-1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4(-0.6f, 0.6f, 0.0f, 1.0f), blue}, 1727 {tcu::Vec4(-0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4(-1.2f, -0.6f, 0.0f, 1.0f), yellow, tcu::Vec4(-0.6f, -0.6f, 0.0f, 1.0f), blue}, 1728 }; 1729 1730 addChild(new TriangleAttributeCase(m_context, "multiple_6", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_WHOLE)); 1731 addChild(new TriangleAttributeCase(m_context, "multiple_6_viewport_center", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CENTER)); 1732 addChild(new TriangleAttributeCase(m_context, "multiple_6_viewport_corner", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CORNER)); 1733 } 1734 1735 { 1736 const TriangleAttributeCase::TriangleData polys[] = 1737 { 1738 // two vertices clipped to edges 1739 {tcu::Vec4( 0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, 0.6f, 0.0f, 1.0f), blue}, 1740 1741 // two vertices clipped to edges 1742 {tcu::Vec4( 0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, -0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, -0.6f, 0.0f, 1.0f), blue}, 1743 {tcu::Vec4( 0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4( 1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.6f, 0.6f, 0.0f, 1.0f), blue}, 1744 {tcu::Vec4(-0.6f, 1.2f, 0.0f, 1.0f), red, tcu::Vec4(-1.2f, 0.6f, 0.0f, 1.0f), yellow, tcu::Vec4(-0.6f, 0.6f, 0.0f, 1.0f), blue}, 1745 {tcu::Vec4(-0.6f, -1.2f, 0.0f, 1.0f), red, tcu::Vec4(-1.2f, -0.6f, 0.0f, 1.0f), yellow, tcu::Vec4(-0.6f, -0.6f, 0.0f, 1.0f), blue}, 1746 }; 1747 1748 addChild(new TriangleAttributeCase(m_context, "multiple_7", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_WHOLE)); 1749 addChild(new TriangleAttributeCase(m_context, "multiple_7_viewport_center", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CENTER)); 1750 addChild(new TriangleAttributeCase(m_context, "multiple_7_viewport_corner", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CORNER)); 1751 } 1752 1753 { 1754 const TriangleAttributeCase::TriangleData polys[] = 1755 { 1756 // one vertex clipped to z 1757 {tcu::Vec4(-0.2f, -0.3f, 0.0f, 1.0f), red, tcu::Vec4( 0.2f, -0.3f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.0f, -offset, 2.0f, 1.0f), blue}, 1758 1759 // fill 1760 {tcu::Vec4( -1.0f, -1.0f, 0.0f, 1.0f), white, tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f), white, tcu::Vec4( -1.0f, 1.0f, 0.0f, 1.0f), white}, 1761 {tcu::Vec4( -1.0f, 1.0f, 0.0f, 1.0f), blue, tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f), blue, tcu::Vec4( 1.0f, 1.0f, 0.0f, 1.0f), blue}, 1762 }; 1763 1764 addChild(new TriangleAttributeCase(m_context, "multiple_8", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_WHOLE)); 1765 addChild(new TriangleAttributeCase(m_context, "multiple_8_viewport_center", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CENTER)); 1766 addChild(new TriangleAttributeCase(m_context, "multiple_8_viewport_corner", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CORNER)); 1767 } 1768 1769 { 1770 const TriangleAttributeCase::TriangleData polys[] = 1771 { 1772 // one vertex clipped to z 1773 {tcu::Vec4(-0.2f, -0.3f, 0.0f, 1.0f), red, tcu::Vec4( 0.2f, -0.3f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.0f, -offset, 2.0f, 1.0f), blue}, 1774 1775 // fill 1776 {tcu::Vec4( -1.0f, 1.0f, 0.0f, 1.0f), red, tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f), red, tcu::Vec4( 1.0f, 1.0f, 0.0f, 1.0f), red}, 1777 {tcu::Vec4( -1.0f, -1.0f, 0.0f, 1.0f), blue, tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f), blue, tcu::Vec4( -1.0f, 1.0f, 0.0f, 1.0f), blue}, 1778 }; 1779 1780 addChild(new TriangleAttributeCase(m_context, "multiple_9", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_WHOLE)); 1781 addChild(new TriangleAttributeCase(m_context, "multiple_9_viewport_center", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CENTER)); 1782 addChild(new TriangleAttributeCase(m_context, "multiple_9_viewport_corner", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CORNER)); 1783 } 1784 1785 { 1786 const TriangleAttributeCase::TriangleData polys[] = 1787 { 1788 // one vertex clipped to z 1789 {tcu::Vec4(-0.2f, -0.3f, 0.0f, 1.0f), red, tcu::Vec4( 0.2f, -0.3f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.0f, -offset, 2.0f, 1.0f), blue}, 1790 1791 // fill 1792 {tcu::Vec4( -1.0f, -1.0f, 0.0f, 1.0f), white, tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f), white, tcu::Vec4( -1.0f, 1.0f, 0.0f, 1.0f), white}, 1793 {tcu::Vec4( -1.0f, 1.0f, 0.0f, 1.0f), red, tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f), red, tcu::Vec4( 1.0f, 1.0f, 0.0f, 1.0f), red}, 1794 {tcu::Vec4( -1.0f, -1.0f, 0.0f, 1.0f), blue, tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f), blue, tcu::Vec4( -1.0f, 1.0f, 0.0f, 1.0f), blue}, 1795 }; 1796 1797 addChild(new TriangleAttributeCase(m_context, "multiple_10", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_WHOLE)); 1798 addChild(new TriangleAttributeCase(m_context, "multiple_10_viewport_center", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CENTER)); 1799 addChild(new TriangleAttributeCase(m_context, "multiple_10_viewport_corner", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CORNER)); 1800 } 1801 1802 { 1803 const TriangleAttributeCase::TriangleData polys[] = 1804 { 1805 // one vertex clipped to z 1806 {tcu::Vec4(-0.2f, -0.3f, 0.0f, 1.0f), red, tcu::Vec4( 0.2f, -0.3f, 0.0f, 1.0f), yellow, tcu::Vec4( 0.0f, -offset, 2.0f, 1.0f), blue}, 1807 1808 // fill 1809 {tcu::Vec4( -1.0f, -1.0f, 0.0f, 1.0f), white, tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f), white, tcu::Vec4( -1.0f, 1.0f, 0.0f, 1.0f), white}, 1810 {tcu::Vec4( -1.0f, 1.0f, 0.0f, 1.0f), red, tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f), red, tcu::Vec4( 1.0f, 1.0f, 0.0f, 1.0f), red}, 1811 {tcu::Vec4( -1.0f, -1.0f, 0.0f, 1.0f), blue, tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f), blue, tcu::Vec4( -1.0f, 1.0f, 0.0f, 1.0f), blue}, 1812 {tcu::Vec4( -1.0f, 1.0f, 0.0f, 1.0f), yellow, tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f), yellow, tcu::Vec4( 1.0f, 1.0f, 0.0f, 1.0f), yellow}, 1813 }; 1814 1815 addChild(new TriangleAttributeCase(m_context, "multiple_11", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_WHOLE)); 1816 addChild(new TriangleAttributeCase(m_context, "multiple_11_viewport_center", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CENTER)); 1817 addChild(new TriangleAttributeCase(m_context, "multiple_11_viewport_corner", "polygon clipping", DE_ARRAY_BEGIN(polys), DE_ARRAY_END(polys), VIEWPORT_CORNER)); 1818 } 1819 } 1820 } 1821 1822 class PolyEdgesTestGroup : public TestCaseGroup 1823 { 1824 public: 1825 PolyEdgesTestGroup (Context& context); 1826 1827 void init (void); 1828 }; 1829 1830 PolyEdgesTestGroup::PolyEdgesTestGroup (Context& context) 1831 : TestCaseGroup(context, "polygon_edge", "Polygon clipping edge tests") 1832 { 1833 } 1834 1835 void PolyEdgesTestGroup::init (void) 1836 { 1837 // Quads via origin 1838 const struct Quad 1839 { 1840 tcu::Vec3 d1; // tangent 1841 tcu::Vec3 d2; // bi-tangent 1842 } quads[] = 1843 { 1844 { tcu::Vec3( 1, 1, 1), tcu::Vec3( 1, -1, 1) }, 1845 { tcu::Vec3( 1, 1, 1), tcu::Vec3(-1, 1.1f, 1) }, 1846 { tcu::Vec3( 1, 1, 0), tcu::Vec3(-1, 1, 0) }, 1847 { tcu::Vec3( 0, 1, 0), tcu::Vec3( 1, 0, 0) }, 1848 { tcu::Vec3( 0, 1, 0), tcu::Vec3( 1, 0.1f, 0) }, 1849 }; 1850 1851 // Quad near edge 1852 const struct EdgeQuad 1853 { 1854 tcu::Vec3 d1; // tangent 1855 tcu::Vec3 d2; // bi-tangent 1856 tcu::Vec3 center; // center 1857 } edgeQuads[] = 1858 { 1859 { tcu::Vec3( 1, 0.01f, 0 ), tcu::Vec3( 0, 0.01f, 0), tcu::Vec3( 0, 0.99f, 0 ) }, // edge near x-plane 1860 { tcu::Vec3( 0.01f, 1, 0 ), tcu::Vec3( 0.01f, 0, 0), tcu::Vec3( 0.99f, 0, 0 ) }, // edge near y-plane 1861 { tcu::Vec3( 1, 1, 0.01f), tcu::Vec3( 0.01f, -0.01f, 0), tcu::Vec3( 0, 0, 0.99f) }, // edge near z-plane 1862 }; 1863 1864 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(quads); ++ndx) 1865 addChild(new QuadFillTest(m_context, (std::string("quad_at_origin_") + de::toString(ndx)).c_str(), "polygon edge clipping", VIEWPORT_CENTER, quads[ndx].d1, quads[ndx].d2)); 1866 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(edgeQuads); ++ndx) 1867 addChild(new QuadFillTest(m_context, (std::string("quad_near_edge_") + de::toString(ndx)).c_str(), "polygon edge clipping", VIEWPORT_CENTER, edgeQuads[ndx].d1, edgeQuads[ndx].d2, edgeQuads[ndx].center)); 1868 1869 // Polyfan 1870 addChild(new TriangleFanFillTest(m_context, "poly_fan", "polygon edge clipping", VIEWPORT_CENTER)); 1871 } 1872 1873 class PolyVertexClipTestGroup : public TestCaseGroup 1874 { 1875 public: 1876 PolyVertexClipTestGroup (Context& context); 1877 1878 void init (void); 1879 }; 1880 1881 PolyVertexClipTestGroup::PolyVertexClipTestGroup (Context& context) 1882 : TestCaseGroup(context, "triangle_vertex", "Clip n vertices") 1883 { 1884 } 1885 1886 void PolyVertexClipTestGroup::init (void) 1887 { 1888 const float far = 30000.0f; 1889 const tcu::IVec3 outside[] = 1890 { 1891 // outside one clipping plane 1892 tcu::IVec3(-1, 0, 0), 1893 tcu::IVec3( 1, 0, 0), 1894 tcu::IVec3( 0, 1, 0), 1895 tcu::IVec3( 0, -1, 0), 1896 tcu::IVec3( 0, 0, 1), 1897 tcu::IVec3( 0, 0, -1), 1898 1899 // outside two clipping planes 1900 tcu::IVec3(-1, -1, 0), 1901 tcu::IVec3( 1, -1, 0), 1902 tcu::IVec3( 1, 1, 0), 1903 tcu::IVec3(-1, 1, 0), 1904 1905 tcu::IVec3(-1, 0, -1), 1906 tcu::IVec3( 1, 0, -1), 1907 tcu::IVec3( 1, 0, 1), 1908 tcu::IVec3(-1, 0, 1), 1909 1910 tcu::IVec3( 0, -1, -1), 1911 tcu::IVec3( 0, 1, -1), 1912 tcu::IVec3( 0, 1, 1), 1913 tcu::IVec3( 0, -1, 1), 1914 1915 // outside three clipping planes 1916 tcu::IVec3(-1, -1, 1), 1917 tcu::IVec3( 1, -1, 1), 1918 tcu::IVec3( 1, 1, 1), 1919 tcu::IVec3(-1, 1, 1), 1920 1921 tcu::IVec3(-1, -1, -1), 1922 tcu::IVec3( 1, -1, -1), 1923 tcu::IVec3( 1, 1, -1), 1924 tcu::IVec3(-1, 1, -1), 1925 }; 1926 1927 de::Random rnd(0xabcdef); 1928 1929 TestCaseGroup* clipOne = new TestCaseGroup(m_context, "clip_one", "Clip one vertex"); 1930 TestCaseGroup* clipTwo = new TestCaseGroup(m_context, "clip_two", "Clip two vertices"); 1931 TestCaseGroup* clipThree = new TestCaseGroup(m_context, "clip_three", "Clip three vertices"); 1932 1933 addChild(clipOne); 1934 addChild(clipTwo); 1935 addChild(clipThree); 1936 1937 // Test 1 point clipped 1938 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(outside); ++ndx) 1939 { 1940 const float w0 = rnd.getFloat(0.2f, 16.0f); 1941 const float w1 = rnd.getFloat(0.2f, 16.0f); 1942 const float w2 = rnd.getFloat(0.2f, 16.0f); 1943 const tcu::Vec4 white = tcu::Vec4( 1, 1, 1, 1); 1944 const tcu::Vec3 r0 = tcu::Vec3( 0.2f, 0.3f, 0); 1945 const tcu::Vec3 r1 = tcu::Vec3(-0.3f, -0.4f, 0); 1946 const tcu::Vec3 r2 = IVec3ToVec3(outside[ndx]) * far; 1947 const tcu::Vec4 p0 = tcu::Vec4(r0.x() * w0, r0.y() * w0, r0.z() * w0, w0); 1948 const tcu::Vec4 p1 = tcu::Vec4(r1.x() * w1, r1.y() * w1, r1.z() * w1, w1); 1949 const tcu::Vec4 p2 = tcu::Vec4(r2.x() * w2, r2.y() * w2, r2.z() * w2, w2); 1950 1951 const std::string name = std::string("clip") + 1952 (outside[ndx].x() > 0 ? "_pos_x" : (outside[ndx].x() < 0 ? "_neg_x" : "")) + 1953 (outside[ndx].y() > 0 ? "_pos_y" : (outside[ndx].y() < 0 ? "_neg_y" : "")) + 1954 (outside[ndx].z() > 0 ? "_pos_z" : (outside[ndx].z() < 0 ? "_neg_z" : "")); 1955 1956 const TriangleCase::TriangleData triangle = {p0, white, p1, white, p2, white}; 1957 1958 // don't try to test with degenerate (or almost degenerate) triangles 1959 if (outside[ndx].x() == 0 && outside[ndx].y() == 0) 1960 continue; 1961 1962 clipOne->addChild(new TriangleCase(m_context, name.c_str(), "clip one vertex", &triangle, &triangle + 1, VIEWPORT_CENTER)); 1963 } 1964 1965 // Special triangles for "clip_z" cases, default triangles is not good, since it has very small visible area => problems with MSAA 1966 { 1967 const tcu::Vec4 white = tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f); 1968 1969 const TriangleCase::TriangleData posZTriangle = 1970 { 1971 tcu::Vec4( 0.0f, -0.7f, -0.9f, 1.0f), white, 1972 tcu::Vec4( 0.8f, 0.0f, -0.7f, 1.0f), white, 1973 tcu::Vec4(-0.9f, 0.9f, 3.0f, 1.0f), white 1974 }; 1975 const TriangleCase::TriangleData negZTriangle = 1976 { 1977 tcu::Vec4( 0.0f, -0.7f, 0.9f, 1.0f), white, 1978 tcu::Vec4( 0.4f, 0.0f, 0.7f, 1.0f), white, 1979 tcu::Vec4(-0.9f, 0.9f, -3.0f, 1.0f), white 1980 }; 1981 1982 clipOne->addChild(new TriangleCase(m_context, "clip_pos_z", "clip one vertex", &posZTriangle, &posZTriangle + 1, VIEWPORT_CENTER)); 1983 clipOne->addChild(new TriangleCase(m_context, "clip_neg_z", "clip one vertex", &negZTriangle, &negZTriangle + 1, VIEWPORT_CENTER)); 1984 } 1985 1986 // Test 2 points clipped 1987 for (int ndx1 = 0; ndx1 < DE_LENGTH_OF_ARRAY(outside); ++ndx1) 1988 for (int ndx2 = ndx1 + 1; ndx2 < DE_LENGTH_OF_ARRAY(outside); ++ndx2) 1989 { 1990 const float w0 = rnd.getFloat(0.2f, 16.0f); 1991 const float w1 = rnd.getFloat(0.2f, 16.0f); 1992 const float w2 = rnd.getFloat(0.2f, 16.0f); 1993 const tcu::Vec4 white = tcu::Vec4( 1, 1, 1, 1); 1994 const tcu::Vec3 r0 = tcu::Vec3( 0.2f, 0.3f, 0); 1995 const tcu::IVec3 r1 = outside[ndx1]; 1996 const tcu::IVec3 r2 = outside[ndx2]; 1997 const tcu::Vec4 p0 = tcu::Vec4(r0.x() * w0, r0.y() * w0, r0.z() * w0, w0); 1998 const tcu::Vec4 p1 = tcu::Vec4(float(r1.x()) * far * w1, float(r1.y()) * far * w1, float(r1.z()) * far * w1, w1); 1999 const tcu::Vec4 p2 = tcu::Vec4(float(r2.x()) * far * w2, float(r2.y()) * far * w2, float(r2.z()) * far * w2, w2); 2000 2001 const std::string name = std::string("clip") + 2002 (outside[ndx1].x() > 0 ? "_pos_x" : (outside[ndx1].x() < 0 ? "_neg_x" : "")) + 2003 (outside[ndx1].y() > 0 ? "_pos_y" : (outside[ndx1].y() < 0 ? "_neg_y" : "")) + 2004 (outside[ndx1].z() > 0 ? "_pos_z" : (outside[ndx1].z() < 0 ? "_neg_z" : "")) + 2005 "_and" + 2006 (outside[ndx2].x() > 0 ? "_pos_x" : (outside[ndx2].x() < 0 ? "_neg_x" : "")) + 2007 (outside[ndx2].y() > 0 ? "_pos_y" : (outside[ndx2].y() < 0 ? "_neg_y" : "")) + 2008 (outside[ndx2].z() > 0 ? "_pos_z" : (outside[ndx2].z() < 0 ? "_neg_z" : "")); 2009 2010 const TriangleCase::TriangleData triangle = {p0, white, p1, white, p2, white}; 2011 2012 if (twoPointClippedTriangleInvisible(r0, r1, r2)) 2013 continue; 2014 2015 clipTwo->addChild(new TriangleCase(m_context, name.c_str(), "clip two vertices", &triangle, &triangle + 1, VIEWPORT_CENTER)); 2016 } 2017 2018 // Test 3 points clipped 2019 for (int ndx1 = 0; ndx1 < DE_LENGTH_OF_ARRAY(outside); ++ndx1) 2020 for (int ndx2 = ndx1 + 1; ndx2 < DE_LENGTH_OF_ARRAY(outside); ++ndx2) 2021 for (int ndx3 = ndx2 + 1; ndx3 < DE_LENGTH_OF_ARRAY(outside); ++ndx3) 2022 { 2023 const float w0 = rnd.getFloat(0.2f, 16.0f); 2024 const float w1 = rnd.getFloat(0.2f, 16.0f); 2025 const float w2 = rnd.getFloat(0.2f, 16.0f); 2026 const tcu::Vec4 white = tcu::Vec4(1, 1, 1, 1); 2027 const tcu::IVec3 r0 = outside[ndx1]; 2028 const tcu::IVec3 r1 = outside[ndx2]; 2029 const tcu::IVec3 r2 = outside[ndx3]; 2030 const tcu::Vec4 p0 = tcu::Vec4(float(r0.x()) * far * w0, float(r0.y()) * far * w0, float(r0.z()) * far * w0, w0); 2031 const tcu::Vec4 p1 = tcu::Vec4(float(r1.x()) * far * w1, float(r1.y()) * far * w1, float(r1.z()) * far * w1, w1); 2032 const tcu::Vec4 p2 = tcu::Vec4(float(r2.x()) * far * w2, float(r2.y()) * far * w2, float(r2.z()) * far * w2, w2); 2033 2034 // ignore cases where polygon is along xz or yz planes 2035 if (pointsOnLine(r0.swizzle(0, 1), r1.swizzle(0, 1), r2.swizzle(0, 1))) 2036 continue; 2037 2038 // triangle is visible only if it intersects the origin 2039 if (pointOnTriangle(tcu::IVec3(0, 0, 0), r0, r1, r2)) 2040 { 2041 const TriangleCase::TriangleData triangle = {p0, white, p1, white, p2, white}; 2042 const std::string name = std::string("clip") + 2043 (outside[ndx1].x() > 0 ? "_pos_x" : (outside[ndx1].x() < 0 ? "_neg_x" : "")) + 2044 (outside[ndx1].y() > 0 ? "_pos_y" : (outside[ndx1].y() < 0 ? "_neg_y" : "")) + 2045 (outside[ndx1].z() > 0 ? "_pos_z" : (outside[ndx1].z() < 0 ? "_neg_z" : "")) + 2046 "_and" + 2047 (outside[ndx2].x() > 0 ? "_pos_x" : (outside[ndx2].x() < 0 ? "_neg_x" : "")) + 2048 (outside[ndx2].y() > 0 ? "_pos_y" : (outside[ndx2].y() < 0 ? "_neg_y" : "")) + 2049 (outside[ndx2].z() > 0 ? "_pos_z" : (outside[ndx2].z() < 0 ? "_neg_z" : "")) + 2050 "_and" + 2051 (outside[ndx3].x() > 0 ? "_pos_x" : (outside[ndx3].x() < 0 ? "_neg_x" : "")) + 2052 (outside[ndx3].y() > 0 ? "_pos_y" : (outside[ndx3].y() < 0 ? "_neg_y" : "")) + 2053 (outside[ndx3].z() > 0 ? "_pos_z" : (outside[ndx3].z() < 0 ? "_neg_z" : "")); 2054 2055 clipThree->addChild(new TriangleCase(m_context, name.c_str(), "clip three vertices", &triangle, &triangle + 1, VIEWPORT_CENTER)); 2056 } 2057 } 2058 } 2059 2060 } // anonymous 2061 2062 ClippingTests::ClippingTests (Context& context) 2063 : TestCaseGroup(context, "clipping", "Clipping tests") 2064 { 2065 } 2066 2067 ClippingTests::~ClippingTests (void) 2068 { 2069 } 2070 2071 void ClippingTests::init (void) 2072 { 2073 addChild(new PointsTestGroup (m_context)); 2074 addChild(new LinesTestGroup (m_context)); 2075 addChild(new PolysTestGroup (m_context)); 2076 addChild(new PolyEdgesTestGroup (m_context)); 2077 addChild(new PolyVertexClipTestGroup(m_context)); 2078 } 2079 2080 } // Functional 2081 } // gles3 2082 } // deqp 2083
