cc/test/test_gles2_interface.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/test/test_gles2_interface.h"
   6
   7 #include "base/logging.h"
   8 #include "cc/test/test_web_graphics_context_3d.h"
   9
  10 namespace cc {
  11
  12 TestGLES2Interface::TestGLES2Interface(TestWebGraphicsContext3D* test_context)
  13     : test_context_(test_context) {
  14   DCHECK(test_context_);
  15 }
  16
  17 TestGLES2Interface::~TestGLES2Interface() {}
  18
  19 void TestGLES2Interface::GenTextures(GLsizei n, GLuint* textures) {
  20   for (GLsizei i = 0; i < n; ++i) {
  21     textures[i] = test_context_->createTexture();
  22   }
  23 }
  24
  25 void TestGLES2Interface::GenBuffers(GLsizei n, GLuint* buffers) {
  26   for (GLsizei i = 0; i < n; ++i) {
  27     buffers[i] = test_context_->createBuffer();
  28   }
  29 }
  30
  31 void TestGLES2Interface::GenFramebuffers(GLsizei n, GLuint* framebuffers) {
  32   for (GLsizei i = 0; i < n; ++i) {
  33     framebuffers[i] = test_context_->createFramebuffer();
  34   }
  35 }
  36
  37 void TestGLES2Interface::GenQueriesEXT(GLsizei n, GLuint* queries) {
  38   for (GLsizei i = 0; i < n; ++i) {
  39     queries[i] = test_context_->createQueryEXT();
  40   }
  41 }
  42
  43 void TestGLES2Interface::DeleteTextures(GLsizei n, const GLuint* textures) {
  44   for (GLsizei i = 0; i < n; ++i) {
  45     test_context_->deleteTexture(textures[i]);
  46   }
  47 }
  48
  49 void TestGLES2Interface::DeleteBuffers(GLsizei n, const GLuint* buffers) {
  50   for (GLsizei i = 0; i < n; ++i) {
  51     test_context_->deleteBuffer(buffers[i]);
  52   }
  53 }
  54
  55 void TestGLES2Interface::DeleteFramebuffers(GLsizei n,
  56                                             const GLuint* framebuffers) {
  57   for (GLsizei i = 0; i < n; ++i) {
  58     test_context_->deleteFramebuffer(framebuffers[i]);
  59   }
  60 }
  61
  62 void TestGLES2Interface::DeleteQueriesEXT(GLsizei n, const GLuint* queries) {
  63   for (GLsizei i = 0; i < n; ++i) {
  64     test_context_->deleteQueryEXT(queries[i]);
  65   }
  66 }
  67
  68 GLuint TestGLES2Interface::CreateShader(GLenum type) {
  69   return test_context_->createShader(type);
  70 }
  71
  72 GLuint TestGLES2Interface::CreateProgram() {
  73   return test_context_->createProgram();
  74 }
  75
  76 void TestGLES2Interface::BindTexture(GLenum target, GLuint texture) {
  77   test_context_->bindTexture(target, texture);
  78 }
  79
  80 void TestGLES2Interface::GetIntegerv(GLenum pname, GLint* params) {
  81   test_context_->getIntegerv(pname, params);
  82 }
  83
  84 void TestGLES2Interface::GetShaderiv(GLuint shader,
  85                                      GLenum pname,
  86                                      GLint* params) {
  87   test_context_->getShaderiv(shader, pname, params);
  88 }
  89
  90 void TestGLES2Interface::GetProgramiv(GLuint program,
  91                                       GLenum pname,
  92                                       GLint* params) {
  93   test_context_->getProgramiv(program, pname, params);
  94 }
  95
  96 void TestGLES2Interface::GetShaderPrecisionFormat(GLenum shadertype,
  97                                                   GLenum precisiontype,
  98                                                   GLint* range,
  99                                                   GLint* precision) {
 100   test_context_->getShaderPrecisionFormat(
 101       shadertype, precisiontype, range, precision);
 102 }
 103
 104 void TestGLES2Interface::Viewport(GLint x,
 105                                   GLint y,
 106                                   GLsizei width,
 107                                   GLsizei height) {
 108   test_context_->viewport(x, y, width, height);
 109 }
 110
 111 void TestGLES2Interface::ActiveTexture(GLenum target) {
 112   test_context_->activeTexture(target);
 113 }
 114
 115 void TestGLES2Interface::UseProgram(GLuint program) {
 116   test_context_->useProgram(program);
 117 }
 118
 119 GLenum TestGLES2Interface::CheckFramebufferStatus(GLenum target) {
 120   return test_context_->checkFramebufferStatus(target);
 121 }
 122
 123 void TestGLES2Interface::Scissor(GLint x,
 124                                  GLint y,
 125                                  GLsizei width,
 126                                  GLsizei height) {
 127   test_context_->scissor(x, y, width, height);
 128 }
 129
 130 void TestGLES2Interface::DrawElements(GLenum mode,
 131                                       GLsizei count,
 132                                       GLenum type,
 133                                       const void* indices) {
 134   test_context_->drawElements(
 135       mode, count, type, reinterpret_cast<intptr_t>(indices));
 136 }
 137
 138 void TestGLES2Interface::ClearColor(GLclampf red,
 139                                     GLclampf green,
 140                                     GLclampf blue,
 141                                     GLclampf alpha) {
 142   test_context_->clearColor(red, green, blue, alpha);
 143 }
 144
 145 void TestGLES2Interface::ClearStencil(GLint s) {
 146   test_context_->clearStencil(s);
 147 }
 148
 149 void TestGLES2Interface::Clear(GLbitfield mask) { test_context_->clear(mask); }
 150
 151 void TestGLES2Interface::Flush() { test_context_->flush(); }
 152
 153 void TestGLES2Interface::Finish() { test_context_->finish(); }
 154
 155 void TestGLES2Interface::ShallowFlushCHROMIUM() {
 156   test_context_->shallowFlushCHROMIUM();
 157 }
 158
 159 void TestGLES2Interface::Enable(GLenum cap) { test_context_->enable(cap); }
 160
 161 void TestGLES2Interface::Disable(GLenum cap) { test_context_->disable(cap); }
 162
 163 void TestGLES2Interface::BindFramebuffer(GLenum target, GLuint buffer) {
 164   test_context_->bindFramebuffer(target, buffer);
 165 }
 166
 167 void TestGLES2Interface::BindBuffer(GLenum target, GLuint buffer) {
 168   test_context_->bindBuffer(target, buffer);
 169 }
 170
 171 void TestGLES2Interface::TexImage2D(GLenum target,
 172                                     GLint level,
 173                                     GLint internalformat,
 174                                     GLsizei width,
 175                                     GLsizei height,
 176                                     GLint border,
 177                                     GLenum format,
 178                                     GLenum type,
 179                                     const void* pixels) {
 180   test_context_->texImage2D(target,
 181                             level,
 182                             internalformat,
 183                             width,
 184                             height,
 185                             border,
 186                             format,
 187                             type,
 188                             pixels);
 189 }
 190
 191 void TestGLES2Interface::TexSubImage2D(GLenum target,
 192                                        GLint level,
 193                                        GLint xoffset,
 194                                        GLint yoffset,
 195                                        GLsizei width,
 196                                        GLsizei height,
 197                                        GLenum format,
 198                                        GLenum type,
 199                                        const void* pixels) {
 200   test_context_->texSubImage2D(
 201       target, level, xoffset, yoffset, width, height, format, type, pixels);
 202 }
 203
 204 void TestGLES2Interface::TexStorage2DEXT(GLenum target,
 205                                          GLsizei levels,
 206                                          GLenum internalformat,
 207                                          GLsizei width,
 208                                          GLsizei height) {
 209   test_context_->texStorage2DEXT(target, levels, internalformat, width, height);
 210 }
 211
 212 void TestGLES2Interface::TexImageIOSurface2DCHROMIUM(GLenum target,
 213                                                      GLsizei width,
 214                                                      GLsizei height,
 215                                                      GLuint io_surface_id,
 216                                                      GLuint plane) {
 217   test_context_->texImageIOSurface2DCHROMIUM(
 218       target, width, height, io_surface_id, plane);
 219 }
 220
 221 void TestGLES2Interface::TexParameteri(GLenum target,
 222                                        GLenum pname,
 223                                        GLint param) {
 224   test_context_->texParameteri(target, pname, param);
 225 }
 226
 227 void TestGLES2Interface::AsyncTexImage2DCHROMIUM(GLenum target,
 228                                                  GLint level,
 229                                                  GLenum internalformat,
 230                                                  GLsizei width,
 231                                                  GLsizei height,
 232                                                  GLint border,
 233                                                  GLenum format,
 234                                                  GLenum type,
 235                                                  const void* pixels) {
 236   test_context_->asyncTexImage2DCHROMIUM(target,
 237                                          level,
 238                                          internalformat,
 239                                          width,
 240                                          height,
 241                                          border,
 242                                          format,
 243                                          type,
 244                                          pixels);
 245 }
 246
 247 void TestGLES2Interface::AsyncTexSubImage2DCHROMIUM(GLenum target,
 248                                                     GLint level,
 249                                                     GLint xoffset,
 250                                                     GLint yoffset,
 251                                                     GLsizei width,
 252                                                     GLsizei height,
 253                                                     GLenum format,
 254                                                     GLenum type,
 255                                                     const void* pixels) {
 256   test_context_->asyncTexSubImage2DCHROMIUM(
 257       target, level, xoffset, yoffset, width, height, format, type, pixels);
 258 }
 259
 260 void TestGLES2Interface::CompressedTexImage2D(GLenum target,
 261                                               GLint level,
 262                                               GLenum internalformat,
 263                                               GLsizei width,
 264                                               GLsizei height,
 265                                               GLint border,
 266                                               GLsizei image_size,
 267                                               const void* data) {
 268   test_context_->compressedTexImage2D(
 269       target, level, internalformat, width, height, border, image_size, data);
 270 }
 271
 272 void TestGLES2Interface::WaitAsyncTexImage2DCHROMIUM(GLenum target) {
 273   test_context_->waitAsyncTexImage2DCHROMIUM(target);
 274 }
 275
 276 GLuint TestGLES2Interface::CreateImageCHROMIUM(GLsizei width,
 277                                                GLsizei height,
 278                                                GLenum internalformat,
 279                                                GLenum usage) {
 280   return test_context_->createImageCHROMIUM(
 281       width, height, internalformat, usage);
 282 }
 283
 284 void TestGLES2Interface::DestroyImageCHROMIUM(GLuint image_id) {
 285   test_context_->destroyImageCHROMIUM(image_id);
 286 }
 287
 288 void* TestGLES2Interface::MapImageCHROMIUM(GLuint image_id) {
 289   return test_context_->mapImageCHROMIUM(image_id);
 290 }
 291
 292 void TestGLES2Interface::GetImageParameterivCHROMIUM(GLuint image_id,
 293                                                      GLenum pname,
 294                                                      GLint* params) {
 295   test_context_->getImageParameterivCHROMIUM(image_id, pname, params);
 296 }
 297
 298 void TestGLES2Interface::UnmapImageCHROMIUM(GLuint image_id) {
 299   test_context_->unmapImageCHROMIUM(image_id);
 300 }
 301
 302 void TestGLES2Interface::BindTexImage2DCHROMIUM(GLenum target, GLint image_id) {
 303   test_context_->bindTexImage2DCHROMIUM(target, image_id);
 304 }
 305
 306 void TestGLES2Interface::ReleaseTexImage2DCHROMIUM(GLenum target,
 307                                                    GLint image_id) {
 308   test_context_->releaseTexImage2DCHROMIUM(target, image_id);
 309 }
 310
 311 void* TestGLES2Interface::MapBufferCHROMIUM(GLuint target, GLenum access) {
 312   return test_context_->mapBufferCHROMIUM(target, access);
 313 }
 314
 315 GLboolean TestGLES2Interface::UnmapBufferCHROMIUM(GLuint target) {
 316   return test_context_->unmapBufferCHROMIUM(target);
 317 }
 318
 319 void TestGLES2Interface::BufferData(GLenum target,
 320                                     GLsizeiptr size,
 321                                     const void* data,
 322                                     GLenum usage) {
 323   test_context_->bufferData(target, size, data, usage);
 324 }
 325
 326 void TestGLES2Interface::WaitSyncPointCHROMIUM(GLuint sync_point) {
 327   test_context_->waitSyncPoint(sync_point);
 328 }
 329
 330 GLuint TestGLES2Interface::InsertSyncPointCHROMIUM() {
 331   return test_context_->insertSyncPoint();
 332 }
 333
 334 void TestGLES2Interface::BeginQueryEXT(GLenum target, GLuint id) {
 335   test_context_->beginQueryEXT(target, id);
 336 }
 337
 338 void TestGLES2Interface::EndQueryEXT(GLenum target) {
 339   test_context_->endQueryEXT(target);
 340 }
 341
 342 void TestGLES2Interface::GetQueryObjectuivEXT(GLuint id,
 343                                               GLenum pname,
 344                                               GLuint* params) {
 345   test_context_->getQueryObjectuivEXT(id, pname, params);
 346 }
 347
 348 void TestGLES2Interface::DiscardFramebufferEXT(GLenum target,
 349                                                GLsizei count,
 350                                                const GLenum* attachments) {
 351   test_context_->discardFramebufferEXT(target, count, attachments);
 352 }
 353
 354 void TestGLES2Interface::GenMailboxCHROMIUM(GLbyte* mailbox) {
 355   test_context_->genMailboxCHROMIUM(mailbox);
 356 }
 357
 358 void TestGLES2Interface::ProduceTextureCHROMIUM(GLenum target,
 359                                                 const GLbyte* mailbox) {
 360   test_context_->produceTextureCHROMIUM(target, mailbox);
 361 }
 362
 363 void TestGLES2Interface::ProduceTextureDirectCHROMIUM(GLuint texture,
 364                                                       GLenum target,
 365                                                       const GLbyte* mailbox) {
 366   test_context_->produceTextureDirectCHROMIUM(texture, target, mailbox);
 367 }
 368
 369 void TestGLES2Interface::ConsumeTextureCHROMIUM(GLenum target,
 370                                                 const GLbyte* mailbox) {
 371   test_context_->consumeTextureCHROMIUM(target, mailbox);
 372 }
 373
 374 GLuint TestGLES2Interface::CreateAndConsumeTextureCHROMIUM(
 375     GLenum target,
 376     const GLbyte* mailbox) {
 377   return test_context_->createAndConsumeTextureCHROMIUM(target, mailbox);
 378 }
 379
 380 void TestGLES2Interface::ResizeCHROMIUM(GLuint width,
 381                                         GLuint height,
 382                                         float device_scale) {
 383   test_context_->reshapeWithScaleFactor(width, height, device_scale);
 384 }
 385
 386 void TestGLES2Interface::LoseContextCHROMIUM(GLenum current, GLenum other) {
 387   test_context_->loseContextCHROMIUM(current, other);
 388 }
 389
 390 }  // namespace cc