1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 2.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 Stencil tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es2fStencilTests.hpp" 25 26 #include "tcuSurface.hpp" 27 #include "tcuVector.hpp" 28 #include "tcuTestLog.hpp" 29 #include "tcuImageCompare.hpp" 30 #include "tcuRenderTarget.hpp" 31 32 #include "sglrContextUtil.hpp" 33 #include "sglrGLContext.hpp" 34 #include "sglrReferenceContext.hpp" 35 36 #include "deRandom.hpp" 37 #include "deMath.h" 38 #include "deString.h" 39 40 #include <vector> 41 42 #include "glwEnums.hpp" 43 #include "glwDefs.hpp" 44 45 using tcu::Vec3; 46 using tcu::IVec2; 47 using tcu::IVec4; 48 using std::vector; 49 using namespace glw; 50 51 namespace deqp 52 { 53 namespace gles2 54 { 55 namespace Functional 56 { 57 58 class StencilShader : public sglr::ShaderProgram 59 { 60 public: 61 StencilShader (void) 62 : sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration() 63 << sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT) 64 << sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT) 65 << sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT) 66 << sglr::pdec::Uniform("u_color", glu::TYPE_FLOAT_VEC4) 67 << sglr::pdec::VertexSource("attribute highp vec4 a_position;\n" 68 "void main (void)\n" 69 "{\n" 70 " gl_Position = a_position;\n" 71 "}\n") 72 << sglr::pdec::FragmentSource("uniform mediump vec4 u_color;\n" 73 "void main (void)\n" 74 "{\n" 75 " gl_FragColor = u_color;\n" 76 "}\n")) 77 , u_color (getUniformByName("u_color")) 78 { 79 } 80 81 void setColor (sglr::Context& ctx, deUint32 program, const tcu::Vec4& color) 82 { 83 ctx.useProgram(program); 84 ctx.uniform4fv(ctx.getUniformLocation(program, "u_color"), 1, color.getPtr()); 85 } 86 87 private: 88 void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const 89 { 90 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx) 91 { 92 rr::VertexPacket& packet = *packets[packetNdx]; 93 94 packet.position = rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx); 95 } 96 } 97 98 void shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const 99 { 100 const tcu::Vec4 color(u_color.value.f4); 101 102 DE_UNREF(packets); 103 104 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx) 105 for (int fragNdx = 0; fragNdx < 4; ++fragNdx) 106 rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color); 107 } 108 109 const sglr::UniformSlot& u_color; 110 }; 111 112 class StencilOp 113 { 114 public: 115 enum Type 116 { 117 TYPE_CLEAR_STENCIL = 0, 118 TYPE_CLEAR_DEPTH, 119 TYPE_QUAD, 120 121 TYPE_LAST 122 }; 123 124 Type type; 125 GLenum stencilTest; 126 int stencil; //!< Ref for quad op, clear value for clears 127 deUint32 stencilMask; 128 GLenum depthTest; 129 float depth; //!< Quad depth or clear value 130 GLenum sFail; 131 GLenum dFail; 132 GLenum dPass; 133 134 StencilOp (Type type_, GLenum stencilTest_ = GL_ALWAYS, int stencil_ = 0, GLenum depthTest_ = GL_ALWAYS, float depth_ = 1.0f, GLenum sFail_ = GL_KEEP, GLenum dFail_ = GL_KEEP, GLenum dPass_ = GL_KEEP) 135 : type (type_) 136 , stencilTest (stencilTest_) 137 , stencil (stencil_) 138 , stencilMask (0xffffffffu) 139 , depthTest (depthTest_) 140 , depth (depth_) 141 , sFail (sFail_) 142 , dFail (dFail_) 143 , dPass (dPass_) 144 { 145 } 146 147 static StencilOp clearStencil (int stencil) 148 { 149 StencilOp op(TYPE_CLEAR_STENCIL); 150 op.stencil = stencil; 151 return op; 152 } 153 154 static StencilOp clearDepth (float depth) 155 { 156 StencilOp op(TYPE_CLEAR_DEPTH); 157 op.depth = depth; 158 return op; 159 } 160 161 static StencilOp quad (GLenum stencilTest, int stencil, GLenum depthTest, float depth, GLenum sFail, GLenum dFail, GLenum dPass) 162 { 163 return StencilOp(TYPE_QUAD, stencilTest, stencil, depthTest, depth, sFail, dFail, dPass); 164 } 165 }; 166 167 class StencilCase : public TestCase 168 { 169 public: 170 StencilCase (Context& context, const char* name, const char* description); 171 virtual ~StencilCase (void); 172 173 void init (void); 174 void deinit (void); 175 IterateResult iterate (void); 176 177 virtual void genOps (vector<StencilOp>& dst, int stencilBits, int depthBits, int targetStencil) = DE_NULL; 178 179 private: 180 void executeOps (sglr::Context& context, const IVec4& cell, const vector<StencilOp>& ops); 181 void visualizeStencil (sglr::Context& context, int stencilBits, int stencilStep); 182 183 StencilShader m_shader; 184 deUint32 m_shaderID; 185 }; 186 187 StencilCase::StencilCase (Context& context, const char* name, const char* description) 188 : TestCase (context, name, description) 189 , m_shaderID (0) 190 { 191 } 192 193 StencilCase::~StencilCase (void) 194 { 195 } 196 197 void StencilCase::init (void) 198 { 199 } 200 201 void StencilCase::deinit (void) 202 { 203 } 204 205 void StencilCase::executeOps (sglr::Context& context, const IVec4& cell, const vector<StencilOp>& ops) 206 { 207 // For quadOps 208 float x0 = 2.0f*((float)cell.x() / (float)context.getWidth())-1.0f; 209 float y0 = 2.0f*((float)cell.y() / (float)context.getHeight())-1.0f; 210 float x1 = x0 + 2.0f*((float)cell.z() / (float)context.getWidth()); 211 float y1 = y0 + 2.0f*((float)cell.w() / (float)context.getHeight()); 212 213 m_shader.setColor(context, m_shaderID, tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)); 214 215 for (vector<StencilOp>::const_iterator i = ops.begin(); i != ops.end(); i++) 216 { 217 const StencilOp& op = *i; 218 219 switch (op.type) 220 { 221 case StencilOp::TYPE_CLEAR_DEPTH: 222 context.enable(GL_SCISSOR_TEST); 223 context.scissor(cell.x(), cell.y(), cell.z(), cell.w()); 224 context.clearDepthf(op.depth); 225 context.clear(GL_DEPTH_BUFFER_BIT); 226 context.disable(GL_SCISSOR_TEST); 227 break; 228 229 case StencilOp::TYPE_CLEAR_STENCIL: 230 context.enable(GL_SCISSOR_TEST); 231 context.scissor(cell.x(), cell.y(), cell.z(), cell.w()); 232 context.clearStencil(op.stencil); 233 context.clear(GL_STENCIL_BUFFER_BIT); 234 context.disable(GL_SCISSOR_TEST); 235 break; 236 237 case StencilOp::TYPE_QUAD: 238 context.enable(GL_DEPTH_TEST); 239 context.enable(GL_STENCIL_TEST); 240 context.depthFunc(op.depthTest); 241 context.stencilFunc(op.stencilTest, op.stencil, op.stencilMask); 242 context.stencilOp(op.sFail, op.dFail, op.dPass); 243 sglr::drawQuad(context, m_shaderID, Vec3(x0, y0, op.depth), Vec3(x1, y1, op.depth)); 244 context.disable(GL_STENCIL_TEST); 245 context.disable(GL_DEPTH_TEST); 246 break; 247 248 default: 249 DE_ASSERT(DE_FALSE); 250 } 251 } 252 } 253 254 void StencilCase::visualizeStencil (sglr::Context& context, int stencilBits, int stencilStep) 255 { 256 int endVal = 1<<stencilBits; 257 int numStencilValues = endVal/stencilStep + 1; 258 259 context.enable(GL_STENCIL_TEST); 260 context.stencilOp(GL_KEEP, GL_KEEP, GL_KEEP); 261 262 for (int ndx = 0; ndx < numStencilValues; ndx++) 263 { 264 int value = deMin32(ndx*stencilStep, endVal-1); 265 float colorMix = (float)value/(float)de::max(1, endVal-1); 266 tcu::Vec4 color (0.0f, 1.0f-colorMix, colorMix, 1.0f); 267 268 m_shader.setColor(context, m_shaderID, color); 269 context.stencilFunc(GL_EQUAL, value, 0xffffffffu); 270 sglr::drawQuad(context, m_shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(+1.0f, +1.0f, 0.0f)); 271 } 272 } 273 274 TestCase::IterateResult StencilCase::iterate (void) 275 { 276 const tcu::RenderTarget& renderTarget = m_context.getRenderContext().getRenderTarget(); 277 int depthBits = renderTarget.getDepthBits(); 278 int stencilBits = renderTarget.getStencilBits(); 279 280 int stencilStep = stencilBits == 8 ? 8 : 1; 281 int numStencilValues = (1<<stencilBits)/stencilStep + 1; 282 283 int gridSize = (int)deFloatCeil(deFloatSqrt((float)(numStencilValues+2))); 284 285 int width = deMin32(128, renderTarget.getWidth()); 286 int height = deMin32(128, renderTarget.getHeight()); 287 288 tcu::TestLog& log = m_testCtx.getLog(); 289 de::Random rnd (deStringHash(m_name.c_str())); 290 int viewportX = rnd.getInt(0, renderTarget.getWidth()-width); 291 int viewportY = rnd.getInt(0, renderTarget.getHeight()-height); 292 IVec4 viewport = IVec4(viewportX, viewportY, width, height); 293 294 tcu::Surface gles2Frame (width, height); 295 tcu::Surface refFrame (width, height); 296 GLenum gles2Error; 297 298 const char* failReason = DE_NULL; 299 300 // Get ops for stencil values 301 vector<vector<StencilOp> > ops(numStencilValues+2); 302 { 303 // Values from 0 to max 304 for (int ndx = 0; ndx < numStencilValues; ndx++) 305 genOps(ops[ndx], stencilBits, depthBits, deMin32(ndx*stencilStep, (1<<stencilBits)-1)); 306 307 // -1 and max+1 308 genOps(ops[numStencilValues+0], stencilBits, depthBits, 1<<stencilBits); 309 genOps(ops[numStencilValues+1], stencilBits, depthBits, -1); 310 } 311 312 // Compute cells: (x, y, w, h) 313 vector<IVec4> cells; 314 int cellWidth = width/gridSize; 315 int cellHeight = height/gridSize; 316 for (int y = 0; y < gridSize; y++) 317 for (int x = 0; x < gridSize; x++) 318 cells.push_back(IVec4(x*cellWidth, y*cellHeight, cellWidth, cellHeight)); 319 320 DE_ASSERT(ops.size() <= cells.size()); 321 322 // Execute for gles2 context 323 { 324 sglr::GLContext context(m_context.getRenderContext(), log, 0 /* don't log calls or program */, viewport); 325 326 m_shaderID = context.createProgram(&m_shader); 327 328 context.clearColor(1.0f, 0.0f, 0.0f, 1.0f); 329 context.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 330 331 for (int ndx = 0; ndx < (int)ops.size(); ndx++) 332 executeOps(context, cells[ndx], ops[ndx]); 333 334 visualizeStencil(context, stencilBits, stencilStep); 335 336 gles2Error = context.getError(); 337 context.readPixels(gles2Frame, 0, 0, width, height); 338 } 339 340 // Execute for reference context 341 { 342 sglr::ReferenceContextBuffers buffers (tcu::PixelFormat(8,8,8,renderTarget.getPixelFormat().alphaBits?8:0), renderTarget.getDepthBits(), renderTarget.getStencilBits(), width, height); 343 sglr::ReferenceContext context (sglr::ReferenceContextLimits(m_context.getRenderContext()), buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer()); 344 345 m_shaderID = context.createProgram(&m_shader); 346 347 context.clearColor(1.0f, 0.0f, 0.0f, 1.0f); 348 context.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 349 350 for (int ndx = 0; ndx < (int)ops.size(); ndx++) 351 executeOps(context, cells[ndx], ops[ndx]); 352 353 visualizeStencil(context, stencilBits, stencilStep); 354 355 context.readPixels(refFrame, 0, 0, width, height); 356 } 357 358 // Check error 359 bool errorCodeOk = (gles2Error == GL_NO_ERROR); 360 if (!errorCodeOk && !failReason) 361 failReason = "Got unexpected error"; 362 363 // Compare images 364 const float threshold = 0.02f; 365 bool imagesOk = tcu::fuzzyCompare(log, "ComparisonResult", "Image comparison result", refFrame, gles2Frame, threshold, tcu::COMPARE_LOG_RESULT); 366 367 if (!imagesOk && !failReason) 368 failReason = "Image comparison failed"; 369 370 // Store test result 371 bool isOk = errorCodeOk && imagesOk; 372 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 373 isOk ? "Pass" : failReason); 374 375 return STOP; 376 } 377 378 StencilTests::StencilTests (Context& context) 379 : TestCaseGroup(context, "stencil", "Stencil Tests") 380 { 381 } 382 383 StencilTests::~StencilTests (void) 384 { 385 } 386 387 typedef void (*GenStencilOpsFunc) (vector<StencilOp>& dst, int stencilBits, int depthBits, int targetStencil); 388 389 class SimpleStencilCase : public StencilCase 390 { 391 public: 392 SimpleStencilCase (Context& context, const char* name, const char* description, GenStencilOpsFunc genOpsFunc) 393 : StencilCase (context, name, description) 394 , m_genOps (genOpsFunc) 395 { 396 } 397 398 void genOps (vector<StencilOp>& dst, int stencilBits, int depthBits, int targetStencil) 399 { 400 m_genOps(dst, stencilBits, depthBits, targetStencil); 401 } 402 403 private: 404 GenStencilOpsFunc m_genOps; 405 }; 406 407 void StencilTests::init (void) 408 { 409 #define STENCIL_CASE(NAME, DESCRIPTION, GEN_OPS_BODY) \ 410 do { \ 411 struct Gen_##NAME { \ 412 static void genOps (vector<StencilOp>& dst, int stencilBits, int depthBits, int targetStencil) \ 413 { \ 414 DE_UNREF(stencilBits && depthBits); \ 415 GEN_OPS_BODY \ 416 } \ 417 }; \ 418 addChild(new SimpleStencilCase(m_context, #NAME, DESCRIPTION, Gen_##NAME::genOps)); \ 419 } while (deGetFalse()); 420 421 STENCIL_CASE(clear, "Stencil clear", 422 { 423 // \note Unused bits are set to 1, clear should mask them out 424 int mask = (1<<stencilBits)-1; 425 dst.push_back(StencilOp::clearStencil(targetStencil | ~mask)); 426 }); 427 428 // Replace in different points 429 STENCIL_CASE(stencil_fail_replace, "Set stencil on stencil fail", 430 { 431 dst.push_back(StencilOp::quad(GL_NEVER, targetStencil, GL_ALWAYS, 0.0f, GL_REPLACE, GL_KEEP, GL_KEEP)); 432 }); 433 STENCIL_CASE(depth_fail_replace, "Set stencil on depth fail", 434 { 435 dst.push_back(StencilOp::clearDepth(0.0f)); 436 dst.push_back(StencilOp::quad(GL_ALWAYS, targetStencil, GL_LESS, 0.5f, GL_KEEP, GL_REPLACE, GL_KEEP)); 437 }); 438 STENCIL_CASE(depth_pass_replace, "Set stencil on depth pass", 439 { 440 dst.push_back(StencilOp::quad(GL_ALWAYS, targetStencil, GL_LESS, 0.0f, GL_KEEP, GL_KEEP, GL_REPLACE)); 441 }); 442 443 // Increment, decrement 444 STENCIL_CASE(incr_stencil_fail, "Increment on stencil fail", 445 { 446 if (targetStencil > 0) 447 { 448 dst.push_back(StencilOp::clearStencil(targetStencil-1)); 449 dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_INCR, GL_KEEP, GL_KEEP)); 450 } 451 else 452 dst.push_back(StencilOp::clearStencil(targetStencil)); 453 }); 454 STENCIL_CASE(decr_stencil_fail, "Decrement on stencil fail", 455 { 456 int maxStencil = (1<<stencilBits)-1; 457 if (targetStencil < maxStencil) 458 { 459 dst.push_back(StencilOp::clearStencil(targetStencil+1)); 460 dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_DECR, GL_KEEP, GL_KEEP)); 461 } 462 else 463 dst.push_back(StencilOp::clearStencil(targetStencil)); 464 }); 465 STENCIL_CASE(incr_wrap_stencil_fail, "Increment (wrap) on stencil fail", 466 { 467 int maxStencil = (1<<stencilBits)-1; 468 dst.push_back(StencilOp::clearStencil((targetStencil-1)&maxStencil)); 469 dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_INCR_WRAP, GL_KEEP, GL_KEEP)); 470 }); 471 STENCIL_CASE(decr_wrap_stencil_fail, "Decrement (wrap) on stencil fail", 472 { 473 int maxStencil = (1<<stencilBits)-1; 474 dst.push_back(StencilOp::clearStencil((targetStencil+1)&maxStencil)); 475 dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_DECR_WRAP, GL_KEEP, GL_KEEP)); 476 }); 477 478 // Zero, Invert 479 STENCIL_CASE(zero_stencil_fail, "Zero on stencil fail", 480 { 481 dst.push_back(StencilOp::clearStencil(targetStencil)); 482 dst.push_back(StencilOp::quad(GL_NOTEQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_ZERO, GL_KEEP, GL_KEEP)); 483 dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_REPLACE, GL_KEEP, GL_KEEP)); 484 }); 485 STENCIL_CASE(invert_stencil_fail, "Invert on stencil fail", 486 { 487 int mask = (1<<stencilBits)-1; 488 dst.push_back(StencilOp::clearStencil((~targetStencil)&mask)); 489 dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_INVERT, GL_KEEP, GL_KEEP)); 490 }); 491 492 // Comparison modes 493 STENCIL_CASE(cmp_equal, "Equality comparison", 494 { 495 int mask = (1<<stencilBits)-1; 496 int inv = (~targetStencil)&mask; 497 dst.push_back(StencilOp::clearStencil(inv)); 498 dst.push_back(StencilOp::quad(GL_EQUAL, inv, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT)); 499 dst.push_back(StencilOp::quad(GL_EQUAL, inv, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT)); 500 }); 501 STENCIL_CASE(cmp_not_equal, "Equality comparison", 502 { 503 int mask = (1<<stencilBits)-1; 504 int inv = (~targetStencil)&mask; 505 dst.push_back(StencilOp::clearStencil(inv)); 506 dst.push_back(StencilOp::quad(GL_NOTEQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT)); 507 dst.push_back(StencilOp::quad(GL_NOTEQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT)); 508 }); 509 STENCIL_CASE(cmp_less_than, "Less than comparison", 510 { 511 int maxStencil = (1<<stencilBits)-1; 512 if (targetStencil < maxStencil) 513 { 514 dst.push_back(StencilOp::clearStencil(targetStencil+1)); 515 dst.push_back(StencilOp::quad(GL_LESS, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_DECR)); 516 dst.push_back(StencilOp::quad(GL_LESS, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_DECR)); 517 } 518 else 519 dst.push_back(StencilOp::clearStencil(targetStencil)); 520 }); 521 STENCIL_CASE(cmp_less_or_equal, "Less or equal comparison", 522 { 523 int maxStencil = (1<<stencilBits)-1; 524 if (targetStencil < maxStencil) 525 { 526 dst.push_back(StencilOp::clearStencil(targetStencil+1)); 527 dst.push_back(StencilOp::quad(GL_LEQUAL, targetStencil+1, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_DECR)); 528 dst.push_back(StencilOp::quad(GL_LEQUAL, targetStencil+1, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_DECR)); 529 } 530 else 531 dst.push_back(StencilOp::clearStencil(targetStencil)); 532 }); 533 STENCIL_CASE(cmp_greater_than, "Greater than comparison", 534 { 535 if (targetStencil > 0) 536 { 537 dst.push_back(StencilOp::clearStencil(targetStencil-1)); 538 dst.push_back(StencilOp::quad(GL_GREATER, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INCR)); 539 dst.push_back(StencilOp::quad(GL_GREATER, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INCR)); 540 } 541 else 542 dst.push_back(StencilOp::clearStencil(targetStencil)); 543 }); 544 STENCIL_CASE(cmp_greater_or_equal, "Greater or equal comparison", 545 { 546 if (targetStencil > 0) 547 { 548 dst.push_back(StencilOp::clearStencil(targetStencil-1)); 549 dst.push_back(StencilOp::quad(GL_GEQUAL, targetStencil-1, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INCR)); 550 dst.push_back(StencilOp::quad(GL_GEQUAL, targetStencil-1, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INCR)); 551 } 552 else 553 dst.push_back(StencilOp::clearStencil(targetStencil)); 554 }); 555 STENCIL_CASE(cmp_mask_equal, "Equality comparison with mask", 556 { 557 int valMask = (1<<stencilBits)-1; 558 int mask = (1<<7)|(1<<5)|(1<<3)|(1<<1); 559 dst.push_back(StencilOp::clearStencil(~targetStencil)); 560 StencilOp op = StencilOp::quad(GL_EQUAL, (~targetStencil | ~mask) & valMask, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT); 561 op.stencilMask = mask; 562 dst.push_back(op); 563 }); 564 } 565 566 } // Functional 567 } // gles2 568 } // deqp 569
