1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES Utilities 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 GL Rendering Context. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "sglrGLContext.hpp" 25 #include "sglrShaderProgram.hpp" 26 #include "gluPixelTransfer.hpp" 27 #include "gluTexture.hpp" 28 #include "gluCallLogWrapper.hpp" 29 #include "gluStrUtil.hpp" 30 #include "glwFunctions.hpp" 31 #include "glwEnums.hpp" 32 33 namespace sglr 34 { 35 36 using std::vector; 37 using std::string; 38 using tcu::TestLog; 39 using tcu::Vec4; 40 using tcu::TextureFormat; 41 42 GLContext::GLContext (const glu::RenderContext& context, tcu::TestLog& log, deUint32 logFlags, const tcu::IVec4& baseViewport) 43 : Context (context.getType()) 44 , m_context (context) 45 , m_log (log) 46 , m_logFlags (logFlags) 47 , m_baseViewport (baseViewport) 48 , m_curViewport (0, 0, m_baseViewport.z(), m_baseViewport.w()) 49 , m_curScissor (0, 0, m_baseViewport.z(), m_baseViewport.w()) 50 , m_readFramebufferBinding (0) 51 , m_drawFramebufferBinding (0) 52 , m_wrapper (DE_NULL) 53 { 54 const glw::Functions& gl = m_context.getFunctions(); 55 56 // Logging? 57 m_wrapper = new glu::CallLogWrapper(gl, log); 58 m_wrapper->enableLogging((logFlags & GLCONTEXT_LOG_CALLS) != 0); 59 60 // Setup base viewport. This offset is active when default framebuffer is active. 61 // \note Calls related to setting up base viewport are not included in log. 62 gl.viewport(baseViewport.x(), baseViewport.y(), baseViewport.z(), baseViewport.w()); 63 } 64 65 GLContext::~GLContext (void) 66 { 67 const glw::Functions& gl = m_context.getFunctions(); 68 69 // Clean up all still alive objects 70 for (std::set<deUint32>::const_iterator i = m_allocatedFbos.begin(); 71 i != m_allocatedFbos.end(); i++) 72 { 73 deUint32 fbo = *i; 74 gl.deleteFramebuffers(1, &fbo); 75 } 76 77 for (std::set<deUint32>::const_iterator i = m_allocatedRbos.begin(); 78 i != m_allocatedRbos.end(); i++) 79 { 80 deUint32 rbo = *i; 81 gl.deleteRenderbuffers(1, &rbo); 82 } 83 84 for (std::set<deUint32>::const_iterator i = m_allocatedTextures.begin(); 85 i != m_allocatedTextures.end(); i++) 86 { 87 deUint32 tex = *i; 88 gl.deleteTextures(1, &tex); 89 } 90 91 for (std::set<deUint32>::const_iterator i = m_allocatedBuffers.begin(); 92 i != m_allocatedBuffers.end(); i++) 93 { 94 deUint32 buf = *i; 95 gl.deleteBuffers(1, &buf); 96 } 97 98 for (std::set<deUint32>::const_iterator i = m_allocatedVaos.begin(); 99 i != m_allocatedVaos.end(); i++) 100 { 101 deUint32 vao = *i; 102 gl.deleteVertexArrays(1, &vao); 103 } 104 105 for (std::vector<glu::ShaderProgram*>::iterator i = m_programs.begin(); 106 i != m_programs.end(); i++) 107 { 108 delete *i; 109 } 110 111 gl.useProgram(0); 112 113 delete m_wrapper; 114 } 115 116 void GLContext::enableLogging (deUint32 logFlags) 117 { 118 m_logFlags = logFlags; 119 m_wrapper->enableLogging((logFlags & GLCONTEXT_LOG_CALLS) != 0); 120 } 121 122 tcu::IVec2 GLContext::getDrawOffset (void) const 123 { 124 if (m_drawFramebufferBinding) 125 return tcu::IVec2(0, 0); 126 else 127 return tcu::IVec2(m_baseViewport.x(), m_baseViewport.y()); 128 } 129 130 tcu::IVec2 GLContext::getReadOffset (void) const 131 { 132 if (m_readFramebufferBinding) 133 return tcu::IVec2(0, 0); 134 else 135 return tcu::IVec2(m_baseViewport.x(), m_baseViewport.y()); 136 } 137 138 int GLContext::getWidth (void) const 139 { 140 return m_baseViewport.z(); 141 } 142 143 int GLContext::getHeight (void) const 144 { 145 return m_baseViewport.w(); 146 } 147 148 void GLContext::activeTexture (deUint32 texture) 149 { 150 m_wrapper->glActiveTexture(texture); 151 } 152 153 void GLContext::texParameteri (deUint32 target, deUint32 pname, int value) 154 { 155 m_wrapper->glTexParameteri(target, pname, value); 156 } 157 158 deUint32 GLContext::checkFramebufferStatus(deUint32 target) 159 { 160 return m_wrapper->glCheckFramebufferStatus(target); 161 } 162 163 void GLContext::viewport (int x, int y, int width, int height) 164 { 165 m_curViewport = tcu::IVec4(x, y, width, height); 166 tcu::IVec2 offset = getDrawOffset(); 167 168 // \note For clarity don't add the offset to log 169 if ((m_logFlags & GLCONTEXT_LOG_CALLS) != 0) 170 m_log << TestLog::Message << "glViewport(" << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage; 171 m_context.getFunctions().viewport(x+offset.x(), y+offset.y(), width, height); 172 } 173 174 void GLContext::bindTexture (deUint32 target, deUint32 texture) 175 { 176 m_allocatedTextures.insert(texture); 177 m_wrapper->glBindTexture(target, texture); 178 } 179 180 void GLContext::genTextures (int numTextures, deUint32* textures) 181 { 182 m_wrapper->glGenTextures(numTextures, textures); 183 if (numTextures > 0) 184 m_allocatedTextures.insert(textures, textures+numTextures); 185 } 186 187 void GLContext::deleteTextures (int numTextures, const deUint32* textures) 188 { 189 for (int i = 0; i < numTextures; i++) 190 m_allocatedTextures.erase(textures[i]); 191 m_wrapper->glDeleteTextures(numTextures, textures); 192 } 193 194 void GLContext::bindFramebuffer (deUint32 target, deUint32 framebuffer) 195 { 196 // \todo [2011-10-13 pyry] This is a bit of a hack since test cases assumes 0 default fbo. 197 deUint32 defaultFbo = m_context.getDefaultFramebuffer(); 198 TCU_CHECK(framebuffer == 0 || framebuffer != defaultFbo); 199 200 bool isValidTarget = target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER || target == GL_READ_FRAMEBUFFER; 201 202 if (isValidTarget && framebuffer != 0) 203 m_allocatedFbos.insert(framebuffer); 204 205 // Update bindings. 206 if (target == GL_FRAMEBUFFER || target == GL_READ_FRAMEBUFFER) 207 m_readFramebufferBinding = framebuffer; 208 209 if (target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER) 210 m_drawFramebufferBinding = framebuffer; 211 212 if (framebuffer == 0) // Redirect 0 to platform-defined default framebuffer. 213 m_wrapper->glBindFramebuffer(target, defaultFbo); 214 else 215 m_wrapper->glBindFramebuffer(target, framebuffer); 216 217 // Update viewport and scissor if we updated draw framebuffer binding \note Not logged for clarity 218 if (target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER) 219 { 220 tcu::IVec2 offset = getDrawOffset(); 221 m_context.getFunctions().viewport(m_curViewport.x()+offset.x(), m_curViewport.y()+offset.y(), m_curViewport.z(), m_curViewport.w()); 222 m_context.getFunctions().scissor(m_curScissor.x()+offset.x(), m_curScissor.y()+offset.y(), m_curScissor.z(), m_curScissor.w()); 223 } 224 } 225 226 void GLContext::genFramebuffers (int numFramebuffers, deUint32* framebuffers) 227 { 228 m_wrapper->glGenFramebuffers(numFramebuffers, framebuffers); 229 if (numFramebuffers > 0) 230 m_allocatedFbos.insert(framebuffers, framebuffers+numFramebuffers); 231 } 232 233 void GLContext::deleteFramebuffers (int numFramebuffers, const deUint32* framebuffers) 234 { 235 for (int i = 0; i < numFramebuffers; i++) 236 m_allocatedFbos.erase(framebuffers[i]); 237 m_wrapper->glDeleteFramebuffers(numFramebuffers, framebuffers); 238 } 239 240 void GLContext::bindRenderbuffer (deUint32 target, deUint32 renderbuffer) 241 { 242 m_allocatedRbos.insert(renderbuffer); 243 m_wrapper->glBindRenderbuffer(target, renderbuffer); 244 } 245 246 void GLContext::genRenderbuffers (int numRenderbuffers, deUint32* renderbuffers) 247 { 248 m_wrapper->glGenRenderbuffers(numRenderbuffers, renderbuffers); 249 if (numRenderbuffers > 0) 250 m_allocatedRbos.insert(renderbuffers, renderbuffers+numRenderbuffers); 251 } 252 253 void GLContext::deleteRenderbuffers (int numRenderbuffers, const deUint32* renderbuffers) 254 { 255 for (int i = 0; i < numRenderbuffers; i++) 256 m_allocatedRbos.erase(renderbuffers[i]); 257 m_wrapper->glDeleteRenderbuffers(numRenderbuffers, renderbuffers); 258 } 259 260 void GLContext::pixelStorei (deUint32 pname, int param) 261 { 262 m_wrapper->glPixelStorei(pname, param); 263 } 264 265 void GLContext::texImage1D (deUint32 target, int level, deUint32 internalFormat, int width, int border, deUint32 format, deUint32 type, const void* data) 266 { 267 m_wrapper->glTexImage1D(target, level, internalFormat, width, border, format, type, data); 268 } 269 270 void GLContext::texImage2D (deUint32 target, int level, deUint32 internalFormat, int width, int height, int border, deUint32 format, deUint32 type, const void* data) 271 { 272 m_wrapper->glTexImage2D(target, level, internalFormat, width, height, border, format, type, data); 273 } 274 275 void GLContext::texImage3D (deUint32 target, int level, deUint32 internalFormat, int width, int height, int depth, int border, deUint32 format, deUint32 type, const void* data) 276 { 277 m_wrapper->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, data); 278 } 279 280 void GLContext::texSubImage1D (deUint32 target, int level, int xoffset, int width, deUint32 format, deUint32 type, const void* data) 281 { 282 m_wrapper->glTexSubImage1D(target, level, xoffset, width, format, type, data); 283 } 284 285 void GLContext::texSubImage2D (deUint32 target, int level, int xoffset, int yoffset, int width, int height, deUint32 format, deUint32 type, const void* data) 286 { 287 m_wrapper->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, data); 288 } 289 290 void GLContext::texSubImage3D (deUint32 target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, deUint32 format, deUint32 type, const void* data) 291 { 292 m_wrapper->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data); 293 } 294 295 void GLContext::copyTexImage1D (deUint32 target, int level, deUint32 internalFormat, int x, int y, int width, int border) 296 { 297 // Don't log offset. 298 if ((m_logFlags & GLCONTEXT_LOG_CALLS) != 0) 299 m_log << TestLog::Message << "glCopyTexImage1D(" 300 << glu::getTextureTargetStr(target) << ", " 301 << level << ", " 302 << glu::getPixelFormatStr(internalFormat) << ", " 303 << x << ", " << y << ", " 304 << width << ", " << border << ")" 305 << TestLog::EndMessage; 306 307 tcu::IVec2 offset = getReadOffset(); 308 m_context.getFunctions().copyTexImage1D(target, level, internalFormat, offset.x()+x, offset.y()+y, width, border); 309 } 310 311 void GLContext::copyTexImage2D (deUint32 target, int level, deUint32 internalFormat, int x, int y, int width, int height, int border) 312 { 313 // Don't log offset. 314 if ((m_logFlags & GLCONTEXT_LOG_CALLS) != 0) 315 m_log << TestLog::Message << "glCopyTexImage2D(" 316 << glu::getTextureTargetStr(target) << ", " 317 << level << ", " 318 << glu::getPixelFormatStr(internalFormat) << ", " 319 << x << ", " << y << ", " 320 << width << ", " << height 321 << ", " << border << ")" 322 << TestLog::EndMessage; 323 324 tcu::IVec2 offset = getReadOffset(); 325 m_context.getFunctions().copyTexImage2D(target, level, internalFormat, offset.x()+x, offset.y()+y, width, height, border); 326 } 327 328 void GLContext::copyTexSubImage1D (deUint32 target, int level, int xoffset, int x, int y, int width) 329 { 330 if ((m_logFlags & GLCONTEXT_LOG_CALLS) != 0) 331 m_log << TestLog::Message << "glCopyTexSubImage1D(" 332 << glu::getTextureTargetStr(target) << ", " 333 << level << ", " 334 << xoffset << ", " 335 << x << ", " << y << ", " 336 << width << ")" 337 << TestLog::EndMessage; 338 339 tcu::IVec2 offset = getReadOffset(); 340 m_context.getFunctions().copyTexSubImage1D(target, level, xoffset, offset.x()+x, offset.y()+y, width); 341 } 342 343 void GLContext::copyTexSubImage2D (deUint32 target, int level, int xoffset, int yoffset, int x, int y, int width, int height) 344 { 345 if ((m_logFlags & GLCONTEXT_LOG_CALLS) != 0) 346 m_log << TestLog::Message << "glCopyTexSubImage2D(" 347 << glu::getTextureTargetStr(target) << ", " 348 << level 349 << ", " << xoffset << ", " << yoffset << ", " 350 << x << ", " << y << ", " 351 << width << ", " << height << ")" 352 << TestLog::EndMessage; 353 354 tcu::IVec2 offset = getReadOffset(); 355 m_context.getFunctions().copyTexSubImage2D(target, level, xoffset, yoffset, offset.x()+x, offset.y()+y, width, height); 356 } 357 358 void GLContext::copyTexSubImage3D (deUint32 target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height) 359 { 360 if ((m_logFlags & GLCONTEXT_LOG_CALLS) != 0) 361 m_log << TestLog::Message << "glCopyTexSubImage3D(" 362 << glu::getTextureTargetStr(target) << ", " 363 << level 364 << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " 365 << x << ", " << y << ", " 366 << width << ", " << height << ")" 367 << TestLog::EndMessage; 368 369 tcu::IVec2 offset = getReadOffset(); 370 m_context.getFunctions().copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, offset.x()+x, offset.y()+y, width, height); 371 } 372 373 void GLContext::texStorage2D (deUint32 target, int levels, deUint32 internalFormat, int width, int height) 374 { 375 m_wrapper->glTexStorage2D(target, levels, internalFormat, width, height); 376 } 377 378 void GLContext::texStorage3D (deUint32 target, int levels, deUint32 internalFormat, int width, int height, int depth) 379 { 380 m_wrapper->glTexStorage3D(target, levels, internalFormat, width, height, depth); 381 } 382 383 void GLContext::framebufferTexture2D (deUint32 target, deUint32 attachment, deUint32 textarget, deUint32 texture, int level) 384 { 385 m_wrapper->glFramebufferTexture2D(target, attachment, textarget, texture, level); 386 } 387 388 void GLContext::framebufferTextureLayer (deUint32 target, deUint32 attachment, deUint32 texture, int level, int layer) 389 { 390 m_wrapper->glFramebufferTextureLayer(target, attachment, texture, level, layer); 391 } 392 393 void GLContext::framebufferRenderbuffer (deUint32 target, deUint32 attachment, deUint32 renderbuffertarget, deUint32 renderbuffer) 394 { 395 m_wrapper->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); 396 } 397 398 void GLContext::getFramebufferAttachmentParameteriv (deUint32 target, deUint32 attachment, deUint32 pname, int* params) 399 { 400 m_wrapper->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); 401 } 402 403 void GLContext::renderbufferStorage (deUint32 target, deUint32 internalformat, int width, int height) 404 { 405 m_wrapper->glRenderbufferStorage(target, internalformat, width, height); 406 } 407 408 void GLContext::renderbufferStorageMultisample (deUint32 target, int samples, deUint32 internalFormat, int width, int height) 409 { 410 m_wrapper->glRenderbufferStorageMultisample(target, samples, internalFormat, width, height); 411 } 412 413 void GLContext::bindBuffer (deUint32 target, deUint32 buffer) 414 { 415 m_allocatedBuffers.insert(buffer); 416 m_wrapper->glBindBuffer(target, buffer); 417 } 418 419 void GLContext::genBuffers (int numBuffers, deUint32* buffers) 420 { 421 m_wrapper->glGenBuffers(numBuffers, buffers); 422 if (numBuffers > 0) 423 m_allocatedBuffers.insert(buffers, buffers+numBuffers); 424 } 425 426 void GLContext::deleteBuffers (int numBuffers, const deUint32* buffers) 427 { 428 m_wrapper->glDeleteBuffers(numBuffers, buffers); 429 for (int i = 0; i < numBuffers; i++) 430 m_allocatedBuffers.erase(buffers[i]); 431 } 432 433 void GLContext::bufferData (deUint32 target, deIntptr size, const void* data, deUint32 usage) 434 { 435 m_wrapper->glBufferData(target, (glw::GLsizeiptr)size, data, usage); 436 } 437 438 void GLContext::bufferSubData (deUint32 target, deIntptr offset, deIntptr size, const void* data) 439 { 440 m_wrapper->glBufferSubData(target, (glw::GLintptr)offset, (glw::GLsizeiptr)size, data); 441 } 442 443 void GLContext::clearColor (float red, float green, float blue, float alpha) 444 { 445 m_wrapper->glClearColor(red, green, blue, alpha); 446 } 447 448 void GLContext::clearDepthf (float depth) 449 { 450 m_wrapper->glClearDepthf(depth); 451 } 452 453 void GLContext::clearStencil (int stencil) 454 { 455 m_wrapper->glClearStencil(stencil); 456 } 457 458 void GLContext::clear (deUint32 buffers) 459 { 460 m_wrapper->glClear(buffers); 461 } 462 463 void GLContext::clearBufferiv (deUint32 buffer, int drawbuffer, const int* value) 464 { 465 m_wrapper->glClearBufferiv(buffer, drawbuffer, value); 466 } 467 468 void GLContext::clearBufferfv (deUint32 buffer, int drawbuffer, const float* value) 469 { 470 m_wrapper->glClearBufferfv(buffer, drawbuffer, value); 471 } 472 473 void GLContext::clearBufferuiv (deUint32 buffer, int drawbuffer, const deUint32* value) 474 { 475 m_wrapper->glClearBufferuiv(buffer, drawbuffer, value); 476 } 477 478 void GLContext::clearBufferfi (deUint32 buffer, int drawbuffer, float depth, int stencil) 479 { 480 m_wrapper->glClearBufferfi(buffer, drawbuffer, depth, stencil); 481 } 482 483 void GLContext::scissor (int x, int y, int width, int height) 484 { 485 m_curScissor = tcu::IVec4(x, y, width, height); 486 487 // \note For clarity don't add the offset to log 488 if ((m_logFlags & GLCONTEXT_LOG_CALLS) != 0) 489 m_log << TestLog::Message << "glScissor(" << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage; 490 491 tcu::IVec2 offset = getDrawOffset(); 492 m_context.getFunctions().scissor(offset.x()+x, offset.y()+y, width, height); 493 } 494 495 void GLContext::enable (deUint32 cap) 496 { 497 m_wrapper->glEnable(cap); 498 } 499 500 void GLContext::disable (deUint32 cap) 501 { 502 m_wrapper->glDisable(cap); 503 } 504 505 void GLContext::stencilFunc (deUint32 func, int ref, deUint32 mask) 506 { 507 m_wrapper->glStencilFunc(func, ref, mask); 508 } 509 510 void GLContext::stencilOp (deUint32 sfail, deUint32 dpfail, deUint32 dppass) 511 { 512 m_wrapper->glStencilOp(sfail, dpfail, dppass); 513 } 514 515 void GLContext::depthFunc (deUint32 func) 516 { 517 m_wrapper->glDepthFunc(func); 518 } 519 520 void GLContext::depthRangef (float n, float f) 521 { 522 m_wrapper->glDepthRangef(n, f); 523 } 524 525 void GLContext::depthRange (double n, double f) 526 { 527 m_wrapper->glDepthRange(n, f); 528 } 529 530 void GLContext::polygonOffset (float factor, float units) 531 { 532 m_wrapper->glPolygonOffset(factor, units); 533 } 534 535 void GLContext::provokingVertex (deUint32 convention) 536 { 537 m_wrapper->glProvokingVertex(convention); 538 } 539 540 void GLContext::primitiveRestartIndex (deUint32 index) 541 { 542 m_wrapper->glPrimitiveRestartIndex(index); 543 } 544 545 void GLContext::stencilFuncSeparate (deUint32 face, deUint32 func, int ref, deUint32 mask) 546 { 547 m_wrapper->glStencilFuncSeparate(face, func, ref, mask); 548 } 549 550 void GLContext::stencilOpSeparate (deUint32 face, deUint32 sfail, deUint32 dpfail, deUint32 dppass) 551 { 552 m_wrapper->glStencilOpSeparate(face, sfail, dpfail, dppass); 553 } 554 555 void GLContext::blendEquation (deUint32 mode) 556 { 557 m_wrapper->glBlendEquation(mode); 558 } 559 560 void GLContext::blendEquationSeparate (deUint32 modeRGB, deUint32 modeAlpha) 561 { 562 m_wrapper->glBlendEquationSeparate(modeRGB, modeAlpha); 563 } 564 565 void GLContext::blendFunc (deUint32 src, deUint32 dst) 566 { 567 m_wrapper->glBlendFunc(src, dst); 568 } 569 570 void GLContext::blendFuncSeparate (deUint32 srcRGB, deUint32 dstRGB, deUint32 srcAlpha, deUint32 dstAlpha) 571 { 572 m_wrapper->glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); 573 } 574 575 void GLContext::blendColor (float red, float green, float blue, float alpha) 576 { 577 m_wrapper->glBlendColor(red, green, blue, alpha); 578 } 579 580 void GLContext::colorMask (deBool r, deBool g, deBool b, deBool a) 581 { 582 m_wrapper->glColorMask(r, g, b, a); 583 } 584 585 void GLContext::depthMask (deBool mask) 586 { 587 m_wrapper->glDepthMask(mask); 588 } 589 590 void GLContext::stencilMask (deUint32 mask) 591 { 592 m_wrapper->glStencilMask(mask); 593 } 594 595 void GLContext::stencilMaskSeparate (deUint32 face, deUint32 mask) 596 { 597 m_wrapper->glStencilMaskSeparate(face, mask); 598 } 599 600 void GLContext::blitFramebuffer (int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, deUint32 mask, deUint32 filter) 601 { 602 tcu::IVec2 drawOffset = getDrawOffset(); 603 tcu::IVec2 readOffset = getReadOffset(); 604 605 if ((m_logFlags & GLCONTEXT_LOG_CALLS) != 0) 606 m_log << TestLog::Message << "glBlitFramebuffer(" 607 << srcX0 << ", " << srcY0 << ", " << srcX1 << ", " << srcY1 << ", " 608 << dstX0 << ", " << dstY0 << ", " << dstX1 << ", " << dstY1 << ", " 609 << glu::getBufferMaskStr(mask) << ", " 610 << glu::getTextureFilterStr(filter) << ")" 611 << TestLog::EndMessage; 612 613 m_context.getFunctions().blitFramebuffer(readOffset.x()+srcX0, readOffset.y()+srcY0, readOffset.x()+srcX1, readOffset.y()+srcY1, 614 drawOffset.x()+dstX0, drawOffset.y()+dstY0, drawOffset.x()+dstX1, drawOffset.y()+dstY1, 615 mask, filter); 616 } 617 618 void GLContext::invalidateSubFramebuffer (deUint32 target, int numAttachments, const deUint32* attachments, int x, int y, int width, int height) 619 { 620 tcu::IVec2 drawOffset = getDrawOffset(); 621 622 if ((m_logFlags & GLCONTEXT_LOG_CALLS) != 0) 623 m_log << TestLog::Message << "glInvalidateSubFramebuffer(" 624 << glu::getFramebufferTargetStr(target) << ", " << numAttachments << ", " 625 << glu::getInvalidateAttachmentStr(attachments, numAttachments) << ", " 626 << x << ", " << y << ", " << width << ", " << height << ")" 627 << TestLog::EndMessage; 628 629 m_context.getFunctions().invalidateSubFramebuffer(target, numAttachments, attachments, x+drawOffset.x(), y+drawOffset.y(), width, height); 630 } 631 632 void GLContext::invalidateFramebuffer (deUint32 target, int numAttachments, const deUint32* attachments) 633 { 634 m_wrapper->glInvalidateFramebuffer(target, numAttachments, attachments); 635 } 636 637 void GLContext::bindVertexArray (deUint32 array) 638 { 639 m_wrapper->glBindVertexArray(array); 640 } 641 642 void GLContext::genVertexArrays (int numArrays, deUint32* vertexArrays) 643 { 644 m_wrapper->glGenVertexArrays(numArrays, vertexArrays); 645 if (numArrays > 0) 646 m_allocatedVaos.insert(vertexArrays, vertexArrays+numArrays); 647 } 648 649 void GLContext::deleteVertexArrays (int numArrays, const deUint32* vertexArrays) 650 { 651 for (int i = 0; i < numArrays; i++) 652 m_allocatedVaos.erase(vertexArrays[i]); 653 m_wrapper->glDeleteVertexArrays(numArrays, vertexArrays); 654 } 655 656 void GLContext::vertexAttribPointer (deUint32 index, int size, deUint32 type, deBool normalized, int stride, const void *pointer) 657 { 658 m_wrapper->glVertexAttribPointer(index, size, type, normalized, stride, pointer); 659 } 660 661 void GLContext::vertexAttribIPointer (deUint32 index, int size, deUint32 type, int stride, const void *pointer) 662 { 663 m_wrapper->glVertexAttribIPointer(index, size, type, stride, pointer); 664 } 665 666 void GLContext::enableVertexAttribArray (deUint32 index) 667 { 668 m_wrapper->glEnableVertexAttribArray(index); 669 } 670 671 void GLContext::disableVertexAttribArray (deUint32 index) 672 { 673 m_wrapper->glDisableVertexAttribArray(index); 674 } 675 676 void GLContext::vertexAttribDivisor (deUint32 index, deUint32 divisor) 677 { 678 m_wrapper->glVertexAttribDivisor(index, divisor); 679 } 680 681 void GLContext::vertexAttrib1f (deUint32 index, float x) 682 { 683 m_wrapper->glVertexAttrib1f(index, x); 684 } 685 686 void GLContext::vertexAttrib2f (deUint32 index, float x, float y) 687 { 688 m_wrapper->glVertexAttrib2f(index, x, y); 689 } 690 691 void GLContext::vertexAttrib3f (deUint32 index, float x, float y, float z) 692 { 693 m_wrapper->glVertexAttrib3f(index, x, y, z); 694 } 695 696 void GLContext::vertexAttrib4f (deUint32 index, float x, float y, float z, float w) 697 { 698 m_wrapper->glVertexAttrib4f(index, x, y, z, w); 699 } 700 701 void GLContext::vertexAttribI4i (deUint32 index, deInt32 x, deInt32 y, deInt32 z, deInt32 w) 702 { 703 m_wrapper->glVertexAttribI4i(index, x, y, z, w); 704 } 705 706 void GLContext::vertexAttribI4ui (deUint32 index, deUint32 x, deUint32 y, deUint32 z, deUint32 w) 707 { 708 m_wrapper->glVertexAttribI4ui(index, x, y, z, w); 709 } 710 711 deInt32 GLContext::getAttribLocation (deUint32 program, const char *name) 712 { 713 return m_wrapper->glGetAttribLocation(program, name); 714 } 715 716 void GLContext::uniform1f (deInt32 location, float v0) 717 { 718 m_wrapper->glUniform1f(location, v0); 719 } 720 721 void GLContext::uniform1i (deInt32 location, deInt32 v0) 722 { 723 m_wrapper->glUniform1i(location, v0); 724 } 725 726 void GLContext::uniform1fv (deInt32 location, deInt32 count, const float* value) 727 { 728 m_wrapper->glUniform1fv(location, count, value); 729 } 730 731 void GLContext::uniform2fv (deInt32 location, deInt32 count, const float* value) 732 { 733 m_wrapper->glUniform2fv(location, count, value); 734 } 735 736 void GLContext::uniform3fv (deInt32 location, deInt32 count, const float* value) 737 { 738 m_wrapper->glUniform3fv(location, count, value); 739 } 740 741 void GLContext::uniform4fv (deInt32 location, deInt32 count, const float* value) 742 { 743 m_wrapper->glUniform4fv(location, count, value); 744 } 745 746 void GLContext::uniform1iv (deInt32 location, deInt32 count, const deInt32* value) 747 { 748 m_wrapper->glUniform1iv(location, count, value); 749 } 750 751 void GLContext::uniform2iv (deInt32 location, deInt32 count, const deInt32* value) 752 { 753 m_wrapper->glUniform2iv(location, count, value); 754 } 755 756 void GLContext::uniform3iv (deInt32 location, deInt32 count, const deInt32* value) 757 { 758 m_wrapper->glUniform3iv(location, count, value); 759 } 760 761 void GLContext::uniform4iv (deInt32 location, deInt32 count, const deInt32* value) 762 { 763 m_wrapper->glUniform4iv(location, count, value); 764 } 765 766 void GLContext::uniformMatrix3fv (deInt32 location, deInt32 count, deInt32 transpose, const float *value) 767 { 768 m_wrapper->glUniformMatrix3fv(location, count, transpose, value); 769 } 770 771 void GLContext::uniformMatrix4fv (deInt32 location, deInt32 count, deInt32 transpose, const float *value) 772 { 773 m_wrapper->glUniformMatrix4fv(location, count, transpose, value); 774 } 775 deInt32 GLContext::getUniformLocation (deUint32 program, const char *name) 776 { 777 return m_wrapper->glGetUniformLocation(program, name); 778 } 779 780 void GLContext::lineWidth (float w) 781 { 782 m_wrapper->glLineWidth(w); 783 } 784 785 void GLContext::drawArrays (deUint32 mode, int first, int count) 786 { 787 m_wrapper->glDrawArrays(mode, first, count); 788 } 789 790 void GLContext::drawArraysInstanced (deUint32 mode, int first, int count, int instanceCount) 791 { 792 m_wrapper->glDrawArraysInstanced(mode, first, count, instanceCount); 793 } 794 795 void GLContext::drawElements (deUint32 mode, int count, deUint32 type, const void *indices) 796 { 797 m_wrapper->glDrawElements(mode, count, type, indices); 798 } 799 800 void GLContext::drawElementsInstanced (deUint32 mode, int count, deUint32 type, const void *indices, int instanceCount) 801 { 802 m_wrapper->glDrawElementsInstanced(mode, count, type, indices, instanceCount); 803 } 804 805 void GLContext::drawElementsBaseVertex (deUint32 mode, int count, deUint32 type, const void *indices, int baseVertex) 806 { 807 m_wrapper->glDrawElementsBaseVertex(mode, count, type, indices, baseVertex); 808 } 809 810 void GLContext::drawElementsInstancedBaseVertex (deUint32 mode, int count, deUint32 type, const void *indices, int instanceCount, int baseVertex) 811 { 812 m_wrapper->glDrawElementsInstancedBaseVertex(mode, count, type, indices, instanceCount, baseVertex); 813 } 814 815 void GLContext::drawRangeElements (deUint32 mode, deUint32 start, deUint32 end, int count, deUint32 type, const void *indices) 816 { 817 m_wrapper->glDrawRangeElements(mode, start, end, count, type, indices); 818 } 819 820 void GLContext::drawRangeElementsBaseVertex (deUint32 mode, deUint32 start, deUint32 end, int count, deUint32 type, const void *indices, int baseVertex) 821 { 822 m_wrapper->glDrawRangeElementsBaseVertex(mode, start, end, count, type, indices, baseVertex); 823 } 824 825 void GLContext::drawArraysIndirect (deUint32 mode, const void *indirect) 826 { 827 m_wrapper->glDrawArraysIndirect(mode, indirect); 828 } 829 830 void GLContext::drawElementsIndirect (deUint32 mode, deUint32 type, const void *indirect) 831 { 832 m_wrapper->glDrawElementsIndirect(mode, type, indirect); 833 } 834 835 void GLContext::multiDrawArrays (deUint32 mode, const int* first, const int* count, int primCount) 836 { 837 m_wrapper->glMultiDrawArrays(mode, first, count, primCount); 838 } 839 840 void GLContext::multiDrawElements (deUint32 mode, const int* count, deUint32 type, const void** indices, int primCount) 841 { 842 m_wrapper->glMultiDrawElements(mode, count, type, indices, primCount); 843 } 844 845 void GLContext::multiDrawElementsBaseVertex (deUint32 mode, const int* count, deUint32 type, const void** indices, int primCount, const int* baseVertex) 846 { 847 m_wrapper->glMultiDrawElementsBaseVertex(mode, count, type, indices, primCount, baseVertex); 848 } 849 850 deUint32 GLContext::createProgram (ShaderProgram* shader) 851 { 852 m_programs.reserve(m_programs.size()+1); 853 854 glu::ShaderProgram* program = DE_NULL; 855 856 if (!shader->m_hasGeometryShader) 857 program = new glu::ShaderProgram(m_context, glu::makeVtxFragSources(shader->m_vertSrc, shader->m_fragSrc)); 858 else 859 program = new glu::ShaderProgram(m_context, 860 glu::ProgramSources() << glu::VertexSource(shader->m_vertSrc) 861 << glu::FragmentSource(shader->m_fragSrc) 862 << glu::GeometrySource(shader->m_geomSrc)); 863 864 if (!program->isOk()) 865 { 866 m_log << *program; 867 delete program; 868 TCU_FAIL("Compile failed"); 869 } 870 871 if ((m_logFlags & GLCONTEXT_LOG_PROGRAMS) != 0) 872 m_log << *program; 873 874 m_programs.push_back(program); 875 return program->getProgram(); 876 } 877 878 void GLContext::deleteProgram (deUint32 program) 879 { 880 for (std::vector<glu::ShaderProgram*>::iterator i = m_programs.begin(); i != m_programs.end(); i++) 881 { 882 if ((*i)->getProgram() == program) 883 { 884 delete *i; 885 m_programs.erase(i); 886 return; 887 } 888 } 889 890 DE_ASSERT(!"invalid delete"); 891 } 892 893 void GLContext::useProgram (deUint32 program) 894 { 895 m_wrapper->glUseProgram(program); 896 } 897 898 void GLContext::readPixels (int x, int y, int width, int height, deUint32 format, deUint32 type, void* data) 899 { 900 // Don't log offset. 901 if ((m_logFlags & GLCONTEXT_LOG_CALLS) != 0) 902 m_log << TestLog::Message << "glReadPixels(" 903 << x << ", " << y << ", " << width << ", " << height << ", " 904 << glu::getPixelFormatStr(format) << ", " 905 << glu::getTypeStr(type) << ", " << data << ")" 906 << TestLog::EndMessage; 907 908 tcu::IVec2 offset = getReadOffset(); 909 m_context.getFunctions().readPixels(x+offset.x(), y+offset.y(), width, height, format, type, data); 910 } 911 912 deUint32 GLContext::getError (void) 913 { 914 return m_wrapper->glGetError(); 915 } 916 917 void GLContext::finish (void) 918 { 919 m_wrapper->glFinish(); 920 } 921 922 void GLContext::getIntegerv (deUint32 pname, int* params) 923 { 924 m_wrapper->glGetIntegerv(pname, params); 925 } 926 927 const char* GLContext::getString (deUint32 pname) 928 { 929 return (const char*)m_wrapper->glGetString(pname); 930 } 931 932 } // sglr 933
