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 Framebuffer Object Tests. 22 * 23 * Notes: 24 * + Like in API tests, tcu::sgl2s::Context class is used. 25 * + ReferenceContext is used to generate reference images. 26 * + API calls can be logged \todo [pyry] Implement. 27 *//*--------------------------------------------------------------------*/ 28 29#include "es2fFboRenderTest.hpp" 30#include "sglrContextUtil.hpp" 31#include "sglrGLContext.hpp" 32#include "sglrReferenceContext.hpp" 33#include "tcuSurface.hpp" 34#include "tcuTextureUtil.hpp" 35#include "tcuImageCompare.hpp" 36#include "tcuRenderTarget.hpp" 37#include "gluPixelTransfer.hpp" 38#include "gluTextureUtil.hpp" 39#include "gluStrUtil.hpp" 40#include "deRandom.h" 41#include "deString.h" 42 43#include "glwFunctions.hpp" 44#include "glwEnums.hpp" 45 46using std::vector; 47using std::string; 48using tcu::Vec2; 49using tcu::Vec3; 50using tcu::Vec4; 51using tcu::RGBA; 52using tcu::Surface; 53using namespace glw; // GL types 54 55namespace deqp 56{ 57namespace gles2 58{ 59namespace Functional 60{ 61 62// Shaders. 63 64class FlatColorShader : public sglr::ShaderProgram 65{ 66public: 67 FlatColorShader (void) 68 : sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration() 69 << sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT) 70 << sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT) 71 << sglr::pdec::Uniform("u_color", glu::TYPE_FLOAT_VEC4) 72 << sglr::pdec::VertexSource( 73 "attribute highp vec4 a_position;\n" 74 "void main (void)\n" 75 "{\n" 76 " gl_Position = a_position;\n" 77 "}\n") 78 << sglr::pdec::FragmentSource( 79 "uniform mediump vec4 u_color;\n" 80 "void main (void)\n" 81 "{\n" 82 " gl_FragColor = u_color;\n" 83 "}\n")) 84 { 85 } 86 87 void setColor (sglr::Context& gl, deUint32 program, const tcu::Vec4& color) 88 { 89 gl.useProgram(program); 90 gl.uniform4fv(gl.getUniformLocation(program, "u_color"), 1, color.getPtr()); 91 } 92 93 void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const 94 { 95 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx) 96 packets[packetNdx]->position = rr::readVertexAttribFloat(inputs[0], packets[packetNdx]->instanceNdx, packets[packetNdx]->vertexNdx); 97 } 98 99 void shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const 100 { 101 const tcu::Vec4 color(m_uniforms[0].value.f4); 102 103 DE_UNREF(packets); 104 105 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx) 106 for (int fragNdx = 0; fragNdx < 4; ++fragNdx) 107 rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color); 108 } 109}; 110 111class SingleTex2DShader : public sglr::ShaderProgram 112{ 113public: 114 SingleTex2DShader (void) 115 : sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration() 116 << sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT) 117 << sglr::pdec::VertexAttribute("a_coord", rr::GENERICVECTYPE_FLOAT) 118 << sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT) 119 << sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT) 120 << sglr::pdec::Uniform("u_sampler0", glu::TYPE_SAMPLER_2D) 121 << sglr::pdec::VertexSource( 122 "attribute highp vec4 a_position;\n" 123 "attribute mediump vec2 a_coord;\n" 124 "varying mediump vec2 v_coord;\n" 125 "void main (void)\n" 126 "{\n" 127 " gl_Position = a_position;\n" 128 " v_coord = a_coord;\n" 129 "}\n") 130 << sglr::pdec::FragmentSource( 131 "uniform sampler2D u_sampler0;\n" 132 "varying mediump vec2 v_coord;\n" 133 "void main (void)\n" 134 "{\n" 135 " gl_FragColor = texture2D(u_sampler0, v_coord);\n" 136 "}\n")) 137 { 138 } 139 140 void setUnit (sglr::Context& gl, deUint32 program, int unitNdx) 141 { 142 gl.useProgram(program); 143 gl.uniform1i(gl.getUniformLocation(program, "u_sampler0"), unitNdx); 144 } 145 146 void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const 147 { 148 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx) 149 { 150 rr::VertexPacket& packet = *packets[packetNdx]; 151 152 packet.position = rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx); 153 packet.outputs[0] = rr::readVertexAttribFloat(inputs[1], packet.instanceNdx, packet.vertexNdx); 154 } 155 } 156 157 void shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const 158 { 159 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx) 160 for (int fragNdx = 0; fragNdx < 4; ++fragNdx) 161 { 162 const tcu::Vec4 v_coord = rr::readVarying<float>(packets[packetNdx], context, 0, fragNdx); 163 const float lod = 0.0f; 164 165 rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, this->m_uniforms[0].sampler.tex2D->sample(v_coord.x(), v_coord.y(), lod)); 166 } 167 } 168 169}; 170 171class MixTexturesShader : public sglr::ShaderProgram 172{ 173public: 174 MixTexturesShader (void) 175 : sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration() 176 << sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT) 177 << sglr::pdec::VertexAttribute("a_coord", rr::GENERICVECTYPE_FLOAT) 178 << sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT) 179 << sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT) 180 << sglr::pdec::Uniform("u_sampler0", glu::TYPE_SAMPLER_2D) 181 << sglr::pdec::Uniform("u_sampler1", glu::TYPE_SAMPLER_2D) 182 << sglr::pdec::VertexSource( 183 "attribute highp vec4 a_position;\n" 184 "attribute mediump vec2 a_coord;\n" 185 "varying mediump vec2 v_coord;\n" 186 "void main (void)\n" 187 "{\n" 188 " gl_Position = a_position;\n" 189 " v_coord = a_coord;\n" 190 "}\n") 191 << sglr::pdec::FragmentSource( 192 "uniform sampler2D u_sampler0;\n" 193 "uniform sampler2D u_sampler1;\n" 194 "varying mediump vec2 v_coord;\n" 195 "void main (void)\n" 196 "{\n" 197 " gl_FragColor = texture2D(u_sampler0, v_coord)*0.5 + texture2D(u_sampler1, v_coord)*0.5;\n" 198 "}\n")) 199 { 200 } 201 202 void setUnits (sglr::Context& gl, deUint32 program, int unit0, int unit1) 203 { 204 gl.useProgram(program); 205 gl.uniform1i(gl.getUniformLocation(program, "u_sampler0"), unit0); 206 gl.uniform1i(gl.getUniformLocation(program, "u_sampler1"), unit1); 207 } 208 209 void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const 210 { 211 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx) 212 { 213 rr::VertexPacket& packet = *packets[packetNdx]; 214 215 packet.position = rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx); 216 packet.outputs[0] = rr::readVertexAttribFloat(inputs[1], packet.instanceNdx, packet.vertexNdx); 217 } 218 } 219 220 void shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const 221 { 222 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx) 223 for (int fragNdx = 0; fragNdx < 4; ++fragNdx) 224 { 225 const tcu::Vec4 v_coord = rr::readVarying<float>(packets[packetNdx], context, 0, fragNdx); 226 const float lod = 0.0f; 227 228 rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, this->m_uniforms[0].sampler.tex2D->sample(v_coord.x(), v_coord.y(), lod) * 0.5f 229 + this->m_uniforms[1].sampler.tex2D->sample(v_coord.x(), v_coord.y(), lod) * 0.5f); 230 } 231 } 232}; 233 234// Framebuffer config. 235 236class FboConfig 237{ 238public: 239 FboConfig (void) 240 : colorbufferType (GL_NONE) 241 , colorbufferFormat (GL_NONE) 242 , depthbufferType (GL_NONE) 243 , depthbufferFormat (GL_NONE) 244 , stencilbufferType (GL_NONE) 245 , stencilbufferFormat (GL_NONE) 246 { 247 } 248 249 std::string getName (void) const; 250 251 GLenum colorbufferType; //!< GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP, GL_RENDERBUFFER 252 GLenum colorbufferFormat; //!< Internal format for color buffer texture or renderbuffer 253 254 GLenum depthbufferType; //!< GL_RENDERBUFFER 255 GLenum depthbufferFormat; 256 257 GLenum stencilbufferType; //!< GL_RENDERBUFFER 258 GLenum stencilbufferFormat; 259 260private: 261 static const char* getFormatName (GLenum format); 262}; 263 264const char* FboConfig::getFormatName (GLenum format) 265{ 266 switch (format) 267 { 268 case GL_RGB: return "rgb"; 269 case GL_RGBA: return "rgba"; 270 case GL_ALPHA: return "alpha"; 271 case GL_LUMINANCE: return "luminance"; 272 case GL_LUMINANCE_ALPHA: return "luminance_alpha"; 273 case GL_RGB565: return "rgb565"; 274 case GL_RGB5_A1: return "rgb5_a1"; 275 case GL_RGBA4: return "rgba4"; 276 case GL_RGBA16F: return "rgba16f"; 277 case GL_RGB16F: return "rgb16f"; 278 case GL_DEPTH_COMPONENT16: return "depth_component16"; 279 case GL_STENCIL_INDEX8: return "stencil_index8"; 280 default: DE_ASSERT(false); return DE_NULL; 281 } 282} 283 284std::string FboConfig::getName (void) const 285{ 286 std::string name = ""; 287 288 if (colorbufferType != GL_NONE) 289 { 290 switch (colorbufferType) 291 { 292 case GL_TEXTURE_2D: name += "tex2d_"; break; 293 case GL_TEXTURE_CUBE_MAP: name += "texcube_"; break; 294 case GL_RENDERBUFFER: name += "rbo_"; break; 295 default: DE_ASSERT(false); break; 296 } 297 name += getFormatName(colorbufferFormat); 298 } 299 300 if (depthbufferType != GL_NONE) 301 { 302 DE_ASSERT(depthbufferType == GL_RENDERBUFFER); 303 if (name.length() > 0) 304 name += "_"; 305 name += getFormatName(depthbufferFormat); 306 } 307 308 if (stencilbufferType != GL_NONE) 309 { 310 DE_ASSERT(stencilbufferType == GL_RENDERBUFFER); 311 if (name.length() > 0) 312 name += "_"; 313 name += getFormatName(stencilbufferFormat); 314 } 315 316 return name; 317} 318 319class FboIncompleteException : public tcu::TestError 320{ 321public: 322 FboIncompleteException (const FboConfig& config, GLenum reason, const char* file, int line); 323 virtual ~FboIncompleteException (void) throw() {} 324 325 const FboConfig& getConfig (void) const { return m_config; } 326 GLenum getReason (void) const { return m_reason; } 327 328private: 329 FboConfig m_config; 330 GLenum m_reason; 331}; 332 333static const char* getFboIncompleteReasonName (GLenum reason) 334{ 335 switch (reason) 336 { 337 case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT"; 338 case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"; 339 case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: return "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS"; 340 case GL_FRAMEBUFFER_UNSUPPORTED: return "GL_FRAMEBUFFER_UNSUPPORTED"; 341 case GL_FRAMEBUFFER_COMPLETE: return "GL_FRAMEBUFFER_COMPLETE"; 342 default: return "UNKNOWN"; 343 } 344} 345 346FboIncompleteException::FboIncompleteException (const FboConfig& config, GLenum reason, const char* file, int line) 347 : TestError("Framebuffer is not complete", getFboIncompleteReasonName(reason), file, line) 348 , m_config(config) 349 , m_reason(reason) 350{ 351} 352 353class Framebuffer 354{ 355public: 356 Framebuffer (sglr::Context& context, const FboConfig& config, int width, int height, deUint32 fbo = 0, deUint32 colorbuffer = 0, deUint32 depthbuffer = 0, deUint32 stencilbuffer = 0); 357 ~Framebuffer (void); 358 359 const FboConfig& getConfig (void) const { return m_config; } 360 deUint32 getFramebuffer (void) const { return m_framebuffer; } 361 deUint32 getColorbuffer (void) const { return m_colorbuffer; } 362 deUint32 getDepthbuffer (void) const { return m_depthbuffer; } 363 deUint32 getStencilbuffer (void) const { return m_stencilbuffer; } 364 365 void checkCompleteness (void); 366 367private: 368 void createRbo (deUint32& name, GLenum format, int width, int height); 369 void destroyBuffer (deUint32 name, GLenum type); 370 371 FboConfig m_config; 372 sglr::Context& m_context; 373 deUint32 m_framebuffer; 374 deUint32 m_colorbuffer; 375 deUint32 m_depthbuffer; 376 deUint32 m_stencilbuffer; 377}; 378 379static bool isExtensionSupported (sglr::Context& context, const char* name) 380{ 381 std::istringstream extensions(context.getString(GL_EXTENSIONS)); 382 std::string extension; 383 384 while (std::getline(extensions, extension, ' ')) 385 { 386 if (extension == name) 387 return true; 388 } 389 390 return false; 391} 392 393static void checkColorFormatSupport (sglr::Context& context, deUint32 sizedFormat) 394{ 395 switch (sizedFormat) 396 { 397 case GL_RGBA16F: 398 case GL_RGB16F: 399 case GL_RG16F: 400 case GL_R16F: 401 if (!isExtensionSupported(context, "GL_EXT_color_buffer_half_float")) 402 throw tcu::NotSupportedError("GL_EXT_color_buffer_half_float is not supported"); 403 404 default: 405 break; 406 } 407} 408 409Framebuffer::Framebuffer (sglr::Context& context, const FboConfig& config, int width, int height, deUint32 fbo, deUint32 colorbuffer, deUint32 depthbuffer, deUint32 stencilbuffer) 410 : m_config (config) 411 , m_context (context) 412 , m_framebuffer (fbo) 413 , m_colorbuffer (colorbuffer) 414 , m_depthbuffer (depthbuffer) 415 , m_stencilbuffer (stencilbuffer) 416{ 417 // Verify that color format is supported 418 checkColorFormatSupport(context, config.colorbufferFormat); 419 420 if (m_framebuffer == 0) 421 context.genFramebuffers(1, &m_framebuffer); 422 context.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer); 423 424 switch (m_config.colorbufferType) 425 { 426 case GL_TEXTURE_2D: 427 if (m_colorbuffer == 0) 428 context.genTextures(1, &m_colorbuffer); 429 context.bindTexture(GL_TEXTURE_2D, m_colorbuffer); 430 context.texImage2D(GL_TEXTURE_2D, 0, m_config.colorbufferFormat, width, height); 431 context.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 432 433 if (!deIsPowerOfTwo32(width) || !deIsPowerOfTwo32(height)) 434 { 435 // Set wrap mode to clamp for NPOT FBOs 436 context.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 437 context.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 438 } 439 440 context.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_colorbuffer, 0); 441 break; 442 443 case GL_TEXTURE_CUBE_MAP: 444 DE_ASSERT(!"TODO"); 445 break; 446 447 case GL_RENDERBUFFER: 448 createRbo(m_colorbuffer, m_config.colorbufferFormat, width, height); 449 context.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_colorbuffer); 450 break; 451 452 default: 453 DE_ASSERT(m_config.colorbufferType == GL_NONE); 454 break; 455 } 456 457 if (m_config.depthbufferType == GL_RENDERBUFFER) 458 { 459 createRbo(m_depthbuffer, m_config.depthbufferFormat, width, height); 460 context.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthbuffer); 461 } 462 else 463 DE_ASSERT(m_config.depthbufferType == GL_NONE); 464 465 if (m_config.stencilbufferType == GL_RENDERBUFFER) 466 { 467 createRbo(m_stencilbuffer, m_config.stencilbufferFormat, width, height); 468 context.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_stencilbuffer); 469 } 470 else 471 DE_ASSERT(m_config.stencilbufferType == GL_NONE); 472 473 context.bindFramebuffer(GL_FRAMEBUFFER, 0); 474} 475 476Framebuffer::~Framebuffer (void) 477{ 478 m_context.deleteFramebuffers(1, &m_framebuffer); 479 destroyBuffer(m_colorbuffer, m_config.colorbufferType); 480 destroyBuffer(m_depthbuffer, m_config.depthbufferType); 481 destroyBuffer(m_stencilbuffer, m_config.stencilbufferType); 482} 483 484void Framebuffer::checkCompleteness (void) 485{ 486 m_context.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer); 487 GLenum status = m_context.checkFramebufferStatus(GL_FRAMEBUFFER); 488 m_context.bindFramebuffer(GL_FRAMEBUFFER, 0); 489 if (status != GL_FRAMEBUFFER_COMPLETE) 490 throw FboIncompleteException(m_config, status, __FILE__, __LINE__); 491} 492 493void Framebuffer::createRbo (deUint32& name, GLenum format, int width, int height) 494{ 495 if (name == 0) 496 m_context.genRenderbuffers(1, &name); 497 m_context.bindRenderbuffer(GL_RENDERBUFFER, name); 498 m_context.renderbufferStorage(GL_RENDERBUFFER, format, width, height); 499} 500 501void Framebuffer::destroyBuffer (deUint32 name, GLenum type) 502{ 503 if (type == GL_TEXTURE_2D || type == GL_TEXTURE_CUBE_MAP) 504 m_context.deleteTextures(1, &name); 505 else if (type == GL_RENDERBUFFER) 506 m_context.deleteRenderbuffers(1, &name); 507 else 508 DE_ASSERT(type == GL_NONE); 509} 510 511static void createMetaballsTex2D (sglr::Context& context, deUint32 name, GLenum format, GLenum dataType, int width, int height) 512{ 513 tcu::TextureFormat texFormat = glu::mapGLTransferFormat(format, dataType); 514 tcu::TextureLevel level (texFormat, width, height); 515 516 tcu::fillWithMetaballs(level.getAccess(), 5, name ^ width ^ height); 517 518 context.bindTexture(GL_TEXTURE_2D, name); 519 context.texImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, dataType, level.getAccess().getDataPtr()); 520 context.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 521} 522 523static void createQuadsTex2D (sglr::Context& context, deUint32 name, GLenum format, GLenum dataType, int width, int height) 524{ 525 tcu::TextureFormat texFormat = glu::mapGLTransferFormat(format, dataType); 526 tcu::TextureLevel level (texFormat, width, height); 527 528 tcu::fillWithRGBAQuads(level.getAccess()); 529 530 context.bindTexture(GL_TEXTURE_2D, name); 531 context.texImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, dataType, level.getAccess().getDataPtr()); 532 context.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 533} 534 535class FboRenderCase : public TestCase 536{ 537public: 538 FboRenderCase (Context& context, const char* name, const char* description, const FboConfig& config); 539 virtual ~FboRenderCase (void) {} 540 541 virtual IterateResult iterate (void); 542 virtual void render (sglr::Context& fboContext, Surface& dst) = DE_NULL; 543 544 const FboConfig& getConfig (void) const { return m_config; } 545 546 static bool isConfigSupported (const FboConfig& config) { DE_UNREF(config); return true; } 547 548private: 549 FboConfig m_config; 550}; 551 552FboRenderCase::FboRenderCase (Context& context, const char* name, const char* description, const FboConfig& config) 553 : TestCase(context, name, description) 554 , m_config(config) 555{ 556} 557 558TestCase::IterateResult FboRenderCase::iterate (void) 559{ 560 Vec4 clearColor (0.125f, 0.25f, 0.5f, 1.0f); 561 glu::RenderContext& renderCtx = m_context.getRenderContext(); 562 const tcu::RenderTarget& renderTarget = m_context.getRenderTarget(); 563 tcu::TestLog& log = m_testCtx.getLog(); 564 const char* failReason = DE_NULL; 565 566 // Position & size for context 567 deRandom rnd; 568 deRandom_init(&rnd, deStringHash(getName())); 569 570 int width = deMin32(renderTarget.getWidth(), 128); 571 int height = deMin32(renderTarget.getHeight(), 128); 572 int xMax = renderTarget.getWidth()-width+1; 573 int yMax = renderTarget.getHeight()-height+1; 574 int x = deRandom_getUint32(&rnd) % xMax; 575 int y = deRandom_getUint32(&rnd) % yMax; 576 577 tcu::Surface gles2Frame (width, height); 578 tcu::Surface refFrame (width, height); 579 GLenum gles2Error; 580 GLenum refError; 581 582 // Render using GLES2 583 try 584 { 585 sglr::GLContext context(renderCtx, log, sglr::GLCONTEXT_LOG_CALLS, tcu::IVec4(x, y, width, height)); 586 587 context.clearColor(clearColor.x(), clearColor.y(), clearColor.z(), clearColor.w()); 588 context.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 589 590 render(context, gles2Frame); // Call actual render func 591 gles2Error = context.getError(); 592 } 593 catch (const FboIncompleteException& e) 594 { 595 if (e.getReason() == GL_FRAMEBUFFER_UNSUPPORTED) 596 { 597 // Mark test case as unsupported 598 log << e; 599 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not supported"); 600 return STOP; 601 } 602 else 603 throw; // Propagate error 604 } 605 606 // Render reference image 607 { 608 sglr::ReferenceContextBuffers buffers (tcu::PixelFormat(8,8,8,renderTarget.getPixelFormat().alphaBits?8:0), renderTarget.getDepthBits(), renderTarget.getStencilBits(), width, height); 609 sglr::ReferenceContext context (sglr::ReferenceContextLimits(renderCtx), buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer()); 610 611 context.clearColor(clearColor.x(), clearColor.y(), clearColor.z(), clearColor.w()); 612 context.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 613 614 render(context, refFrame); 615 refError = context.getError(); 616 } 617 618 // Compare error codes 619 bool errorCodesOk = (gles2Error == refError); 620 621 if (!errorCodesOk) 622 { 623 log << tcu::TestLog::Message << "Error code mismatch: got " << glu::getErrorStr(gles2Error) << ", expected " << glu::getErrorStr(refError) << tcu::TestLog::EndMessage; 624 failReason = "Got unexpected error"; 625 } 626 627 // Compare images 628 const float threshold = 0.02f; 629 bool imagesOk = tcu::fuzzyCompare(log, "ComparisonResult", "Image comparison result", refFrame, gles2Frame, threshold, tcu::COMPARE_LOG_RESULT); 630 631 if (!imagesOk && !failReason) 632 failReason = "Image comparison failed"; 633 634 // Store test result 635 bool isOk = errorCodesOk && imagesOk; 636 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 637 isOk ? "Pass" : failReason); 638 639 return STOP; 640} 641 642namespace FboCases 643{ 644 645class ColorClearsTest : public FboRenderCase 646{ 647public: 648 ColorClearsTest (Context& context, const FboConfig& config); 649 ~ColorClearsTest (void) {} 650 651 void render (sglr::Context& context, Surface& dst); 652}; 653 654ColorClearsTest::ColorClearsTest (Context& context, const FboConfig& config) 655 : FboRenderCase(context, config.getName().c_str(), "Color buffer clears", config) 656{ 657} 658 659void ColorClearsTest::render (sglr::Context& context, Surface& dst) 660{ 661 int width = 128; 662 int height = 128; 663 deRandom rnd; 664 665 deRandom_init(&rnd, 0); 666 667 // Create framebuffer 668 Framebuffer fbo(context, getConfig(), width, height); 669 fbo.checkCompleteness(); 670 671 // Clear fbo 672 context.bindFramebuffer(GL_FRAMEBUFFER, fbo.getFramebuffer()); 673 context.viewport(0, 0, width, height); 674 context.clearColor(0.0f, 0.0f, 0.0f, 1.0f); 675 context.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 676 677 // Enable scissor test. 678 context.enable(GL_SCISSOR_TEST); 679 680 // Do 10 random color clears 681 for (int i = 0; i < 15; i++) 682 { 683 int cX = (int)(deRandom_getUint32(&rnd) & 0x7fffffff) % width; 684 int cY = (int)(deRandom_getUint32(&rnd) & 0x7fffffff) % height; 685 int cWidth = (int)(deRandom_getUint32(&rnd) & 0x7fffffff) % (width-cX); 686 int cHeight = (int)(deRandom_getUint32(&rnd) & 0x7fffffff) % (height-cY); 687 Vec4 color = RGBA(deRandom_getUint32(&rnd)).toVec(); 688 689 context.scissor(cX, cY, cWidth, cHeight); 690 context.clearColor(color.x(), color.y(), color.z(), color.w()); 691 context.clear(GL_COLOR_BUFFER_BIT); 692 } 693 694 // Disable scissor. 695 context.disable(GL_SCISSOR_TEST); 696 697 if (fbo.getConfig().colorbufferType == GL_TEXTURE_2D) 698 { 699 // Unbind fbo 700 context.bindFramebuffer(GL_FRAMEBUFFER, 0); 701 702 // Draw to screen 703 SingleTex2DShader shader; 704 deUint32 shaderID = context.createProgram(&shader); 705 706 shader.setUnit(context, shaderID, 0); 707 708 context.bindTexture(GL_TEXTURE_2D, fbo.getColorbuffer()); 709 context.viewport(0, 0, context.getWidth(), context.getHeight()); 710 sglr::drawQuad(context, shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 711 712 // Read from screen 713 context.readPixels(dst, 0, 0, context.getWidth(), context.getHeight()); 714 } 715 else 716 { 717 // Read from fbo 718 context.readPixels(dst, 0, 0, width, height); 719 } 720} 721 722class IntersectingQuadsTest : public FboRenderCase 723{ 724public: 725 IntersectingQuadsTest (Context& context, const FboConfig& config, bool npot = false); 726 virtual ~IntersectingQuadsTest (void) {} 727 728 virtual void render (sglr::Context& context, Surface& dst); 729 730 static bool isConfigSupported (const FboConfig& config); 731 732private: 733 int m_fboWidth; 734 int m_fboHeight; 735}; 736 737class IntersectingQuadsNpotTest : public IntersectingQuadsTest 738{ 739public: 740 IntersectingQuadsNpotTest (Context& context, const FboConfig& config) 741 : IntersectingQuadsTest(context, config, true) 742 { 743 } 744}; 745 746IntersectingQuadsTest::IntersectingQuadsTest (Context& context, const FboConfig& config, bool npot) 747 : FboRenderCase (context, (string(npot ? "npot_" : "") + config.getName()).c_str(), "Intersecting textured quads", config) 748 , m_fboWidth (npot ? 127 : 128) 749 , m_fboHeight (npot ? 95 : 128) 750{ 751} 752 753bool IntersectingQuadsTest::isConfigSupported (const FboConfig& config) 754{ 755 // \note Disabled for stencil configurations since doesn't exercise stencil buffer 756 return config.depthbufferType != GL_NONE && 757 config.stencilbufferType == GL_NONE; 758} 759 760void IntersectingQuadsTest::render (sglr::Context& ctx, Surface& dst) 761{ 762 SingleTex2DShader texShader; 763 deUint32 texShaderID = ctx.createProgram(&texShader); 764 765 deUint32 metaballsTex = 1; 766 deUint32 quadsTex = 2; 767 768 createMetaballsTex2D(ctx, metaballsTex, GL_RGB, GL_UNSIGNED_BYTE, 64, 64); 769 createQuadsTex2D(ctx, quadsTex, GL_RGB, GL_UNSIGNED_BYTE, 64, 64); 770 771 int width = m_fboWidth; 772 int height = m_fboHeight; 773 Framebuffer fbo(ctx, getConfig(), width, height); 774 fbo.checkCompleteness(); 775 776 // Setup shaders 777 texShader.setUnit(ctx, texShaderID, 0); 778 779 // Draw scene 780 ctx.bindFramebuffer(GL_FRAMEBUFFER, fbo.getFramebuffer()); 781 ctx.viewport(0, 0, width, height); 782 ctx.clearColor(1.0f, 0.0f, 0.0f, 1.0f); 783 ctx.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 784 785 ctx.enable(GL_DEPTH_TEST); 786 787 ctx.bindTexture(GL_TEXTURE_2D, metaballsTex); 788 sglr::drawQuad(ctx, texShaderID, Vec3(-1.0f, -1.0f, -1.0f), Vec3(1.0f, 1.0f, 1.0f)); 789 790 ctx.bindTexture(GL_TEXTURE_2D, quadsTex); 791 sglr::drawQuad(ctx, texShaderID, Vec3(-1.0f, -1.0f, 1.0f), Vec3(1.0f, 1.0f, -1.0f)); 792 793 ctx.disable(GL_DEPTH_TEST); 794 795 if (fbo.getConfig().colorbufferType == GL_TEXTURE_2D) 796 { 797 // Unbind fbo 798 ctx.bindFramebuffer(GL_FRAMEBUFFER, 0); 799 800 // Draw to screen 801 ctx.bindTexture(GL_TEXTURE_2D, fbo.getColorbuffer()); 802 ctx.viewport(0, 0, ctx.getWidth(), ctx.getHeight()); 803 sglr::drawQuad(ctx, texShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 804 805 // Read from screen 806 ctx.readPixels(dst, 0, 0, ctx.getWidth(), ctx.getHeight()); 807 } 808 else 809 { 810 // Read from fbo 811 ctx.readPixels(dst, 0, 0, width, height); 812 } 813} 814 815class MixTest : public FboRenderCase 816{ 817public: 818 MixTest (Context& context, const FboConfig& config, bool npot = false); 819 virtual ~MixTest (void) {} 820 821 void render (sglr::Context& context, Surface& dst); 822 823 static bool isConfigSupported (const FboConfig& config); 824 825private: 826 int m_fboAWidth; 827 int m_fboAHeight; 828 int m_fboBWidth; 829 int m_fboBHeight; 830}; 831 832class MixNpotTest : public MixTest 833{ 834public: 835 MixNpotTest (Context& context, const FboConfig& config) 836 : MixTest(context, config, true) 837 { 838 } 839}; 840 841MixTest::MixTest (Context& context, const FboConfig& config, bool npot) 842 : FboRenderCase (context, (string(npot ? "mix_npot_" : "mix_") + config.getName()).c_str(), "Use two fbos as sources in draw operation", config) 843 , m_fboAWidth (npot ? 127 : 128) 844 , m_fboAHeight (npot ? 95 : 128) 845 , m_fboBWidth (npot ? 55 : 64) 846 , m_fboBHeight (npot ? 63 : 64) 847{ 848} 849 850bool MixTest::isConfigSupported (const FboConfig& config) 851{ 852 // \note Disabled for stencil configurations since doesn't exercise stencil buffer 853 return config.colorbufferType == GL_TEXTURE_2D && 854 config.stencilbufferType == GL_NONE; 855} 856 857void MixTest::render (sglr::Context& context, Surface& dst) 858{ 859 SingleTex2DShader singleTexShader; 860 MixTexturesShader mixShader; 861 862 deUint32 singleTexShaderID = context.createProgram(&singleTexShader); 863 deUint32 mixShaderID = context.createProgram(&mixShader); 864 865 // Texture with metaballs 866 deUint32 metaballsTex = 1; 867 context.pixelStorei(GL_UNPACK_ALIGNMENT, 1); 868 createMetaballsTex2D(context, metaballsTex, GL_RGB, GL_UNSIGNED_BYTE, 64, 64); 869 870 // Setup shaders 871 singleTexShader.setUnit(context, singleTexShaderID, 0); 872 mixShader.setUnits(context, mixShaderID, 0, 1); 873 874 // Fbo, quad with metaballs texture 875 Framebuffer fboA(context, getConfig(), m_fboAWidth, m_fboAHeight); 876 fboA.checkCompleteness(); 877 context.bindFramebuffer(GL_FRAMEBUFFER, fboA.getFramebuffer()); 878 context.viewport(0, 0, m_fboAWidth, m_fboAHeight); 879 context.clearColor(0.0f, 0.0f, 0.0f, 1.0f); 880 context.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 881 context.bindTexture(GL_TEXTURE_2D, metaballsTex); 882 sglr::drawQuad(context, singleTexShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 883 884 // Fbo, color clears 885 Framebuffer fboB(context, getConfig(), m_fboBWidth, m_fboBHeight); 886 fboB.checkCompleteness(); 887 context.bindFramebuffer(GL_FRAMEBUFFER, fboB.getFramebuffer()); 888 context.viewport(0, 0, m_fboBWidth, m_fboBHeight); 889 context.enable(GL_SCISSOR_TEST); 890 context.scissor(0, 0, 32, 64); 891 context.clearColor(1.0f, 0.0f, 0.0f, 1.0f); 892 context.clear(GL_COLOR_BUFFER_BIT); 893 context.scissor(32, 0, 32, 64); 894 context.clearColor(0.0f, 1.0f, 0.0f, 1.0f); 895 context.clear(GL_COLOR_BUFFER_BIT); 896 context.disable(GL_SCISSOR_TEST); 897 898 // Final mix op 899 context.activeTexture(GL_TEXTURE0); 900 context.bindTexture(GL_TEXTURE_2D, fboA.getColorbuffer()); 901 context.activeTexture(GL_TEXTURE1); 902 context.bindTexture(GL_TEXTURE_2D, fboB.getColorbuffer()); 903 context.bindFramebuffer(GL_FRAMEBUFFER, 0); 904 context.viewport(0, 0, context.getWidth(), context.getHeight()); 905 sglr::drawQuad(context, mixShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 906 907 context.readPixels(dst, 0, 0, context.getWidth(), context.getHeight()); 908} 909 910class BlendTest : public FboRenderCase 911{ 912public: 913 BlendTest (Context& context, const FboConfig& config, bool npot = false); 914 virtual ~BlendTest (void) {} 915 916 void render (sglr::Context& context, Surface& dst); 917 918 static bool isConfigSupported (const FboConfig& config); 919 920private: 921 int m_fboWidth; 922 int m_fboHeight; 923}; 924 925class BlendNpotTest : public BlendTest 926{ 927public: 928 BlendNpotTest (Context& context, const FboConfig& config) 929 : BlendTest(context, config, true) 930 { 931 } 932}; 933 934BlendTest::BlendTest (Context& context, const FboConfig& config, bool npot) 935 : FboRenderCase (context, (string(npot ? "blend_npot_" : "blend_") + config.getName()).c_str(), "Blend to fbo", config) 936 , m_fboWidth (npot ? 111 : 128) 937 , m_fboHeight (npot ? 122 : 128) 938{ 939} 940 941bool BlendTest::isConfigSupported (const FboConfig& config) 942{ 943 // \note Disabled for stencil configurations since doesn't exercise stencil buffer 944 return config.stencilbufferType == GL_NONE; 945} 946 947void BlendTest::render (sglr::Context& context, Surface& dst) 948{ 949 SingleTex2DShader shader; 950 deUint32 shaderID = context.createProgram(&shader); 951 int width = m_fboWidth; 952 int height = m_fboHeight; 953 deUint32 metaballsTex = 1; 954 955 createMetaballsTex2D(context, metaballsTex, GL_RGBA, GL_UNSIGNED_BYTE, 64, 64); 956 957 Framebuffer fbo(context, getConfig(), width, height); 958 fbo.checkCompleteness(); 959 960 shader.setUnit(context, shaderID, 0); 961 962 context.bindFramebuffer(GL_FRAMEBUFFER, fbo.getFramebuffer()); 963 context.viewport(0, 0, width, height); 964 context.bindTexture(GL_TEXTURE_2D, metaballsTex); 965 context.clearColor(0.6f, 0.0f, 0.6f, 1.0f); 966 context.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 967 968 context.enable(GL_BLEND); 969 context.blendEquation(GL_FUNC_ADD); 970 context.blendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ZERO, GL_ONE); 971 sglr::drawQuad(context, shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 972 context.disable(GL_BLEND); 973 974 if (fbo.getConfig().colorbufferType == GL_TEXTURE_2D) 975 { 976 context.bindFramebuffer(GL_FRAMEBUFFER, 0); 977 context.bindTexture(GL_TEXTURE_2D, fbo.getColorbuffer()); 978 context.viewport(0, 0, context.getWidth(), context.getHeight()); 979 sglr::drawQuad(context, shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 980 context.readPixels(dst, 0, 0, context.getWidth(), context.getHeight()); 981 } 982 else 983 context.readPixels(dst, 0, 0, width, height); 984} 985 986class StencilClearsTest : public FboRenderCase 987{ 988public: 989 StencilClearsTest (Context& context, const FboConfig& config); 990 virtual ~StencilClearsTest (void) {}; 991 992 void render (sglr::Context& context, Surface& dst); 993 994 static bool isConfigSupported (const FboConfig& config); 995}; 996 997StencilClearsTest::StencilClearsTest (Context& context, const FboConfig& config) 998 : FboRenderCase(context, config.getName().c_str(), "Stencil clears", config) 999{ 1000} 1001 1002void StencilClearsTest::render (sglr::Context& context, Surface& dst) 1003{ 1004 SingleTex2DShader shader; 1005 deUint32 shaderID = context.createProgram(&shader); 1006 int width = 128; 1007 int height = 128; 1008 deUint32 quadsTex = 1; 1009 deUint32 metaballsTex = 2; 1010 1011 createQuadsTex2D(context, quadsTex, GL_RGBA, GL_UNSIGNED_BYTE, width, height); 1012 createMetaballsTex2D(context, metaballsTex, GL_RGBA, GL_UNSIGNED_BYTE, width, height); 1013 1014 Framebuffer fbo(context, getConfig(), width, height); 1015 fbo.checkCompleteness(); 1016 1017 // Bind framebuffer and clear 1018 context.bindFramebuffer(GL_FRAMEBUFFER, fbo.getFramebuffer()); 1019 context.viewport(0, 0, width, height); 1020 context.clearColor(0.0f, 0.0f, 0.0f, 1.0f); 1021 context.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 1022 1023 // Do stencil clears 1024 context.enable(GL_SCISSOR_TEST); 1025 context.scissor(10, 16, 32, 120); 1026 context.clearStencil(1); 1027 context.clear(GL_STENCIL_BUFFER_BIT); 1028 context.scissor(16, 32, 100, 64); 1029 context.clearStencil(2); 1030 context.clear(GL_STENCIL_BUFFER_BIT); 1031 context.disable(GL_SCISSOR_TEST); 1032 1033 // Draw 2 textures with stecil tests 1034 context.activeTexture(GL_TEXTURE0); 1035 context.bindTexture(GL_TEXTURE_2D, quadsTex); 1036 context.activeTexture(GL_TEXTURE1); 1037 context.bindTexture(GL_TEXTURE_2D, metaballsTex); 1038 1039 context.enable(GL_STENCIL_TEST); 1040 context.stencilFunc(GL_EQUAL, 1, 0xffffffffu); 1041 shader.setUnit(context, shaderID, 0); 1042 sglr::drawQuad(context, shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1043 1044 context.stencilFunc(GL_EQUAL, 2, 0xffffffffu); 1045 shader.setUnit(context, shaderID, 1); 1046 sglr::drawQuad(context, shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1047 1048 context.disable(GL_STENCIL_TEST); 1049 1050 if (fbo.getConfig().colorbufferType == GL_TEXTURE_2D) 1051 { 1052 context.bindFramebuffer(GL_FRAMEBUFFER, 0); 1053 context.activeTexture(GL_TEXTURE0); 1054 context.bindTexture(GL_TEXTURE_2D, fbo.getColorbuffer()); 1055 context.viewport(0, 0, context.getWidth(), context.getHeight()); 1056 shader.setUnit(context, shaderID, 0); 1057 sglr::drawQuad(context, shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1058 context.readPixels(dst, 0, 0, context.getWidth(), context.getHeight()); 1059 } 1060 else 1061 context.readPixels(dst, 0, 0, width, height); 1062} 1063 1064bool StencilClearsTest::isConfigSupported (const FboConfig& config) 1065{ 1066 return config.stencilbufferType != GL_NONE; 1067} 1068 1069class StencilTest : public FboRenderCase 1070{ 1071public: 1072 StencilTest (Context& context, const FboConfig& config, bool npot = false); 1073 virtual ~StencilTest (void) {}; 1074 1075 void render (sglr::Context& context, Surface& dst); 1076 1077 static bool isConfigSupported (const FboConfig& config); 1078 1079private: 1080 int m_fboWidth; 1081 int m_fboHeight; 1082}; 1083 1084class StencilNpotTest : public StencilTest 1085{ 1086public: 1087 StencilNpotTest (Context& context, const FboConfig& config) 1088 : StencilTest(context, config, true) 1089 { 1090 } 1091}; 1092 1093StencilTest::StencilTest (Context& context, const FboConfig& config, bool npot) 1094 : FboRenderCase (context, (string(npot ? "npot_" : "") + config.getName()).c_str(), "Stencil ops", config) 1095 , m_fboWidth (npot ? 99 : 128) 1096 , m_fboHeight (npot ? 110 : 128) 1097{ 1098} 1099 1100bool StencilTest::isConfigSupported (const FboConfig& config) 1101{ 1102 return config.stencilbufferType != GL_NONE; 1103} 1104 1105void StencilTest::render (sglr::Context& ctx, Surface& dst) 1106{ 1107 FlatColorShader colorShader; 1108 SingleTex2DShader texShader; 1109 deUint32 colorShaderID = ctx.createProgram(&colorShader); 1110 deUint32 texShaderID = ctx.createProgram(&texShader); 1111 int width = m_fboWidth; 1112 int height = m_fboHeight; 1113 int texWidth = 64; 1114 int texHeight = 64; 1115 deUint32 quadsTex = 1; 1116 deUint32 metaballsTex = 2; 1117 bool depth = getConfig().depthbufferType != GL_NONE; 1118 1119 createQuadsTex2D(ctx, quadsTex, GL_RGB, GL_UNSIGNED_BYTE, texWidth, texHeight); 1120 createMetaballsTex2D(ctx, metaballsTex, GL_RGB, GL_UNSIGNED_BYTE, texWidth, texHeight); 1121 1122 Framebuffer fbo(ctx, getConfig(), width, height); 1123 fbo.checkCompleteness(); 1124 1125 // Bind framebuffer and clear 1126 ctx.bindFramebuffer(GL_FRAMEBUFFER, fbo.getFramebuffer()); 1127 ctx.viewport(0, 0, width, height); 1128 ctx.clearColor(0.0f, 0.0f, 0.0f, 1.0f); 1129 ctx.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 1130 1131 // Render intersecting quads - increment stencil on depth pass 1132 ctx.enable(GL_DEPTH_TEST); 1133 ctx.enable(GL_STENCIL_TEST); 1134 ctx.stencilFunc(GL_ALWAYS, 0, 0xffu); 1135 ctx.stencilOp(GL_KEEP, GL_KEEP, GL_INCR); 1136 1137 colorShader.setColor(ctx, colorShaderID, Vec4(0.0f, 0.0f, 1.0f, 1.0f)); 1138 sglr::drawQuad(ctx, colorShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(+1.0f, +1.0f, 0.0f)); 1139 1140 ctx.bindTexture(GL_TEXTURE_2D, quadsTex); 1141 texShader.setUnit(ctx, texShaderID, 0); 1142 sglr::drawQuad(ctx, texShaderID, Vec3(-1.0f, -1.0f, -1.0f), Vec3(+1.0f, +1.0f, +1.0f)); 1143 1144 // Draw quad with stencil test (stencil == 1 or 2 depending on depth) - decrement on stencil failure 1145 ctx.disable(GL_DEPTH_TEST); 1146 ctx.stencilFunc(GL_EQUAL, depth ? 2 : 1, 0xffu); 1147 ctx.stencilOp(GL_DECR, GL_KEEP, GL_KEEP); 1148 colorShader.setColor(ctx, colorShaderID, Vec4(0.0f, 1.0f, 0.0f, 1.0f)); 1149 sglr::drawQuad(ctx, colorShaderID, Vec3(-0.5f, -0.5f, 0.0f), Vec3(+0.5f, +0.5f, 0.0f)); 1150 1151 // Draw metaballs with stencil test where stencil > 1 or 2 depending on depth buffer 1152 ctx.bindTexture(GL_TEXTURE_2D, metaballsTex); 1153 ctx.stencilFunc(GL_GREATER, depth ? 1 : 2, 0xffu); 1154 ctx.stencilOp(GL_KEEP, GL_KEEP, GL_KEEP); 1155 sglr::drawQuad(ctx, texShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(+1.0f, +1.0f, 0.0f)); 1156 1157 ctx.disable(GL_STENCIL_TEST); 1158 1159 if (fbo.getConfig().colorbufferType == GL_TEXTURE_2D) 1160 { 1161 ctx.bindFramebuffer(GL_FRAMEBUFFER, 0); 1162 ctx.activeTexture(GL_TEXTURE0); 1163 ctx.bindTexture(GL_TEXTURE_2D, fbo.getColorbuffer()); 1164 ctx.viewport(0, 0, ctx.getWidth(), ctx.getHeight()); 1165 sglr::drawQuad(ctx, texShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1166 ctx.readPixels(dst, 0, 0, ctx.getWidth(), ctx.getHeight()); 1167 } 1168 else 1169 ctx.readPixels(dst, 0, 0, width, height); 1170} 1171 1172class SharedColorbufferTest : public FboRenderCase 1173{ 1174public: 1175 SharedColorbufferTest (Context& context, const FboConfig& config); 1176 virtual ~SharedColorbufferTest (void) {}; 1177 1178 void render (sglr::Context& context, Surface& dst); 1179}; 1180 1181SharedColorbufferTest::SharedColorbufferTest (Context& context, const FboConfig& config) 1182 : FboRenderCase(context, config.getName().c_str(), "Shared colorbuffer", config) 1183{ 1184} 1185 1186void SharedColorbufferTest::render (sglr::Context& context, Surface& dst) 1187{ 1188 SingleTex2DShader shader; 1189 deUint32 shaderID = context.createProgram(&shader); 1190 int width = 128; 1191 int height = 128; 1192// bool depth = getConfig().depthbufferFormat != GL_NONE; 1193 bool stencil = getConfig().stencilbufferFormat != GL_NONE; 1194 1195 // Textures 1196 deUint32 quadsTex = 1; 1197 deUint32 metaballsTex = 2; 1198 createQuadsTex2D(context, quadsTex, GL_RGB, GL_UNSIGNED_BYTE, 64, 64); 1199 createMetaballsTex2D(context, metaballsTex, GL_RGBA, GL_UNSIGNED_BYTE, 64, 64); 1200 1201 context.viewport(0, 0, width, height); 1202 1203 shader.setUnit(context, shaderID, 0); 1204 1205 // Fbo A 1206 Framebuffer fboA(context, getConfig(), width, height); 1207 fboA.checkCompleteness(); 1208 1209 // Fbo B - don't create colorbuffer 1210 FboConfig cfg = getConfig(); 1211 cfg.colorbufferType = GL_NONE; 1212 cfg.colorbufferFormat = GL_NONE; 1213 Framebuffer fboB(context, cfg, width, height); 1214 1215 // Attach color buffer from fbo A 1216 context.bindFramebuffer(GL_FRAMEBUFFER, fboB.getFramebuffer()); 1217 switch (getConfig().colorbufferType) 1218 { 1219 case GL_TEXTURE_2D: 1220 context.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fboA.getColorbuffer(), 0); 1221 break; 1222 1223 case GL_RENDERBUFFER: 1224 context.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, fboA.getColorbuffer()); 1225 break; 1226 1227 default: 1228 DE_ASSERT(false); 1229 } 1230 1231 // Clear depth and stencil in fbo B 1232 context.clear(GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 1233 1234 // Render quads to fbo 1, with depth 0.0 1235 context.bindFramebuffer(GL_FRAMEBUFFER, fboA.getFramebuffer()); 1236 context.bindTexture(GL_TEXTURE_2D, quadsTex); 1237 context.clearColor(0.0f, 0.0f, 0.0f, 1.0f); 1238 context.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 1239 1240 if (stencil) 1241 { 1242 // Stencil to 1 in fbo A 1243 context.clearStencil(1); 1244 context.clear(GL_STENCIL_BUFFER_BIT); 1245 } 1246 1247 context.enable(GL_DEPTH_TEST); 1248 sglr::drawQuad(context, shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1249 context.disable(GL_DEPTH_TEST); 1250 1251 // Blend metaballs to fbo 2 1252 context.bindFramebuffer(GL_FRAMEBUFFER, fboB.getFramebuffer()); 1253 context.bindTexture(GL_TEXTURE_2D, metaballsTex); 1254 context.enable(GL_BLEND); 1255 context.blendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ZERO, GL_ONE); 1256 sglr::drawQuad(context, shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1257 1258 // Render small quad that is only visible if depth buffer is not shared with fbo A - or there is no depth bits 1259 context.bindTexture(GL_TEXTURE_2D, quadsTex); 1260 context.enable(GL_DEPTH_TEST); 1261 sglr::drawQuad(context, shaderID, Vec3(0.5f, 0.5f, 0.5f), Vec3(1.0f, 1.0f, 0.5f)); 1262 context.disable(GL_DEPTH_TEST); 1263 1264 if (stencil) 1265 { 1266 FlatColorShader flatShader; 1267 deUint32 flatShaderID = context.createProgram(&flatShader); 1268 1269 flatShader.setColor(context, flatShaderID, Vec4(0.0f, 1.0f, 0.0f, 1.0f)); 1270 1271 // Clear subset of stencil buffer to 1 1272 context.enable(GL_SCISSOR_TEST); 1273 context.scissor(10, 10, 12, 25); 1274 context.clearStencil(1); 1275 context.clear(GL_STENCIL_BUFFER_BIT); 1276 context.disable(GL_SCISSOR_TEST); 1277 1278 // Render quad with stencil mask == 1 1279 context.enable(GL_STENCIL_TEST); 1280 context.stencilFunc(GL_EQUAL, 1, 0xffu); 1281 sglr::drawQuad(context, flatShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1282 context.disable(GL_STENCIL_TEST); 1283 } 1284 1285 // Get results 1286 if (fboA.getConfig().colorbufferType == GL_TEXTURE_2D) 1287 { 1288 context.bindFramebuffer(GL_FRAMEBUFFER, 0); 1289 context.bindTexture(GL_TEXTURE_2D, fboA.getColorbuffer()); 1290 context.viewport(0, 0, context.getWidth(), context.getHeight()); 1291 sglr::drawQuad(context, shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1292 context.readPixels(dst, 0, 0, context.getWidth(), context.getHeight()); 1293 } 1294 else 1295 context.readPixels(dst, 0, 0, width, height); 1296} 1297 1298class SharedColorbufferClearsTest : public FboRenderCase 1299{ 1300public: 1301 SharedColorbufferClearsTest (Context& context, const FboConfig& config); 1302 virtual ~SharedColorbufferClearsTest (void) {} 1303 1304 static bool isConfigSupported (const FboConfig& config); 1305 void render (sglr::Context& context, Surface& dst); 1306}; 1307 1308SharedColorbufferClearsTest::SharedColorbufferClearsTest (Context& context, const FboConfig& config) 1309 : FboRenderCase(context, config.getName().c_str(), "Shared colorbuffer clears", config) 1310{ 1311} 1312 1313bool SharedColorbufferClearsTest::isConfigSupported (const FboConfig& config) 1314{ 1315 return config.colorbufferType != GL_NONE && 1316 config.depthbufferType == GL_NONE && 1317 config.stencilbufferType == GL_NONE; 1318} 1319 1320void SharedColorbufferClearsTest::render (sglr::Context& context, Surface& dst) 1321{ 1322 int width = 128; 1323 int height = 128; 1324 deUint32 colorbuffer = 1; 1325 1326 checkColorFormatSupport(context, getConfig().colorbufferFormat); 1327 1328 // Single colorbuffer 1329 if (getConfig().colorbufferType == GL_TEXTURE_2D) 1330 { 1331 context.bindTexture(GL_TEXTURE_2D, colorbuffer); 1332 context.texImage2D(GL_TEXTURE_2D, 0, getConfig().colorbufferFormat, width, height); 1333 context.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 1334 } 1335 else 1336 { 1337 DE_ASSERT(getConfig().colorbufferType == GL_RENDERBUFFER); 1338 context.bindRenderbuffer(GL_RENDERBUFFER, colorbuffer); 1339 context.renderbufferStorage(GL_RENDERBUFFER, getConfig().colorbufferFormat, width, height); 1340 } 1341 1342 // Multiple framebuffers sharing the colorbuffer 1343 for (int fbo = 1; fbo <= 3; fbo++) 1344 { 1345 context.bindFramebuffer(GL_FRAMEBUFFER, fbo); 1346 1347 if (getConfig().colorbufferType == GL_TEXTURE_2D) 1348 context.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorbuffer, 0); 1349 else 1350 context.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, colorbuffer); 1351 } 1352 1353 context.bindFramebuffer(GL_FRAMEBUFFER, 1); 1354 1355 // Check completeness 1356 { 1357 GLenum status = context.checkFramebufferStatus(GL_FRAMEBUFFER); 1358 if (status != GL_FRAMEBUFFER_COMPLETE) 1359 throw FboIncompleteException(getConfig(), status, __FILE__, __LINE__); 1360 } 1361 1362 // Render to them 1363 context.viewport(0, 0, width, height); 1364 context.clearColor(0.0f, 0.0f, 1.0f, 1.0f); 1365 context.clear(GL_COLOR_BUFFER_BIT); 1366 1367 context.enable(GL_SCISSOR_TEST); 1368 1369 context.bindFramebuffer(GL_FRAMEBUFFER, 2); 1370 context.clearColor(0.6f, 0.0f, 0.0f, 1.0f); 1371 context.scissor(10, 10, 64, 64); 1372 context.clear(GL_COLOR_BUFFER_BIT); 1373 context.clearColor(0.0f, 0.6f, 0.0f, 1.0f); 1374 context.scissor(60, 60, 40, 20); 1375 context.clear(GL_COLOR_BUFFER_BIT); 1376 1377 context.bindFramebuffer(GL_FRAMEBUFFER, 3); 1378 context.clearColor(0.0f, 0.0f, 0.6f, 1.0f); 1379 context.scissor(20, 20, 100, 10); 1380 context.clear(GL_COLOR_BUFFER_BIT); 1381 1382 context.bindFramebuffer(GL_FRAMEBUFFER, 1); 1383 context.clearColor(0.6f, 0.0f, 0.6f, 1.0f); 1384 context.scissor(20, 20, 5, 100); 1385 context.clear(GL_COLOR_BUFFER_BIT); 1386 1387 context.disable(GL_SCISSOR_TEST); 1388 1389 if (getConfig().colorbufferType == GL_TEXTURE_2D) 1390 { 1391 SingleTex2DShader shader; 1392 deUint32 shaderID = context.createProgram(&shader); 1393 1394 shader.setUnit(context, shaderID, 0); 1395 1396 context.bindFramebuffer(GL_FRAMEBUFFER, 0); 1397 context.viewport(0, 0, context.getWidth(), context.getHeight()); 1398 sglr::drawQuad(context, shaderID, Vec3(-0.9f, -0.9f, 0.0f), Vec3(0.9f, 0.9f, 0.0f)); 1399 context.readPixels(dst, 0, 0, context.getWidth(), context.getHeight()); 1400 } 1401 else 1402 context.readPixels(dst, 0, 0, width, height); 1403} 1404 1405class SharedDepthbufferTest : public FboRenderCase 1406{ 1407public: 1408 SharedDepthbufferTest (Context& context, const FboConfig& config); 1409 virtual ~SharedDepthbufferTest (void) {}; 1410 1411 static bool isConfigSupported (const FboConfig& config); 1412 void render (sglr::Context& context, Surface& dst); 1413}; 1414 1415SharedDepthbufferTest::SharedDepthbufferTest (Context& context, const FboConfig& config) 1416 : FboRenderCase(context, config.getName().c_str(), "Shared depthbuffer", config) 1417{ 1418} 1419 1420bool SharedDepthbufferTest::isConfigSupported (const FboConfig& config) 1421{ 1422 return config.depthbufferType == GL_RENDERBUFFER; 1423} 1424 1425void SharedDepthbufferTest::render (sglr::Context& context, Surface& dst) 1426{ 1427 SingleTex2DShader texShader; 1428 FlatColorShader colorShader; 1429 deUint32 texShaderID = context.createProgram(&texShader); 1430 deUint32 colorShaderID = context.createProgram(&colorShader); 1431 int width = 128; 1432 int height = 128; 1433 bool stencil = getConfig().stencilbufferType != GL_NONE; 1434 1435 // Setup shaders 1436 texShader.setUnit(context, texShaderID, 0); 1437 colorShader.setColor(context, colorShaderID, Vec4(0.0f, 1.0f, 0.0f, 1.0f)); 1438 1439 // Textures 1440 deUint32 metaballsTex = 5; 1441 deUint32 quadsTex = 6; 1442 createMetaballsTex2D(context, metaballsTex, GL_RGB, GL_UNSIGNED_BYTE, 64, 64); 1443 createQuadsTex2D(context, quadsTex, GL_RGB, GL_UNSIGNED_BYTE, 64, 64); 1444 1445 context.viewport(0, 0, width, height); 1446 1447 // Fbo A 1448 Framebuffer fboA(context, getConfig(), width, height); 1449 fboA.checkCompleteness(); 1450 1451 // Fbo B 1452 FboConfig cfg = getConfig(); 1453 cfg.depthbufferType = GL_NONE; 1454 cfg.depthbufferFormat = GL_NONE; 1455 Framebuffer fboB(context, cfg, width, height); 1456 1457 // Bind depth buffer from fbo A to fbo B 1458 DE_ASSERT(fboA.getConfig().depthbufferType == GL_RENDERBUFFER); 1459 context.bindFramebuffer(GL_FRAMEBUFFER, fboB.getFramebuffer()); 1460 context.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, fboA.getDepthbuffer()); 1461 1462 // Clear fbo B color to red and stencil to 1 1463 context.clearColor(1.0f, 0.0f, 0.0f, 1.0f); 1464 context.clearStencil(1); 1465 context.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 1466 1467 // Enable depth test. 1468 context.enable(GL_DEPTH_TEST); 1469 1470 // Render quad to fbo A 1471 context.bindFramebuffer(GL_FRAMEBUFFER, fboA.getFramebuffer()); 1472 context.bindTexture(GL_TEXTURE_2D, quadsTex); 1473 context.clearColor(0.0f, 0.0f, 0.0f, 1.0f); 1474 context.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 1475 sglr::drawQuad(context, texShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1476 1477 // Render metaballs to fbo B 1478 context.bindFramebuffer(GL_FRAMEBUFFER, fboB.getFramebuffer()); 1479 context.bindTexture(GL_TEXTURE_2D, metaballsTex); 1480 sglr::drawQuad(context, texShaderID, Vec3(-1.0f, -1.0f, -1.0f), Vec3(1.0f, 1.0f, 1.0f)); 1481 1482 context.disable(GL_DEPTH_TEST); 1483 1484 if (stencil) 1485 { 1486 // Clear subset of stencil buffer to 0 1487 context.enable(GL_SCISSOR_TEST); 1488 context.scissor(10, 10, 12, 25); 1489 context.clearStencil(0); 1490 context.clear(GL_STENCIL_BUFFER_BIT); 1491 context.disable(GL_SCISSOR_TEST); 1492 1493 // Render quad with stencil mask == 0 1494 context.enable(GL_STENCIL_TEST); 1495 context.stencilFunc(GL_EQUAL, 0, 0xffu); 1496 sglr::drawQuad(context, colorShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1497 context.disable(GL_STENCIL_TEST); 1498 } 1499 1500 if (getConfig().colorbufferType == GL_TEXTURE_2D) 1501 { 1502 // Render both to screen 1503 context.bindFramebuffer(GL_FRAMEBUFFER, 0); 1504 context.viewport(0, 0, context.getWidth(), context.getHeight()); 1505 context.bindTexture(GL_TEXTURE_2D, fboA.getColorbuffer()); 1506 sglr::drawQuad(context, texShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(0.0f, 1.0f, 0.0f)); 1507 context.bindTexture(GL_TEXTURE_2D, fboB.getColorbuffer()); 1508 sglr::drawQuad(context, texShaderID, Vec3(0.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1509 1510 context.readPixels(dst, 0, 0, context.getWidth(), context.getHeight()); 1511 } 1512 else 1513 { 1514 // Read results from fbo B 1515 context.readPixels(dst, 0, 0, width, height); 1516 } 1517} 1518 1519class TexSubImageAfterRenderTest : public FboRenderCase 1520{ 1521public: 1522 TexSubImageAfterRenderTest (Context& context, const FboConfig& config); 1523 virtual ~TexSubImageAfterRenderTest (void) {} 1524 1525 static bool isConfigSupported (const FboConfig& config); 1526 void render (sglr::Context& context, Surface& dst); 1527}; 1528 1529TexSubImageAfterRenderTest::TexSubImageAfterRenderTest (Context& context, const FboConfig& config) 1530 : FboRenderCase(context, (string("after_render_") + config.getName()).c_str(), "TexSubImage after rendering to texture", config) 1531{ 1532} 1533 1534bool TexSubImageAfterRenderTest::isConfigSupported (const FboConfig& config) 1535{ 1536 return config.colorbufferType == GL_TEXTURE_2D && 1537 (config.colorbufferFormat == GL_RGB || config.colorbufferFormat == GL_RGBA) && 1538 config.depthbufferType == GL_NONE && 1539 config.stencilbufferType == GL_NONE; 1540} 1541 1542void TexSubImageAfterRenderTest::render (sglr::Context& context, Surface& dst) 1543{ 1544 SingleTex2DShader shader; 1545 deUint32 shaderID = context.createProgram(&shader); 1546 bool isRGBA = getConfig().colorbufferFormat == GL_RGBA; 1547 1548 tcu::TextureLevel fourQuads(tcu::TextureFormat(tcu::TextureFormat::RGB, tcu::TextureFormat::UNORM_INT8), 64, 64); 1549 tcu::fillWithRGBAQuads(fourQuads.getAccess()); 1550 1551 tcu::TextureLevel metaballs(tcu::TextureFormat(isRGBA ? tcu::TextureFormat::RGBA : tcu::TextureFormat::RGB, tcu::TextureFormat::UNORM_INT8), 64, 64); 1552 tcu::fillWithMetaballs(metaballs.getAccess(), 5, 3); 1553 1554 shader.setUnit(context, shaderID, 0); 1555 1556 deUint32 fourQuadsTex = 1; 1557 context.bindTexture(GL_TEXTURE_2D, fourQuadsTex); 1558 context.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 1559 context.texImage2D(GL_TEXTURE_2D, 0, GL_RGB, 64, 64, 0, GL_RGB, GL_UNSIGNED_BYTE, fourQuads.getAccess().getDataPtr()); 1560 1561 context.bindFramebuffer(GL_FRAMEBUFFER, 1); 1562 1563 deUint32 fboTex = 2; 1564 context.bindTexture(GL_TEXTURE_2D, fboTex); 1565 context.texImage2D(GL_TEXTURE_2D, 0, isRGBA ? GL_RGBA : GL_RGB, 128, 128); 1566 context.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 1567 context.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fboTex, 0); 1568 1569 // Render to fbo 1570 context.viewport(0, 0, 128, 128); 1571 context.bindTexture(GL_TEXTURE_2D, fourQuadsTex); 1572 sglr::drawQuad(context, shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1573 1574 // Update texture using TexSubImage2D 1575 context.bindTexture(GL_TEXTURE_2D, fboTex); 1576 context.texSubImage2D(GL_TEXTURE_2D, 0, 32, 32, 64, 64, isRGBA ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE, metaballs.getAccess().getDataPtr()); 1577 1578 // Draw to screen 1579 context.bindFramebuffer(GL_FRAMEBUFFER, 0); 1580 context.viewport(0, 0, context.getWidth(), context.getHeight()); 1581 sglr::drawQuad(context, shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1582 context.readPixels(dst, 0, 0, context.getWidth(), context.getHeight()); 1583} 1584 1585class TexSubImageBetweenRenderTest : public FboRenderCase 1586{ 1587public: 1588 TexSubImageBetweenRenderTest (Context& context, const FboConfig& config); 1589 virtual ~TexSubImageBetweenRenderTest (void) {} 1590 1591 static bool isConfigSupported (const FboConfig& config); 1592 void render (sglr::Context& context, Surface& dst); 1593}; 1594 1595TexSubImageBetweenRenderTest::TexSubImageBetweenRenderTest (Context& context, const FboConfig& config) 1596 : FboRenderCase(context, (string("between_render_") + config.getName()).c_str(), "TexSubImage between rendering calls", config) 1597{ 1598} 1599 1600bool TexSubImageBetweenRenderTest::isConfigSupported (const FboConfig& config) 1601{ 1602 return config.colorbufferType == GL_TEXTURE_2D && 1603 (config.colorbufferFormat == GL_RGB || config.colorbufferFormat == GL_RGBA) && 1604 config.depthbufferType == GL_NONE && 1605 config.stencilbufferType == GL_NONE; 1606} 1607 1608void TexSubImageBetweenRenderTest::render (sglr::Context& context, Surface& dst) 1609{ 1610 SingleTex2DShader shader; 1611 deUint32 shaderID = context.createProgram(&shader); 1612 bool isRGBA = getConfig().colorbufferFormat == GL_RGBA; 1613 1614 tcu::TextureLevel fourQuads(tcu::TextureFormat(tcu::TextureFormat::RGB, tcu::TextureFormat::UNORM_INT8), 64, 64); 1615 tcu::fillWithRGBAQuads(fourQuads.getAccess()); 1616 1617 tcu::TextureLevel metaballs(tcu::TextureFormat(isRGBA ? tcu::TextureFormat::RGBA : tcu::TextureFormat::RGB, tcu::TextureFormat::UNORM_INT8), 64, 64); 1618 tcu::fillWithMetaballs(metaballs.getAccess(), 5, 3); 1619 1620 tcu::TextureLevel metaballs2(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), 64, 64); 1621 tcu::fillWithMetaballs(metaballs2.getAccess(), 5, 4); 1622 1623 deUint32 metaballsTex = 3; 1624 context.bindTexture(GL_TEXTURE_2D, metaballsTex); 1625 context.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 1626 context.texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, metaballs2.getAccess().getDataPtr()); 1627 1628 deUint32 fourQuadsTex = 1; 1629 context.bindTexture(GL_TEXTURE_2D, fourQuadsTex); 1630 context.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 1631 context.texImage2D(GL_TEXTURE_2D, 0, GL_RGB, 64, 64, 0, GL_RGB, GL_UNSIGNED_BYTE, fourQuads.getAccess().getDataPtr()); 1632 1633 context.bindFramebuffer(GL_FRAMEBUFFER, 1); 1634 1635 deUint32 fboTex = 2; 1636 context.bindTexture(GL_TEXTURE_2D, fboTex); 1637 context.texImage2D(GL_TEXTURE_2D, 0, isRGBA ? GL_RGBA : GL_RGB, 128, 128); 1638 context.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 1639 context.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fboTex, 0); 1640 1641 shader.setUnit(context, shaderID, 0); 1642 1643 // Render to fbo 1644 context.viewport(0, 0, 128, 128); 1645 context.bindTexture(GL_TEXTURE_2D, fourQuadsTex); 1646 sglr::drawQuad(context, shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1647 1648 // Update texture using TexSubImage2D 1649 context.bindTexture(GL_TEXTURE_2D, fboTex); 1650 context.texSubImage2D(GL_TEXTURE_2D, 0, 32, 32, 64, 64, isRGBA ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE, metaballs.getAccess().getDataPtr()); 1651 1652 // Render again to fbo 1653 context.bindTexture(GL_TEXTURE_2D, metaballsTex); 1654 context.enable(GL_BLEND); 1655 context.blendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ZERO, GL_ONE); 1656 sglr::drawQuad(context, shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1657 context.disable(GL_BLEND); 1658 1659 // Draw to screen 1660 context.bindFramebuffer(GL_FRAMEBUFFER, 0); 1661 context.viewport(0, 0, context.getWidth(), context.getHeight()); 1662 context.bindTexture(GL_TEXTURE_2D, fboTex); 1663 sglr::drawQuad(context, shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1664 1665 context.readPixels(dst, 0, 0, context.getWidth(), context.getHeight()); 1666} 1667 1668class ResizeTest : public FboRenderCase 1669{ 1670public: 1671 ResizeTest (Context& context, const FboConfig& config); 1672 virtual ~ResizeTest (void) {} 1673 1674 void render (sglr::Context& context, Surface& dst); 1675}; 1676 1677ResizeTest::ResizeTest (Context& context, const FboConfig& config) 1678 : FboRenderCase(context, config.getName().c_str(), "Resize framebuffer", config) 1679{ 1680} 1681 1682void ResizeTest::render (sglr::Context& context, Surface& dst) 1683{ 1684 SingleTex2DShader texShader; 1685 FlatColorShader colorShader; 1686 deUint32 texShaderID = context.createProgram(&texShader); 1687 deUint32 colorShaderID = context.createProgram(&colorShader); 1688 deUint32 quadsTex = 1; 1689 deUint32 metaballsTex = 2; 1690 bool depth = getConfig().depthbufferType != GL_NONE; 1691 bool stencil = getConfig().stencilbufferType != GL_NONE; 1692 1693 createQuadsTex2D(context, quadsTex, GL_RGB, GL_UNSIGNED_BYTE, 64, 64); 1694 createMetaballsTex2D(context, metaballsTex, GL_RGB, GL_UNSIGNED_BYTE, 32, 32); 1695 1696 Framebuffer fbo(context, getConfig(), 128, 128); 1697 fbo.checkCompleteness(); 1698 1699 // Setup shaders 1700 texShader.setUnit(context, texShaderID, 0); 1701 colorShader.setColor(context, colorShaderID, Vec4(0.0f, 1.0f, 0.0f, 1.0f)); 1702 1703 // Render quads 1704 context.bindFramebuffer(GL_FRAMEBUFFER, fbo.getFramebuffer()); 1705 context.viewport(0, 0, 128, 128); 1706 context.clearColor(0.0f, 0.0f, 0.0f, 1.0f); 1707 context.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 1708 context.bindTexture(GL_TEXTURE_2D, quadsTex); 1709 sglr::drawQuad(context, texShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1710 1711 if (fbo.getConfig().colorbufferType == GL_TEXTURE_2D) 1712 { 1713 // Render fbo to screen 1714 context.bindFramebuffer(GL_FRAMEBUFFER, 0); 1715 context.viewport(0, 0, context.getWidth(), context.getHeight()); 1716 context.bindTexture(GL_TEXTURE_2D, fbo.getColorbuffer()); 1717 sglr::drawQuad(context, texShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1718 1719 // Restore binding 1720 context.bindFramebuffer(GL_FRAMEBUFFER, fbo.getFramebuffer()); 1721 } 1722 1723 int newWidth = 64; 1724 int newHeight = 32; 1725 1726 // Resize buffers 1727 switch (fbo.getConfig().colorbufferType) 1728 { 1729 case GL_TEXTURE_2D: 1730 context.bindTexture(GL_TEXTURE_2D, fbo.getColorbuffer()); 1731 context.texImage2D(GL_TEXTURE_2D, 0, fbo.getConfig().colorbufferFormat, newWidth, newHeight); 1732 break; 1733 1734 case GL_RENDERBUFFER: 1735 context.bindRenderbuffer(GL_RENDERBUFFER, fbo.getColorbuffer()); 1736 context.renderbufferStorage(GL_RENDERBUFFER, fbo.getConfig().colorbufferFormat, newWidth, newHeight); 1737 break; 1738 1739 default: 1740 DE_ASSERT(false); 1741 } 1742 1743 if (depth) 1744 { 1745 DE_ASSERT(fbo.getConfig().depthbufferType == GL_RENDERBUFFER); 1746 context.bindRenderbuffer(GL_RENDERBUFFER, fbo.getDepthbuffer()); 1747 context.renderbufferStorage(GL_RENDERBUFFER, fbo.getConfig().depthbufferFormat, newWidth, newHeight); 1748 } 1749 1750 if (stencil) 1751 { 1752 DE_ASSERT(fbo.getConfig().stencilbufferType == GL_RENDERBUFFER); 1753 context.bindRenderbuffer(GL_RENDERBUFFER, fbo.getStencilbuffer()); 1754 context.renderbufferStorage(GL_RENDERBUFFER, fbo.getConfig().stencilbufferFormat, newWidth, newHeight); 1755 } 1756 1757 // Render to resized fbo 1758 context.viewport(0, 0, newWidth, newHeight); 1759 context.clearColor(1.0f, 0.0f, 0.0f, 1.0f); 1760 context.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 1761 1762 context.enable(GL_DEPTH_TEST); 1763 1764 context.bindTexture(GL_TEXTURE_2D, metaballsTex); 1765 sglr::drawQuad(context, texShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(+1.0f, +1.0f, 0.0f)); 1766 1767 context.bindTexture(GL_TEXTURE_2D, quadsTex); 1768 sglr::drawQuad(context, texShaderID, Vec3(0.0f, 0.0f, -1.0f), Vec3(+1.0f, +1.0f, 1.0f)); 1769 1770 context.disable(GL_DEPTH_TEST); 1771 1772 if (stencil) 1773 { 1774 context.enable(GL_SCISSOR_TEST); 1775 context.scissor(10, 10, 5, 15); 1776 context.clearStencil(1); 1777 context.clear(GL_STENCIL_BUFFER_BIT); 1778 context.disable(GL_SCISSOR_TEST); 1779 1780 context.enable(GL_STENCIL_TEST); 1781 context.stencilFunc(GL_EQUAL, 1, 0xffu); 1782 sglr::drawQuad(context, colorShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(+1.0f, +1.0f, 0.0f)); 1783 context.disable(GL_STENCIL_TEST); 1784 } 1785 1786 if (getConfig().colorbufferType == GL_TEXTURE_2D) 1787 { 1788 context.bindFramebuffer(GL_FRAMEBUFFER, 0); 1789 context.viewport(0, 0, context.getWidth(), context.getHeight()); 1790 context.bindTexture(GL_TEXTURE_2D, fbo.getColorbuffer()); 1791 sglr::drawQuad(context, texShaderID, Vec3(-0.5f, -0.5f, 0.0f), Vec3(0.5f, 0.5f, 0.0f)); 1792 context.readPixels(dst, 0, 0, context.getWidth(), context.getHeight()); 1793 } 1794 else 1795 context.readPixels(dst, 0, 0, newWidth, newHeight); 1796} 1797 1798template <GLenum Buffers> 1799class RecreateBuffersTest : public FboRenderCase 1800{ 1801public: 1802 RecreateBuffersTest (Context& context, const FboConfig& config, bool rebind); 1803 virtual ~RecreateBuffersTest (void) {} 1804 1805 static bool isConfigSupported (const FboConfig& config); 1806 void render (sglr::Context& context, Surface& dst); 1807 1808private: 1809 bool m_rebind; 1810}; 1811 1812template <GLenum Buffers> 1813class RecreateBuffersNoRebindTest : public RecreateBuffersTest<Buffers> 1814{ 1815public: 1816 RecreateBuffersNoRebindTest (Context& context, const FboConfig& config) 1817 : RecreateBuffersTest<Buffers>(context, config, false) 1818 { 1819 } 1820}; 1821 1822template <GLenum Buffers> 1823class RecreateBuffersRebindTest : public RecreateBuffersTest<Buffers> 1824{ 1825public: 1826 RecreateBuffersRebindTest (Context& context, const FboConfig& config) 1827 : RecreateBuffersTest<Buffers>(context, config, true) 1828 { 1829 } 1830}; 1831 1832template <GLenum Buffers> 1833RecreateBuffersTest<Buffers>::RecreateBuffersTest (Context& context, const FboConfig& config, bool rebind) 1834 : FboRenderCase (context, (string(rebind ? "rebind_" : "no_rebind_") + config.getName()).c_str(), "Recreate buffers", config) 1835 , m_rebind (rebind) 1836{ 1837} 1838 1839template <GLenum Buffers> 1840bool RecreateBuffersTest<Buffers>::isConfigSupported (const FboConfig& config) 1841{ 1842 if ((Buffers & GL_COLOR_BUFFER_BIT) && config.colorbufferType == GL_NONE) 1843 return false; 1844 if ((Buffers & GL_DEPTH_BUFFER_BIT) && config.depthbufferType == GL_NONE) 1845 return false; 1846 if ((Buffers & GL_STENCIL_BUFFER_BIT) && config.stencilbufferType == GL_NONE) 1847 return false; 1848 return true; 1849} 1850 1851template <GLenum Buffers> 1852void RecreateBuffersTest<Buffers>::render (sglr::Context& ctx, Surface& dst) 1853{ 1854 SingleTex2DShader texShader; 1855 deUint32 texShaderID = ctx.createProgram(&texShader); 1856 int width = 128; 1857 int height = 128; 1858 deUint32 metaballsTex = 1; 1859 deUint32 quadsTex = 2; 1860 bool stencil = getConfig().stencilbufferType != GL_NONE; 1861 1862 createQuadsTex2D(ctx, quadsTex, GL_RGB, GL_UNSIGNED_BYTE, 64, 64); 1863 createMetaballsTex2D(ctx, metaballsTex, GL_RGB, GL_UNSIGNED_BYTE, 64, 64); 1864 1865 Framebuffer fbo(ctx, getConfig(), width, height); 1866 fbo.checkCompleteness(); 1867 1868 // Setup shader 1869 texShader.setUnit(ctx, texShaderID, 0); 1870 1871 // Draw scene 1872 ctx.bindFramebuffer(GL_FRAMEBUFFER, fbo.getFramebuffer()); 1873 ctx.viewport(0, 0, width, height); 1874 ctx.clearColor(1.0f, 0.0f, 0.0f, 1.0f); 1875 ctx.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 1876 1877 ctx.enable(GL_DEPTH_TEST); 1878 1879 ctx.bindTexture(GL_TEXTURE_2D, quadsTex); 1880 sglr::drawQuad(ctx, texShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1881 1882 if (stencil) 1883 { 1884 ctx.enable(GL_SCISSOR_TEST); 1885 ctx.scissor(width/4, height/4, width/2, height/2); 1886 ctx.clearStencil(1); 1887 ctx.clear(GL_STENCIL_BUFFER_BIT); 1888 ctx.disable(GL_SCISSOR_TEST); 1889 } 1890 1891 // Recreate buffers 1892 if (!m_rebind) 1893 ctx.bindFramebuffer(GL_FRAMEBUFFER, 0); 1894 1895 if (Buffers & GL_COLOR_BUFFER_BIT) 1896 { 1897 deUint32 colorbuf = fbo.getColorbuffer(); 1898 switch (fbo.getConfig().colorbufferType) 1899 { 1900 case GL_TEXTURE_2D: 1901 ctx.deleteTextures(1, &colorbuf); 1902 ctx.bindTexture(GL_TEXTURE_2D, colorbuf); 1903 ctx.texImage2D(GL_TEXTURE_2D, 0, fbo.getConfig().colorbufferFormat, width, height); 1904 ctx.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 1905 1906 if (m_rebind) 1907 ctx.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorbuf, 0); 1908 break; 1909 1910 case GL_RENDERBUFFER: 1911 ctx.deleteRenderbuffers(1, &colorbuf); 1912 ctx.bindRenderbuffer(GL_RENDERBUFFER, colorbuf); 1913 ctx.renderbufferStorage(GL_RENDERBUFFER, fbo.getConfig().colorbufferFormat, width, height); 1914 1915 if (m_rebind) 1916 ctx.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, colorbuf); 1917 break; 1918 1919 default: 1920 DE_ASSERT(false); 1921 } 1922 } 1923 1924 if (Buffers & GL_DEPTH_BUFFER_BIT) 1925 { 1926 deUint32 depthbuf = fbo.getDepthbuffer(); 1927 DE_ASSERT(fbo.getConfig().depthbufferType == GL_RENDERBUFFER); 1928 1929 ctx.deleteRenderbuffers(1, &depthbuf); 1930 ctx.bindRenderbuffer(GL_RENDERBUFFER, depthbuf); 1931 ctx.renderbufferStorage(GL_RENDERBUFFER, fbo.getConfig().depthbufferFormat, width, height); 1932 1933 if (m_rebind) 1934 ctx.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthbuf); 1935 } 1936 1937 if (Buffers & GL_STENCIL_BUFFER_BIT) 1938 { 1939 deUint32 stencilbuf = fbo.getStencilbuffer(); 1940 DE_ASSERT(fbo.getConfig().stencilbufferType == GL_RENDERBUFFER); 1941 1942 ctx.deleteRenderbuffers(1, &stencilbuf); 1943 ctx.bindRenderbuffer(GL_RENDERBUFFER, stencilbuf); 1944 ctx.renderbufferStorage(GL_RENDERBUFFER, fbo.getConfig().stencilbufferFormat, width, height); 1945 1946 if (m_rebind) 1947 ctx.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, stencilbuf); 1948 } 1949 1950 if (!m_rebind) 1951 ctx.bindFramebuffer(GL_FRAMEBUFFER, fbo.getFramebuffer()); 1952 1953 ctx.clearColor(0.0f, 0.0f, 1.0f, 0.0f); 1954 ctx.clearStencil(0); 1955 ctx.clear(Buffers); // \note Clear only buffers that were re-created 1956 1957 if (stencil) 1958 { 1959 // \note Stencil test enabled only if we have stencil buffer 1960 ctx.enable(GL_STENCIL_TEST); 1961 ctx.stencilFunc(GL_EQUAL, 0, 0xffu); 1962 } 1963 ctx.bindTexture(GL_TEXTURE_2D, metaballsTex); 1964 sglr::drawQuad(ctx, texShaderID, Vec3(-1.0f, -1.0f, 1.0f), Vec3(1.0f, 1.0f, -1.0f)); 1965 if (stencil) 1966 ctx.disable(GL_STENCIL_TEST); 1967 1968 ctx.disable(GL_DEPTH_TEST); 1969 1970 if (fbo.getConfig().colorbufferType == GL_TEXTURE_2D) 1971 { 1972 // Unbind fbo 1973 ctx.bindFramebuffer(GL_FRAMEBUFFER, 0); 1974 1975 // Draw to screen 1976 ctx.bindTexture(GL_TEXTURE_2D, fbo.getColorbuffer()); 1977 ctx.viewport(0, 0, ctx.getWidth(), ctx.getHeight()); 1978 sglr::drawQuad(ctx, texShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f)); 1979 1980 // Read from screen 1981 ctx.readPixels(dst, 0, 0, ctx.getWidth(), ctx.getHeight()); 1982 } 1983 else 1984 { 1985 // Read from fbo 1986 ctx.readPixels(dst, 0, 0, width, height); 1987 } 1988} 1989 1990} // FboCases 1991 1992FboRenderTestGroup::FboRenderTestGroup (Context& context) 1993 : TestCaseGroup(context, "render", "Rendering Tests") 1994{ 1995} 1996 1997FboRenderTestGroup::~FboRenderTestGroup (void) 1998{ 1999} 2000 2001namespace 2002{ 2003 2004struct TypeFormatPair 2005{ 2006 GLenum type; 2007 GLenum format; 2008}; 2009 2010template <typename CaseType> 2011void addChildVariants (deqp::gles2::TestCaseGroup* group) 2012{ 2013 TypeFormatPair colorbufferConfigs[] = 2014 { 2015// { GL_TEXTURE_2D, GL_ALPHA }, 2016// { GL_TEXTURE_2D, GL_LUMINANCE }, 2017// { GL_TEXTURE_2D, GL_LUMINANCE_ALPHA }, 2018 { GL_TEXTURE_2D, GL_RGB }, 2019 { GL_TEXTURE_2D, GL_RGBA }, 2020 { GL_RENDERBUFFER, GL_RGB565 }, 2021 { GL_RENDERBUFFER, GL_RGB5_A1 }, 2022 { GL_RENDERBUFFER, GL_RGBA4 }, 2023// { GL_RENDERBUFFER, GL_RGBA16F }, 2024// { GL_RENDERBUFFER, GL_RGB16F } 2025 }; 2026 TypeFormatPair depthbufferConfigs[] = 2027 { 2028 { GL_NONE, GL_NONE }, 2029 { GL_RENDERBUFFER, GL_DEPTH_COMPONENT16 } 2030 }; 2031 TypeFormatPair stencilbufferConfigs[] = 2032 { 2033 { GL_NONE, GL_NONE }, 2034 { GL_RENDERBUFFER, GL_STENCIL_INDEX8 } 2035 }; 2036 2037 for (int colorbufferNdx = 0; colorbufferNdx < DE_LENGTH_OF_ARRAY(colorbufferConfigs); colorbufferNdx++) 2038 for (int depthbufferNdx = 0; depthbufferNdx < DE_LENGTH_OF_ARRAY(depthbufferConfigs); depthbufferNdx++) 2039 for (int stencilbufferNdx = 0; stencilbufferNdx < DE_LENGTH_OF_ARRAY(stencilbufferConfigs); stencilbufferNdx++) 2040 { 2041 FboConfig config; 2042 config.colorbufferType = colorbufferConfigs[colorbufferNdx].type; 2043 config.colorbufferFormat = colorbufferConfigs[colorbufferNdx].format; 2044 config.depthbufferType = depthbufferConfigs[depthbufferNdx].type; 2045 config.depthbufferFormat = depthbufferConfigs[depthbufferNdx].format; 2046 config.stencilbufferType = stencilbufferConfigs[stencilbufferNdx].type; 2047 config.stencilbufferFormat = stencilbufferConfigs[stencilbufferNdx].format; 2048 2049 if (CaseType::isConfigSupported(config)) 2050 group->addChild(new CaseType(group->getContext(), config)); 2051 } 2052} 2053 2054template <typename CaseType> 2055void createChildGroup (deqp::gles2::TestCaseGroup* parent, const char* name, const char* description) 2056{ 2057 deqp::gles2::TestCaseGroup* tmpGroup = new deqp::gles2::TestCaseGroup(parent->getContext(), name, description); 2058 parent->addChild(tmpGroup); 2059 addChildVariants<CaseType>(tmpGroup); 2060} 2061 2062template <GLbitfield Buffers> 2063void createRecreateBuffersGroup (deqp::gles2::TestCaseGroup* parent, const char* name, const char* description) 2064{ 2065 deqp::gles2::TestCaseGroup* tmpGroup = new deqp::gles2::TestCaseGroup(parent->getContext(), name, description); 2066 parent->addChild(tmpGroup); 2067 addChildVariants<FboCases::RecreateBuffersRebindTest<Buffers> > (tmpGroup); 2068 addChildVariants<FboCases::RecreateBuffersNoRebindTest<Buffers> > (tmpGroup); 2069} 2070 2071} // anonymous 2072 2073void FboRenderTestGroup::init (void) 2074{ 2075 createChildGroup<FboCases::ColorClearsTest> (this, "color_clear", "Color buffer clears"); 2076 createChildGroup<FboCases::StencilClearsTest> (this, "stencil_clear", "Stencil buffer clears"); 2077 2078 deqp::gles2::TestCaseGroup* colorGroup = new deqp::gles2::TestCaseGroup(m_context, "color", "Color buffer tests"); 2079 addChild(colorGroup); 2080 addChildVariants<FboCases::MixTest> (colorGroup); 2081 addChildVariants<FboCases::MixNpotTest> (colorGroup); 2082 addChildVariants<FboCases::BlendTest> (colorGroup); 2083 addChildVariants<FboCases::BlendNpotTest> (colorGroup); 2084 2085 deqp::gles2::TestCaseGroup* depthGroup = new deqp::gles2::TestCaseGroup(m_context, "depth", "Depth bufer tests"); 2086 addChild(depthGroup); 2087 addChildVariants<FboCases::IntersectingQuadsTest> (depthGroup); 2088 addChildVariants<FboCases::IntersectingQuadsNpotTest> (depthGroup); 2089 2090 deqp::gles2::TestCaseGroup* stencilGroup = new deqp::gles2::TestCaseGroup(m_context, "stencil", "Stencil buffer tests"); 2091 addChild(stencilGroup); 2092 addChildVariants<FboCases::StencilTest> (stencilGroup); 2093 addChildVariants<FboCases::StencilNpotTest> (stencilGroup); 2094 2095 createChildGroup<FboCases::SharedColorbufferClearsTest> (this, "shared_colorbuffer_clear", "Shared colorbuffer clears"); 2096 createChildGroup<FboCases::SharedColorbufferTest> (this, "shared_colorbuffer", "Shared colorbuffer tests"); 2097 createChildGroup<FboCases::SharedDepthbufferTest> (this, "shared_depthbuffer", "Shared depthbuffer tests"); 2098 createChildGroup<FboCases::ResizeTest> (this, "resize", "FBO resize tests"); 2099 2100 createRecreateBuffersGroup<GL_COLOR_BUFFER_BIT> (this, "recreate_colorbuffer", "Recreate colorbuffer tests"); 2101 createRecreateBuffersGroup<GL_DEPTH_BUFFER_BIT> (this, "recreate_depthbuffer", "Recreate depthbuffer tests"); 2102 createRecreateBuffersGroup<GL_STENCIL_BUFFER_BIT> (this, "recreate_stencilbuffer", "Recreate stencilbuffer tests"); 2103 2104 deqp::gles2::TestCaseGroup* texSubImageGroup = new deqp::gles2::TestCaseGroup(m_context, "texsubimage", "TexSubImage interop with FBO colorbuffer texture"); 2105 addChild(texSubImageGroup); 2106 addChildVariants<FboCases::TexSubImageAfterRenderTest> (texSubImageGroup); 2107 addChildVariants<FboCases::TexSubImageBetweenRenderTest> (texSubImageGroup); 2108} 2109 2110} // Functional 2111} // gles2 2112} // deqp 2113