framework/opengl/simplereference/sglrGLContext.cpp

   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