shared/OpenglCodecCommon/GLClientState.cpp

   1 /*
   2 * Copyright (C) 2011 The Android Open Source Project
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16 #include "GLClientState.h"
  17 #include "GLESTextureUtils.h"
  18 #include "ErrorLog.h"
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include "glUtils.h"
  23 #include <cutils/log.h>
  24
  25 #ifndef MAX
  26 #define MAX(a, b) ((a) < (b) ? (b) : (a))
  27 #endif
  28
  29 // Don't include these in the .h file, or we get weird compile errors.
  30 #include <GLES3/gl3.h>
  31 #include <GLES3/gl31.h>
  32
  33 void GLClientState::init() {
  34     m_initialized = false;
  35     m_nLocations = CODEC_MAX_VERTEX_ATTRIBUTES;
  36
  37     m_arrayBuffer = 0;
  38     m_max_vertex_attrib_bindings = m_nLocations;
  39     addVertexArrayObject(0);
  40     setVertexArrayObject(0);
  41     // init gl constans;
  42     m_currVaoState[VERTEX_LOCATION].glConst = GL_VERTEX_ARRAY;
  43     m_currVaoState[NORMAL_LOCATION].glConst = GL_NORMAL_ARRAY;
  44     m_currVaoState[COLOR_LOCATION].glConst = GL_COLOR_ARRAY;
  45     m_currVaoState[POINTSIZE_LOCATION].glConst = GL_POINT_SIZE_ARRAY_OES;
  46     m_currVaoState[TEXCOORD0_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
  47     m_currVaoState[TEXCOORD1_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
  48     m_currVaoState[TEXCOORD2_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
  49     m_currVaoState[TEXCOORD3_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
  50     m_currVaoState[TEXCOORD4_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
  51     m_currVaoState[TEXCOORD5_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
  52     m_currVaoState[TEXCOORD6_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
  53     m_currVaoState[TEXCOORD7_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
  54     m_currVaoState[MATRIXINDEX_LOCATION].glConst = GL_MATRIX_INDEX_ARRAY_OES;
  55     m_currVaoState[WEIGHT_LOCATION].glConst = GL_WEIGHT_ARRAY_OES;
  56
  57     m_copyReadBuffer = 0;
  58     m_copyWriteBuffer = 0;
  59     m_pixelPackBuffer = 0;
  60     m_pixelUnpackBuffer = 0;
  61     m_transformFeedbackBuffer = 0;
  62     m_uniformBuffer = 0;
  63     m_atomicCounterBuffer = 0;
  64     m_dispatchIndirectBuffer = 0;
  65     m_drawIndirectBuffer = 0;
  66     m_shaderStorageBuffer = 0;
  67
  68     m_transformFeedbackActiveUnpaused = false;
  69
  70     // to be modified later when these are queried from host.
  71     m_max_transform_feedback_separate_attribs = 0;
  72     m_max_uniform_buffer_bindings = 0;
  73     m_max_atomic_counter_buffer_bindings = 0;
  74     m_max_shader_storage_buffer_bindings = 0;
  75
  76     m_activeTexture = 0;
  77     m_currentProgram = 0;
  78     m_currentShaderProgram = 0;
  79
  80     m_pixelStore.unpack_alignment = 4;
  81     m_pixelStore.pack_alignment = 4;
  82
  83     m_pixelStore.unpack_row_length = 0;
  84     m_pixelStore.unpack_image_height = 0;
  85     m_pixelStore.unpack_skip_pixels = 0;
  86     m_pixelStore.unpack_skip_rows = 0;
  87     m_pixelStore.unpack_skip_images = 0;
  88
  89     m_pixelStore.pack_row_length = 0;
  90     m_pixelStore.pack_skip_pixels = 0;
  91     m_pixelStore.pack_skip_rows = 0;
  92
  93     memset(m_tex.unit, 0, sizeof(m_tex.unit));
  94     m_tex.activeUnit = &m_tex.unit[0];
  95     m_tex.textureRecs = NULL;
  96
  97     mRboState.boundRenderbuffer = 0;
  98     mRboState.boundRenderbufferIndex = 0;
  99
 100     mFboState.boundDrawFramebuffer = 0;
 101     mFboState.boundReadFramebuffer = 0;
 102     mFboState.drawFboCheckStatus = GL_NONE;
 103     mFboState.readFboCheckStatus = GL_NONE;
 104
 105     m_maxVertexAttribsDirty = true;
 106 }
 107
 108 GLClientState::GLClientState()
 109 {
 110     init();
 111 }
 112
 113 GLClientState::GLClientState(int majorVersion, int minorVersion) :
 114     m_glesMajorVersion(majorVersion),
 115     m_glesMinorVersion(minorVersion) {
 116     init();
 117 }
 118
 119 GLClientState::~GLClientState()
 120 {
 121 }
 122
 123 void GLClientState::enable(int location, int state)
 124 {
 125     m_currVaoState[location].enableDirty |= (state != m_currVaoState[location].enabled);
 126     m_currVaoState[location].enabled = state;
 127 }
 128
 129 void GLClientState::setVertexAttribState(int location, int size, GLenum type, GLboolean normalized, GLsizei stride, const void *data, bool isInt)
 130 {
 131     m_currVaoState[location].size = size;
 132     m_currVaoState[location].type = type;
 133     m_currVaoState[location].stride = stride;
 134     m_currVaoState[location].data = (void*)data;
 135     m_currVaoState[location].bufferObject = m_arrayBuffer;
 136     m_currVaoState[location].elementSize = size ? (glSizeof(type) * size) : 0;
 137     switch (type) {
 138         case GL_INT_2_10_10_10_REV:
 139         case GL_UNSIGNED_INT_2_10_10_10_REV:
 140             m_currVaoState[location].elementSize =
 141                 m_currVaoState[location].elementSize / 4;
 142             break;
 143         default:
 144             break;
 145     }
 146     m_currVaoState[location].normalized = normalized;
 147     m_currVaoState[location].isInt = isInt;
 148 }
 149
 150 void GLClientState::setVertexBindingDivisor(int bindingindex, GLuint divisor) {
 151     m_currVaoState.bufferBinding(bindingindex).divisor = divisor;
 152 }
 153
 154 const GLClientState::BufferBinding& GLClientState::getCurrAttributeBindingInfo(int attribindex) {
 155     return m_currVaoState.bufferBindings_const()[m_currVaoState[attribindex].bindingindex];
 156 }
 157
 158 void GLClientState::setVertexAttribBinding(int attribindex, int bindingindex) {
 159     m_currVaoState[attribindex].bindingindex = bindingindex;
 160 }
 161
 162 void GLClientState::setVertexAttribFormat(int location, int size, GLenum type, GLboolean normalized, GLuint reloffset, bool isInt) {
 163     m_currVaoState[location].size = size;
 164     m_currVaoState[location].type = type;
 165     m_currVaoState[location].normalized = normalized;
 166     m_currVaoState[location].reloffset = reloffset;
 167     m_currVaoState[location].elementSize = size ? (glSizeof(type) * size) : 0;
 168     switch (type) {
 169         case GL_INT_2_10_10_10_REV:
 170         case GL_UNSIGNED_INT_2_10_10_10_REV:
 171             m_currVaoState[location].elementSize =
 172                 m_currVaoState[location].elementSize / 4;
 173             break;
 174         default:
 175             break;
 176     }
 177     m_currVaoState[location].isInt = isInt;
 178 }
 179
 180 void GLClientState::addVertexArrayObjects(GLsizei n, GLuint* arrays) {
 181     for (GLsizei i = 0; i < n; i++) {
 182         addVertexArrayObject(arrays[i]);
 183     }
 184 }
 185
 186 void GLClientState::removeVertexArrayObjects(GLsizei n, const GLuint* arrays) {
 187     for (GLsizei i = 0; i < n; i++) {
 188         if (arrays[i] && m_currVaoState.vaoId() == arrays[i]) {
 189             setVertexArrayObject(0);
 190         }
 191         removeVertexArrayObject(arrays[i]);
 192     }
 193 }
 194
 195 void GLClientState::addVertexArrayObject(GLuint name) {
 196     if (m_vaoMap.find(name) !=
 197         m_vaoMap.end()) {
 198         ALOGE("%s: ERROR: %u already part of current VAO state!",
 199               __FUNCTION__, name);
 200         return;
 201     }
 202
 203     m_vaoMap.insert(
 204             VAOStateMap::value_type(
 205                 name,
 206                 VAOState(0, m_nLocations, std::max(m_nLocations, m_max_vertex_attrib_bindings))));
 207     VertexAttribStateVector& attribState =
 208         m_vaoMap.find(name)->second.attribState;
 209     for (int i = 0; i < m_nLocations; i++) {
 210         attribState[i].enabled = 0;
 211         attribState[i].enableDirty = false;
 212         attribState[i].data = 0;
 213         attribState[i].reloffset = 0;
 214         attribState[i].bindingindex = i;
 215         attribState[i].divisor = 0;
 216         attribState[i].size = 4; // 4 is the default size
 217         attribState[i].type = GL_FLOAT; // GL_FLOAT is the default type
 218     }
 219
 220     VertexAttribBindingVector& bindingState =
 221         m_vaoMap.find(name)->second.bindingState;
 222     for (int i = 0; i < bindingState.size(); i++) {
 223         bindingState[i].effectiveStride = 16;
 224     }
 225 }
 226
 227 void GLClientState::removeVertexArrayObject(GLuint name) {
 228     if (name == 0) {
 229         ALOGE("%s: ERROR: cannot delete VAO 0!",
 230               __FUNCTION__);
 231         return;
 232     }
 233     if (m_vaoMap.find(name) ==
 234         m_vaoMap.end()) {
 235         ALOGE("%s: ERROR: %u not found in VAO state!",
 236               __FUNCTION__, name);
 237         return;
 238     }
 239     m_vaoMap.erase(name);
 240 }
 241
 242 void GLClientState::setVertexArrayObject(GLuint name) {
 243     if (m_vaoMap.find(name) ==
 244         m_vaoMap.end()) {
 245         ALOGE("%s: ERROR: %u not found in VAO state!",
 246               __FUNCTION__, name);
 247         return;
 248     }
 249
 250     if (name && m_currVaoState.vaoId() == name) {
 251         ALOGV("%s: set vao to self, no-op (%u)",
 252               __FUNCTION__, name);
 253         return;
 254     }
 255
 256     m_currVaoState =
 257         VAOStateRef(m_vaoMap.find(name));
 258     ALOGV("%s: set vao to %u (%u) %u %u", __FUNCTION__,
 259             name,
 260             m_currVaoState.vaoId(),
 261             m_arrayBuffer,
 262             m_currVaoState.iboId());
 263 }
 264
 265 bool GLClientState::isVertexArrayObject(GLuint vao) const {
 266     return m_vaoMap.find(vao) != m_vaoMap.end();
 267 }
 268
 269 const GLClientState::VertexAttribState& GLClientState::getState(int location)
 270 {
 271     return m_currVaoState[location];
 272 }
 273
 274 const GLClientState::VertexAttribState& GLClientState::getStateAndEnableDirty(int location, bool *enableChanged)
 275 {
 276     if (enableChanged) {
 277         *enableChanged = m_currVaoState[location].enableDirty;
 278     }
 279
 280     m_currVaoState[location].enableDirty = false;
 281     return m_currVaoState[location];
 282 }
 283
 284 int GLClientState::getLocation(GLenum loc)
 285 {
 286     int retval;
 287
 288     switch(loc) {
 289     case GL_VERTEX_ARRAY:
 290         retval = int(VERTEX_LOCATION);
 291         break;
 292     case GL_NORMAL_ARRAY:
 293         retval = int(NORMAL_LOCATION);
 294         break;
 295     case GL_COLOR_ARRAY:
 296         retval = int(COLOR_LOCATION);
 297         break;
 298     case GL_POINT_SIZE_ARRAY_OES:
 299         retval = int(POINTSIZE_LOCATION);
 300         break;
 301     case GL_TEXTURE_COORD_ARRAY:
 302         retval = int (TEXCOORD0_LOCATION + m_activeTexture);
 303         break;
 304     case GL_MATRIX_INDEX_ARRAY_OES:
 305         retval = int (MATRIXINDEX_LOCATION);
 306         break;
 307     case GL_WEIGHT_ARRAY_OES:
 308         retval = int (WEIGHT_LOCATION);
 309         break;
 310     default:
 311         retval = loc;
 312     }
 313     return retval;
 314 }
 315
 316 static void sClearIndexedBufferBinding(GLuint id, std::vector<GLClientState::BufferBinding>& bindings) {
 317     for (size_t i = 0; i < bindings.size(); i++) {
 318         if (bindings[i].buffer == id) {
 319             bindings[i].offset = 0;
 320             bindings[i].stride = 0;
 321             bindings[i].effectiveStride = 16;
 322             bindings[i].size = 0;
 323             bindings[i].buffer = 0;
 324             bindings[i].divisor = 0;
 325         }
 326     }
 327 }
 328
 329 void GLClientState::addBuffer(GLuint id) {
 330     mBufferIds.insert(id);
 331 }
 332
 333 void GLClientState::removeBuffer(GLuint id) {
 334     mBufferIds.erase(id);
 335 }
 336
 337 bool GLClientState::bufferIdExists(GLuint id) const {
 338     return mBufferIds.find(id) != mBufferIds.end();
 339 }
 340
 341 void GLClientState::unBindBuffer(GLuint id) {
 342     if (m_arrayBuffer == id) m_arrayBuffer = 0;
 343     if (m_currVaoState.iboId() == id) m_currVaoState.iboId() = 0;
 344     if (m_copyReadBuffer == id)
 345         m_copyReadBuffer = 0;
 346     if (m_copyWriteBuffer == id)
 347         m_copyWriteBuffer = 0;
 348     if (m_pixelPackBuffer == id)
 349         m_pixelPackBuffer = 0;
 350     if (m_pixelUnpackBuffer == id)
 351         m_pixelUnpackBuffer = 0;
 352     if (m_transformFeedbackBuffer == id)
 353         m_transformFeedbackBuffer = 0;
 354     if (m_uniformBuffer == id)
 355         m_uniformBuffer = 0;
 356     if (m_atomicCounterBuffer == id)
 357         m_atomicCounterBuffer = 0;
 358     if (m_dispatchIndirectBuffer == id)
 359         m_dispatchIndirectBuffer = 0;
 360     if (m_drawIndirectBuffer == id)
 361         m_drawIndirectBuffer = 0;
 362     if (m_shaderStorageBuffer == id)
 363         m_shaderStorageBuffer = 0;
 364
 365     sClearIndexedBufferBinding(id, m_indexedTransformFeedbackBuffers);
 366     sClearIndexedBufferBinding(id, m_indexedUniformBuffers);
 367     sClearIndexedBufferBinding(id, m_indexedAtomicCounterBuffers);
 368     sClearIndexedBufferBinding(id, m_indexedShaderStorageBuffers);
 369     sClearIndexedBufferBinding(id, m_currVaoState.bufferBindings());
 370 }
 371
 372 int GLClientState::bindBuffer(GLenum target, GLuint id)
 373 {
 374     int err = 0;
 375     switch(target) {
 376     case GL_ARRAY_BUFFER:
 377         m_arrayBuffer = id;
 378         break;
 379     case GL_ELEMENT_ARRAY_BUFFER:
 380         m_currVaoState.iboId() = id;
 381         break;
 382     case GL_COPY_READ_BUFFER:
 383         m_copyReadBuffer = id;
 384         break;
 385     case GL_COPY_WRITE_BUFFER:
 386         m_copyWriteBuffer = id;
 387         break;
 388     case GL_PIXEL_PACK_BUFFER:
 389         m_pixelPackBuffer = id;
 390         break;
 391     case GL_PIXEL_UNPACK_BUFFER:
 392         m_pixelUnpackBuffer = id;
 393         break;
 394     case GL_TRANSFORM_FEEDBACK_BUFFER:
 395         m_transformFeedbackBuffer = id;
 396         break;
 397     case GL_UNIFORM_BUFFER:
 398         m_uniformBuffer = id;
 399         break;
 400     case GL_ATOMIC_COUNTER_BUFFER:
 401         m_atomicCounterBuffer = id;
 402         break;
 403     case GL_DISPATCH_INDIRECT_BUFFER:
 404         m_dispatchIndirectBuffer = id;
 405         break;
 406     case GL_DRAW_INDIRECT_BUFFER:
 407         m_drawIndirectBuffer = id;
 408         break;
 409     case GL_SHADER_STORAGE_BUFFER:
 410         m_shaderStorageBuffer = id;
 411         break;
 412     default:
 413         err = -1;
 414     }
 415     return err;
 416 }
 417
 418 void GLClientState::bindIndexedBuffer(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size, GLintptr stride, GLintptr effectiveStride) {
 419     switch (target) {
 420     case GL_TRANSFORM_FEEDBACK_BUFFER:
 421         m_indexedTransformFeedbackBuffers[index].buffer = buffer;
 422         m_indexedTransformFeedbackBuffers[index].offset = offset;
 423         m_indexedTransformFeedbackBuffers[index].size = size;
 424         m_indexedTransformFeedbackBuffers[index].stride = stride;
 425         break;
 426     case GL_UNIFORM_BUFFER:
 427         m_indexedUniformBuffers[index].buffer = buffer;
 428         m_indexedUniformBuffers[index].offset = offset;
 429         m_indexedUniformBuffers[index].size = size;
 430         m_indexedUniformBuffers[index].stride = stride;
 431         break;
 432     case GL_ATOMIC_COUNTER_BUFFER:
 433         m_indexedAtomicCounterBuffers[index].buffer = buffer;
 434         m_indexedAtomicCounterBuffers[index].offset = offset;
 435         m_indexedAtomicCounterBuffers[index].size = size;
 436         m_indexedAtomicCounterBuffers[index].stride = stride;
 437         break;
 438     case GL_SHADER_STORAGE_BUFFER:
 439         m_indexedShaderStorageBuffers[index].buffer = buffer;
 440         m_indexedShaderStorageBuffers[index].offset = offset;
 441         m_indexedShaderStorageBuffers[index].size = size;
 442         m_indexedShaderStorageBuffers[index].stride = stride;
 443         break;
 444     default:
 445         m_currVaoState.bufferBinding(index).buffer = buffer;
 446         m_currVaoState.bufferBinding(index).offset = offset;
 447         m_currVaoState.bufferBinding(index).size = size;
 448         m_currVaoState.bufferBinding(index).stride = stride;
 449         m_currVaoState.bufferBinding(index).effectiveStride = effectiveStride;
 450         return;
 451     }
 452 }
 453
 454 int GLClientState::getMaxIndexedBufferBindings(GLenum target) const {
 455     switch (target) {
 456     case GL_TRANSFORM_FEEDBACK_BUFFER:
 457         return m_indexedTransformFeedbackBuffers.size();
 458     case GL_UNIFORM_BUFFER:
 459         return m_indexedUniformBuffers.size();
 460     case GL_ATOMIC_COUNTER_BUFFER:
 461         return m_indexedAtomicCounterBuffers.size();
 462     case GL_SHADER_STORAGE_BUFFER:
 463         return m_indexedShaderStorageBuffers.size();
 464     default:
 465         return m_currVaoState.bufferBindings_const().size();
 466     }
 467 }
 468
 469 int GLClientState::getBuffer(GLenum target) {
 470     int ret=0;
 471     switch (target) {
 472         case GL_ARRAY_BUFFER:
 473             ret = m_arrayBuffer;
 474             break;
 475         case GL_ELEMENT_ARRAY_BUFFER:
 476             ret = m_currVaoState.iboId();
 477             break;
 478         case GL_COPY_READ_BUFFER:
 479             ret = m_copyReadBuffer;
 480             break;
 481         case GL_COPY_WRITE_BUFFER:
 482             ret = m_copyWriteBuffer;
 483             break;
 484         case GL_PIXEL_PACK_BUFFER:
 485             ret = m_pixelPackBuffer;
 486             break;
 487         case GL_PIXEL_UNPACK_BUFFER:
 488             ret = m_pixelUnpackBuffer;
 489             break;
 490         case GL_TRANSFORM_FEEDBACK_BUFFER:
 491             ret = m_transformFeedbackBuffer;
 492             break;
 493         case GL_UNIFORM_BUFFER:
 494             ret = m_uniformBuffer;
 495             break;
 496         case GL_ATOMIC_COUNTER_BUFFER:
 497             ret = m_atomicCounterBuffer;
 498             break;
 499         case GL_DISPATCH_INDIRECT_BUFFER:
 500             ret = m_dispatchIndirectBuffer;
 501             break;
 502         case GL_DRAW_INDIRECT_BUFFER:
 503             ret = m_drawIndirectBuffer;
 504             break;
 505         case GL_SHADER_STORAGE_BUFFER:
 506             ret = m_shaderStorageBuffer;
 507             break;
 508         default:
 509             ret = -1;
 510     }
 511     return ret;
 512 }
 513
 514 void GLClientState::getClientStatePointer(GLenum pname, GLvoid** params)
 515 {
 516     GLenum which_state = -1;
 517     switch (pname) {
 518     case GL_VERTEX_ARRAY_POINTER: {
 519         which_state = GLClientState::VERTEX_LOCATION;
 520         break;
 521         }
 522     case GL_NORMAL_ARRAY_POINTER: {
 523         which_state = GLClientState::NORMAL_LOCATION;
 524         break;
 525         }
 526     case GL_COLOR_ARRAY_POINTER: {
 527         which_state = GLClientState::COLOR_LOCATION;
 528         break;
 529         }
 530     case GL_TEXTURE_COORD_ARRAY_POINTER: {
 531         which_state = getActiveTexture() + GLClientState::TEXCOORD0_LOCATION;
 532         break;
 533         }
 534     case GL_POINT_SIZE_ARRAY_POINTER_OES: {
 535         which_state = GLClientState::POINTSIZE_LOCATION;
 536         break;
 537         }
 538     case GL_MATRIX_INDEX_ARRAY_POINTER_OES: {
 539         which_state = GLClientState::MATRIXINDEX_LOCATION;
 540         break;
 541         }
 542     case GL_WEIGHT_ARRAY_POINTER_OES: {
 543         which_state = GLClientState::WEIGHT_LOCATION;
 544         break;
 545         }
 546     }
 547     if (which_state != -1)
 548         *params = getState(which_state).data;
 549 }
 550
 551 int GLClientState::setPixelStore(GLenum param, GLint value)
 552 {
 553     int retval = 0;
 554     switch(param) {
 555     case GL_UNPACK_ALIGNMENT:
 556         m_pixelStore.unpack_alignment = value;
 557         break;
 558     case GL_PACK_ALIGNMENT:
 559         m_pixelStore.pack_alignment = value;
 560         break;
 561     case GL_UNPACK_ROW_LENGTH:
 562         m_pixelStore.unpack_row_length = value;
 563         break;
 564     case GL_UNPACK_IMAGE_HEIGHT:
 565         m_pixelStore.unpack_image_height = value;
 566         break;
 567     case GL_UNPACK_SKIP_PIXELS:
 568         m_pixelStore.unpack_skip_pixels = value;
 569         break;
 570     case GL_UNPACK_SKIP_ROWS:
 571         m_pixelStore.unpack_skip_rows = value;
 572         break;
 573     case GL_UNPACK_SKIP_IMAGES:
 574         m_pixelStore.unpack_skip_images = value;
 575         break;
 576     case GL_PACK_ROW_LENGTH:
 577         m_pixelStore.pack_row_length = value;
 578         break;
 579     case GL_PACK_SKIP_PIXELS:
 580         m_pixelStore.pack_skip_pixels = value;
 581         break;
 582     case GL_PACK_SKIP_ROWS:
 583         m_pixelStore.pack_skip_rows = value;
 584         break;
 585     default:
 586         retval = GL_INVALID_ENUM;
 587     }
 588     return retval;
 589 }
 590
 591
 592 size_t GLClientState::pixelDataSize(GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, int pack) const
 593 {
 594     if (width <= 0 || height <= 0 || depth <= 0) return 0;
 595
 596     ALOGV("%s: pack? %d", __FUNCTION__, pack);
 597     if (pack) {
 598         ALOGV("%s: pack stats", __FUNCTION__);
 599         ALOGV("%s: pack align %d", __FUNCTION__, m_pixelStore.pack_alignment);
 600         ALOGV("%s: pack rowlen %d", __FUNCTION__, m_pixelStore.pack_row_length);
 601         ALOGV("%s: pack skippixels %d", __FUNCTION__, m_pixelStore.pack_skip_pixels);
 602         ALOGV("%s: pack skiprows %d", __FUNCTION__, m_pixelStore.pack_skip_rows);
 603     } else {
 604         ALOGV("%s: unpack stats", __FUNCTION__);
 605         ALOGV("%s: unpack align %d", __FUNCTION__, m_pixelStore.unpack_alignment);
 606         ALOGV("%s: unpack rowlen %d", __FUNCTION__, m_pixelStore.unpack_row_length);
 607         ALOGV("%s: unpack imgheight %d", __FUNCTION__, m_pixelStore.unpack_image_height);
 608         ALOGV("%s: unpack skippixels %d", __FUNCTION__, m_pixelStore.unpack_skip_pixels);
 609         ALOGV("%s: unpack skiprows %d", __FUNCTION__, m_pixelStore.unpack_skip_rows);
 610         ALOGV("%s: unpack skipimages %d", __FUNCTION__, m_pixelStore.unpack_skip_images);
 611     }
 612     return GLESTextureUtils::computeTotalImageSize(
 613             width, height, depth,
 614             format, type,
 615             pack ? m_pixelStore.pack_alignment : m_pixelStore.unpack_alignment,
 616             pack ? m_pixelStore.pack_row_length : m_pixelStore.unpack_row_length,
 617             pack ? 0 : m_pixelStore.unpack_image_height,
 618             pack ? m_pixelStore.pack_skip_pixels : m_pixelStore.unpack_skip_pixels,
 619             pack ? m_pixelStore.pack_skip_rows : m_pixelStore.unpack_skip_rows,
 620             pack ? 0 : m_pixelStore.unpack_skip_images);
 621 }
 622
 623 size_t GLClientState::pboNeededDataSize(GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, int pack) const
 624 {
 625     if (width <= 0 || height <= 0 || depth <= 0) return 0;
 626
 627     ALOGV("%s: pack? %d", __FUNCTION__, pack);
 628     if (pack) {
 629         ALOGV("%s: pack stats", __FUNCTION__);
 630         ALOGV("%s: pack align %d", __FUNCTION__, m_pixelStore.pack_alignment);
 631         ALOGV("%s: pack rowlen %d", __FUNCTION__, m_pixelStore.pack_row_length);
 632         ALOGV("%s: pack skippixels %d", __FUNCTION__, m_pixelStore.pack_skip_pixels);
 633         ALOGV("%s: pack skiprows %d", __FUNCTION__, m_pixelStore.pack_skip_rows);
 634     } else {
 635         ALOGV("%s: unpack stats", __FUNCTION__);
 636         ALOGV("%s: unpack align %d", __FUNCTION__, m_pixelStore.unpack_alignment);
 637         ALOGV("%s: unpack rowlen %d", __FUNCTION__, m_pixelStore.unpack_row_length);
 638         ALOGV("%s: unpack imgheight %d", __FUNCTION__, m_pixelStore.unpack_image_height);
 639         ALOGV("%s: unpack skippixels %d", __FUNCTION__, m_pixelStore.unpack_skip_pixels);
 640         ALOGV("%s: unpack skiprows %d", __FUNCTION__, m_pixelStore.unpack_skip_rows);
 641         ALOGV("%s: unpack skipimages %d", __FUNCTION__, m_pixelStore.unpack_skip_images);
 642     }
 643     return GLESTextureUtils::computeNeededBufferSize(
 644             width, height, depth,
 645             format, type,
 646             pack ? m_pixelStore.pack_alignment : m_pixelStore.unpack_alignment,
 647             pack ? m_pixelStore.pack_row_length : m_pixelStore.unpack_row_length,
 648             pack ? 0 : m_pixelStore.unpack_image_height,
 649             pack ? m_pixelStore.pack_skip_pixels : m_pixelStore.unpack_skip_pixels,
 650             pack ? m_pixelStore.pack_skip_rows : m_pixelStore.unpack_skip_rows,
 651             pack ? 0 : m_pixelStore.unpack_skip_images);
 652 }
 653
 654
 655 size_t GLClientState::clearBufferNumElts(GLenum buffer) const
 656 {
 657     switch (buffer) {
 658     case GL_COLOR:
 659         return 4;
 660     case GL_DEPTH:
 661     case GL_STENCIL:
 662         return 1;
 663     }
 664     return 1;
 665 }
 666
 667 void GLClientState::setNumActiveUniformsInUniformBlock(GLuint program, GLuint uniformBlockIndex, GLint numActiveUniforms) {
 668     UniformBlockInfoKey key;
 669     key.program = program;
 670     key.uniformBlockIndex = uniformBlockIndex;
 671
 672     UniformBlockUniformInfo info;
 673     info.numActiveUniforms = (size_t)numActiveUniforms;
 674
 675     m_uniformBlockInfoMap[key] = info;
 676 }
 677
 678 size_t GLClientState::numActiveUniformsInUniformBlock(GLuint program, GLuint uniformBlockIndex) const {
 679     UniformBlockInfoKey key;
 680     key.program = program;
 681     key.uniformBlockIndex = uniformBlockIndex;
 682     UniformBlockInfoMap::const_iterator it =
 683         m_uniformBlockInfoMap.find(key);
 684     if (it == m_uniformBlockInfoMap.end()) return 0;
 685     return it->second.numActiveUniforms;
 686 }
 687
 688 void GLClientState::associateProgramWithPipeline(GLuint program, GLuint pipeline) {
 689     m_programPipelines[program] = pipeline;
 690 }
 691
 692 GLClientState::ProgramPipelineIterator GLClientState::programPipelineBegin() {
 693     return m_programPipelines.begin();
 694 }
 695
 696 GLClientState::ProgramPipelineIterator GLClientState::programPipelineEnd() {
 697     return m_programPipelines.end();
 698 }
 699
 700 GLenum GLClientState::setActiveTextureUnit(GLenum texture)
 701 {
 702     GLuint unit = texture - GL_TEXTURE0;
 703     if (unit >= MAX_TEXTURE_UNITS) {
 704         return GL_INVALID_ENUM;
 705     }
 706     m_tex.activeUnit = &m_tex.unit[unit];
 707     return GL_NO_ERROR;
 708 }
 709
 710 GLenum GLClientState::getActiveTextureUnit() const
 711 {
 712     return GL_TEXTURE0 + (m_tex.activeUnit - &m_tex.unit[0]);
 713 }
 714
 715 void GLClientState::enableTextureTarget(GLenum target)
 716 {
 717     switch (target) {
 718     case GL_TEXTURE_2D:
 719         m_tex.activeUnit->enables |= (1u << TEXTURE_2D);
 720         break;
 721     case GL_TEXTURE_EXTERNAL_OES:
 722         m_tex.activeUnit->enables |= (1u << TEXTURE_EXTERNAL);
 723         break;
 724     }
 725 }
 726
 727 void GLClientState::disableTextureTarget(GLenum target)
 728 {
 729     switch (target) {
 730     case GL_TEXTURE_2D:
 731         m_tex.activeUnit->enables &= ~(1u << TEXTURE_2D);
 732         break;
 733     case GL_TEXTURE_EXTERNAL_OES:
 734         m_tex.activeUnit->enables &= ~(1u << TEXTURE_EXTERNAL);
 735         break;
 736     }
 737 }
 738
 739 GLenum GLClientState::getPriorityEnabledTarget(GLenum allDisabled) const
 740 {
 741     unsigned int enables = m_tex.activeUnit->enables;
 742     if (enables & (1u << TEXTURE_EXTERNAL)) {
 743         return GL_TEXTURE_EXTERNAL_OES;
 744     } else if (enables & (1u << TEXTURE_2D)) {
 745         return GL_TEXTURE_2D;
 746     } else {
 747         return allDisabled;
 748     }
 749 }
 750
 751 int GLClientState::compareTexId(const void* pid, const void* prec)
 752 {
 753     const GLuint* id = (const GLuint*)pid;
 754     const TextureRec* rec = (const TextureRec*)prec;
 755     return (GLint)(*id) - (GLint)rec->id;
 756 }
 757
 758 GLenum GLClientState::bindTexture(GLenum target, GLuint texture,
 759         GLboolean* firstUse)
 760 {
 761     GLboolean first = GL_FALSE;
 762
 763     TextureRec* texrec = getTextureRec(texture);
 764     if (!texrec) {
 765         texrec = addTextureRec(texture, target);
 766     }
 767
 768     if (texture && target != texrec->target &&
 769         (target != GL_TEXTURE_EXTERNAL_OES &&
 770          texrec->target != GL_TEXTURE_EXTERNAL_OES)) {
 771         ALOGD("%s: issue GL_INVALID_OPERATION: target 0x%x texrectarget 0x%x texture %u", __FUNCTION__, target, texrec->target, texture);
 772     }
 773
 774     switch (target) {
 775     case GL_TEXTURE_2D:
 776         m_tex.activeUnit->texture[TEXTURE_2D] = texture;
 777         break;
 778     case GL_TEXTURE_EXTERNAL_OES:
 779         m_tex.activeUnit->texture[TEXTURE_EXTERNAL] = texture;
 780         break;
 781     case GL_TEXTURE_CUBE_MAP:
 782         m_tex.activeUnit->texture[TEXTURE_CUBE_MAP] = texture;
 783         break;
 784     case GL_TEXTURE_2D_ARRAY:
 785         m_tex.activeUnit->texture[TEXTURE_2D_ARRAY] = texture;
 786         break;
 787     case GL_TEXTURE_3D:
 788         m_tex.activeUnit->texture[TEXTURE_3D] = texture;
 789         break;
 790     case GL_TEXTURE_2D_MULTISAMPLE:
 791         m_tex.activeUnit->texture[TEXTURE_2D_MULTISAMPLE] = texture;
 792         break;
 793     }
 794
 795     if (firstUse) {
 796         *firstUse = first;
 797     }
 798
 799     return GL_NO_ERROR;
 800 }
 801
 802 void GLClientState::setBoundEGLImage(GLenum target, GLeglImageOES image) {
 803     GLuint texture = getBoundTexture(target);
 804     TextureRec* texrec = getTextureRec(texture);
 805     if (!texrec) return;
 806     texrec->boundEGLImage = true;
 807 }
 808
 809 TextureRec* GLClientState::addTextureRec(GLuint id, GLenum target)
 810 {
 811     TextureRec* tex = new TextureRec;
 812     tex->id = id;
 813     tex->target = target;
 814     tex->format = -1;
 815     tex->multisamples = 0;
 816     tex->immutable = false;
 817     tex->boundEGLImage = false;
 818     tex->dims = new TextureDims;
 819
 820     (*(m_tex.textureRecs))[id] = tex;
 821     return tex;
 822 }
 823
 824 TextureRec* GLClientState::getTextureRec(GLuint id) const {
 825     SharedTextureDataMap::const_iterator it =
 826         m_tex.textureRecs->find(id);
 827     if (it == m_tex.textureRecs->end()) {
 828         return NULL;
 829     }
 830     return it->second;
 831 }
 832
 833 void GLClientState::setBoundTextureInternalFormat(GLenum target, GLint internalformat) {
 834     GLuint texture = getBoundTexture(target);
 835     TextureRec* texrec = getTextureRec(texture);
 836     if (!texrec) return;
 837     texrec->internalformat = internalformat;
 838 }
 839
 840 void GLClientState::setBoundTextureFormat(GLenum target, GLenum format) {
 841     GLuint texture = getBoundTexture(target);
 842     TextureRec* texrec = getTextureRec(texture);
 843     if (!texrec) return;
 844     texrec->format = format;
 845 }
 846
 847 void GLClientState::setBoundTextureType(GLenum target, GLenum type) {
 848     GLuint texture = getBoundTexture(target);
 849     TextureRec* texrec = getTextureRec(texture);
 850     if (!texrec) return;
 851     texrec->type = type;
 852 }
 853
 854 void GLClientState::setBoundTextureDims(GLenum target, GLsizei level, GLsizei width, GLsizei height, GLsizei depth) {
 855     GLuint texture = getBoundTexture(target);
 856     TextureRec* texrec = getTextureRec(texture);
 857     if (!texrec) {
 858         return;
 859     }
 860
 861     if (level == -1) {
 862         GLsizei curr_width = width;
 863         GLsizei curr_height = height;
 864         GLsizei curr_depth = depth;
 865         GLsizei curr_level = 0;
 866
 867         while (true) {
 868             texrec->dims->widths[curr_level] = curr_width;
 869             texrec->dims->heights[curr_level] = curr_height;
 870             texrec->dims->depths[curr_level] = curr_depth;
 871             if (curr_width >> 1 == 0 &&
 872                 curr_height >> 1 == 0 &&
 873                 ((target == GL_TEXTURE_3D && curr_depth == 0) ||
 874                  true)) {
 875                 break;
 876             }
 877             curr_width = (curr_width >> 1) ? (curr_width >> 1) : 1;
 878             curr_height = (curr_height >> 1) ? (curr_height >> 1) : 1;
 879             if (target == GL_TEXTURE_3D) {
 880                 curr_depth = (curr_depth >> 1) ? (curr_depth >> 1) : 1;
 881             }
 882             curr_level++;
 883         }
 884
 885     } else {
 886         texrec->dims->widths[level] = width;
 887         texrec->dims->heights[level] = height;
 888         texrec->dims->depths[level] = depth;
 889     }
 890 }
 891
 892 void GLClientState::setBoundTextureSamples(GLenum target, GLsizei samples) {
 893     GLuint texture = getBoundTexture(target);
 894     TextureRec* texrec = getTextureRec(texture);
 895     if (!texrec) return;
 896     texrec->multisamples = samples;
 897 }
 898
 899 void GLClientState::setBoundTextureImmutableFormat(GLenum target) {
 900     GLuint texture = getBoundTexture(target);
 901     TextureRec* texrec = getTextureRec(texture);
 902     if (!texrec) return;
 903     texrec->immutable = true;
 904 }
 905
 906 bool GLClientState::isBoundTextureImmutableFormat(GLenum target) const {
 907     GLuint texture = getBoundTexture(target);
 908     TextureRec* texrec = getTextureRec(texture);
 909     if (!texrec) return false;
 910     return texrec->immutable;
 911 }
 912
 913 GLuint GLClientState::getBoundTexture(GLenum target) const
 914 {
 915     switch (target) {
 916     case GL_TEXTURE_2D:
 917         return m_tex.activeUnit->texture[TEXTURE_2D];
 918     case GL_TEXTURE_EXTERNAL_OES:
 919         return m_tex.activeUnit->texture[TEXTURE_EXTERNAL];
 920     case GL_TEXTURE_CUBE_MAP:
 921         return m_tex.activeUnit->texture[TEXTURE_CUBE_MAP];
 922     case GL_TEXTURE_2D_ARRAY:
 923         return m_tex.activeUnit->texture[TEXTURE_2D_ARRAY];
 924     case GL_TEXTURE_3D:
 925         return m_tex.activeUnit->texture[TEXTURE_3D];
 926     case GL_TEXTURE_2D_MULTISAMPLE:
 927         return m_tex.activeUnit->texture[TEXTURE_2D_MULTISAMPLE];
 928     default:
 929         return 0;
 930     }
 931 }
 932
 933 // BEGIN driver workarounds-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
 934 // (>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')>
 935
 936 static bool unreliableInternalFormat(GLenum internalformat) {
 937     switch (internalformat) {
 938     case GL_LUMINANCE:
 939         return true;
 940     default:
 941         return false;
 942     }
 943 }
 944
 945 void GLClientState::writeCopyTexImageState
 946     (GLenum target, GLint level, GLenum internalformat) {
 947     if (unreliableInternalFormat(internalformat)) {
 948         CubeMapDef entry;
 949         entry.id = getBoundTexture(GL_TEXTURE_2D);
 950         entry.target = target;
 951         entry.level = level;
 952         entry.internalformat = internalformat;
 953         m_cubeMapDefs.insert(entry);
 954     }
 955 }
 956
 957 static GLenum identifyPositiveCubeMapComponent(GLenum target) {
 958     switch (target) {
 959     case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
 960         return GL_TEXTURE_CUBE_MAP_POSITIVE_X;
 961     case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
 962         return GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
 963     case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
 964         return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
 965     default:
 966         return 0;
 967     }
 968 }
 969
 970 GLenum GLClientState::copyTexImageNeededTarget
 971     (GLenum target, GLint level, GLenum internalformat) {
 972     if (unreliableInternalFormat(internalformat)) {
 973         GLenum positiveComponent =
 974             identifyPositiveCubeMapComponent(target);
 975         if (positiveComponent) {
 976             CubeMapDef query;
 977             query.id = getBoundTexture(GL_TEXTURE_2D);
 978             query.target = positiveComponent;
 979             query.level = level;
 980             query.internalformat = internalformat;
 981             if (m_cubeMapDefs.find(query) ==
 982                 m_cubeMapDefs.end()) {
 983                 return positiveComponent;
 984             }
 985         }
 986     }
 987     return 0;
 988 }
 989
 990 GLenum GLClientState::copyTexImageLuminanceCubeMapAMDWorkaround
 991     (GLenum target, GLint level, GLenum internalformat) {
 992     writeCopyTexImageState(target, level, internalformat);
 993     return copyTexImageNeededTarget(target, level, internalformat);
 994 }
 995
 996 // (>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')>
 997 // END driver workarounds-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
 998
 999 void GLClientState::deleteTextures(GLsizei n, const GLuint* textures)
1000 {
1001     // Updating the textures array could be made more efficient when deleting
1002     // several textures:
1003     // - compacting the array could be done in a single pass once the deleted
1004     //   textures are marked, or
1005     // - could swap deleted textures to the end and re-sort.
1006     TextureRec* texrec;
1007     for (const GLuint* texture = textures; texture != textures + n; texture++) {
1008         texrec = getTextureRec(*texture);
1009         if (texrec && texrec->dims) {
1010             delete texrec->dims;
1011         }
1012         if (texrec) {
1013             m_tex.textureRecs->erase(*texture);
1014             delete texrec;
1015             for (TextureUnit* unit = m_tex.unit;
1016                  unit != m_tex.unit + MAX_TEXTURE_UNITS;
1017                  unit++)
1018             {
1019                 if (unit->texture[TEXTURE_2D] == *texture) {
1020                     unit->texture[TEXTURE_2D] = 0;
1021                 } else if (unit->texture[TEXTURE_EXTERNAL] == *texture) {
1022                     unit->texture[TEXTURE_EXTERNAL] = 0;
1023                 }
1024             }
1025         }
1026     }
1027 }
1028
1029 // RBO//////////////////////////////////////////////////////////////////////////
1030
1031 void GLClientState::addFreshRenderbuffer(GLuint name) {
1032     // if underlying opengl says these are fresh names,
1033     // but we are keeping a stale one, reset it.
1034     RboProps props;
1035     props.target = GL_RENDERBUFFER;
1036     props.name = name;
1037     props.format = GL_NONE;
1038     props.multisamples = 0;
1039     props.previouslyBound = false;
1040
1041     if (usedRenderbufferName(name)) {
1042         mRboState.rboData[getRboIndex(name)] = props;
1043     } else {
1044         mRboState.rboData.push_back(props);
1045     }
1046 }
1047
1048 void GLClientState::addRenderbuffers(GLsizei n, GLuint* renderbuffers) {
1049     for (size_t i = 0; i < n; i++) {
1050         addFreshRenderbuffer(renderbuffers[i]);
1051     }
1052 }
1053
1054 size_t GLClientState::getRboIndex(GLuint name) const {
1055     for (size_t i = 0; i < mRboState.rboData.size(); i++) {
1056         if (mRboState.rboData[i].name == name) {
1057             return i;
1058         }
1059     }
1060     return -1;
1061 }
1062
1063 void GLClientState::removeRenderbuffers(GLsizei n, const GLuint* renderbuffers) {
1064     size_t bound_rbo_idx = getRboIndex(boundRboProps_const().name);
1065
1066     std::vector<GLuint> to_remove;
1067     for (size_t i = 0; i < n; i++) {
1068         if (renderbuffers[i] != 0) { // Never remove the zero rb.
1069             to_remove.push_back(getRboIndex(renderbuffers[i]));
1070         }
1071     }
1072
1073     for (size_t i = 0; i < to_remove.size(); i++) {
1074         mRboState.rboData[to_remove[i]] = mRboState.rboData.back();
1075         mRboState.rboData.pop_back();
1076     }
1077
1078     // If we just deleted the currently bound rb,
1079     // bind the zero rb
1080     if (getRboIndex(boundRboProps_const().name) != bound_rbo_idx) {
1081         bindRenderbuffer(GL_RENDERBUFFER, 0);
1082     }
1083 }
1084
1085 bool GLClientState::usedRenderbufferName(GLuint name) const {
1086     for (size_t i = 0; i < mRboState.rboData.size(); i++) {
1087         if (mRboState.rboData[i].name == name) {
1088             return true;
1089         }
1090     }
1091     return false;
1092 }
1093
1094 void GLClientState::setBoundRenderbufferIndex() {
1095     for (size_t i = 0; i < mRboState.rboData.size(); i++) {
1096         if (mRboState.rboData[i].name == mRboState.boundRenderbuffer) {
1097             mRboState.boundRenderbufferIndex = i;
1098             break;
1099         }
1100     }
1101 }
1102
1103 RboProps& GLClientState::boundRboProps() {
1104     return mRboState.rboData[mRboState.boundRenderbufferIndex];
1105 }
1106
1107 const RboProps& GLClientState::boundRboProps_const() const {
1108     return mRboState.rboData[mRboState.boundRenderbufferIndex];
1109 }
1110
1111 void GLClientState::bindRenderbuffer(GLenum target, GLuint name) {
1112     // If unused, add it.
1113     if (!usedRenderbufferName(name)) {
1114         addFreshRenderbuffer(name);
1115     }
1116     mRboState.boundRenderbuffer = name;
1117     setBoundRenderbufferIndex();
1118     boundRboProps().target = target;
1119     boundRboProps().previouslyBound = true;
1120 }
1121
1122 GLuint GLClientState::boundRenderbuffer() const {
1123     return boundRboProps_const().name;
1124 }
1125
1126 void GLClientState::setBoundRenderbufferFormat(GLenum format) {
1127     boundRboProps().format = format;
1128 }
1129
1130 void GLClientState::setBoundRenderbufferSamples(GLsizei samples) {
1131     boundRboProps().multisamples = samples;
1132 }
1133
1134 // FBO//////////////////////////////////////////////////////////////////////////
1135
1136 // Format querying
1137
1138 GLenum GLClientState::queryRboFormat(GLuint rbo_name) const {
1139     return mRboState.rboData[getRboIndex(rbo_name)].format;
1140 }
1141
1142 GLsizei GLClientState::queryRboSamples(GLuint rbo_name) const {
1143     return mRboState.rboData[getRboIndex(rbo_name)].multisamples;
1144 }
1145
1146 GLint GLClientState::queryTexInternalFormat(GLuint tex_name) const {
1147     TextureRec* texrec = getTextureRec(tex_name);
1148     if (!texrec) return -1;
1149     return texrec->internalformat;
1150 }
1151
1152 GLsizei GLClientState::queryTexWidth(GLsizei level, GLuint tex_name) const {
1153     TextureRec* texrec = getTextureRec(tex_name);
1154     if (!texrec) {
1155         return 0;
1156     }
1157     return texrec->dims->widths[level];
1158 }
1159
1160 GLsizei GLClientState::queryTexHeight(GLsizei level, GLuint tex_name) const {
1161     TextureRec* texrec = getTextureRec(tex_name);
1162     if (!texrec) return 0;
1163     return texrec->dims->heights[level];
1164 }
1165
1166 GLsizei GLClientState::queryTexDepth(GLsizei level, GLuint tex_name) const {
1167     TextureRec* texrec = getTextureRec(tex_name);
1168     if (!texrec) return 0;
1169     return texrec->dims->depths[level];
1170 }
1171
1172 bool GLClientState::queryTexEGLImageBacked(GLuint tex_name) const {
1173     TextureRec* texrec = getTextureRec(tex_name);
1174     if (!texrec) return false;
1175     return texrec->boundEGLImage;
1176 }
1177
1178 GLenum GLClientState::queryTexFormat(GLuint tex_name) const {
1179     TextureRec* texrec = getTextureRec(tex_name);
1180     if (!texrec) return -1;
1181     return texrec->format;
1182 }
1183
1184 GLenum GLClientState::queryTexType(GLuint tex_name) const {
1185     TextureRec* texrec = getTextureRec(tex_name);
1186     if (!texrec) return -1;
1187     return texrec->type;
1188 }
1189
1190 GLsizei GLClientState::queryTexSamples(GLuint tex_name) const {
1191     TextureRec* texrec = getTextureRec(tex_name);
1192     if (!texrec) return 0;
1193     return texrec->multisamples;
1194 }
1195
1196 GLenum GLClientState::queryTexLastBoundTarget(GLuint tex_name) const {
1197     TextureRec* texrec = getTextureRec(tex_name);
1198     if (!texrec) return GL_NONE;
1199     return texrec->target;
1200 }
1201
1202 void GLClientState::getBoundFramebufferFormat(
1203         GLenum target,
1204         GLenum attachment, FboFormatInfo* res_info) const {
1205     const FboProps& props = boundFboProps_const(target);
1206
1207     res_info->type = FBO_ATTACHMENT_NONE;
1208     res_info->rb_format = GL_NONE;
1209     res_info->rb_multisamples = 0;
1210     res_info->tex_internalformat = -1;
1211     res_info->tex_format = GL_NONE;
1212     res_info->tex_type = GL_NONE;
1213     res_info->tex_multisamples = 0;
1214
1215     int colorAttachmentIndex =
1216         glUtilsColorAttachmentIndex(attachment);
1217
1218     if (colorAttachmentIndex != -1) {
1219         if (props.colorAttachmenti_hasRbo[colorAttachmentIndex]) {
1220             res_info->type = FBO_ATTACHMENT_RENDERBUFFER;
1221             res_info->rb_format =
1222                 queryRboFormat(
1223                         props.colorAttachmenti_rbos[colorAttachmentIndex]);
1224             res_info->rb_multisamples =
1225                 queryRboSamples(
1226                         props.colorAttachmenti_rbos[colorAttachmentIndex]);
1227         } else if (props.colorAttachmenti_hasTex[colorAttachmentIndex]) {
1228             res_info->type = FBO_ATTACHMENT_TEXTURE;
1229             res_info->tex_internalformat =
1230                 queryTexInternalFormat(
1231                         props.colorAttachmenti_textures[colorAttachmentIndex]);
1232             res_info->tex_format =
1233                 queryTexFormat(
1234                         props.colorAttachmenti_textures[colorAttachmentIndex]);
1235             res_info->tex_type =
1236                 queryTexType(props.colorAttachmenti_textures[colorAttachmentIndex]);
1237             res_info->tex_multisamples =
1238                 queryTexSamples(props.colorAttachmenti_textures[colorAttachmentIndex]);
1239         } else {
1240             res_info->type = FBO_ATTACHMENT_NONE;
1241         }
1242     }
1243
1244     switch (attachment) {
1245     case GL_DEPTH_ATTACHMENT:
1246         if (props.depthAttachment_hasRbo) {
1247             res_info->type = FBO_ATTACHMENT_RENDERBUFFER;
1248             res_info->rb_format = queryRboFormat(props.depthAttachment_rbo);
1249             res_info->rb_multisamples =
1250                 queryRboSamples(
1251                         props.colorAttachmenti_rbos[colorAttachmentIndex]);
1252         } else if (props.depthAttachment_hasTexObj) {
1253             res_info->type = FBO_ATTACHMENT_TEXTURE;
1254             res_info->tex_internalformat = queryTexInternalFormat(props.depthAttachment_texture);
1255             res_info->tex_format = queryTexFormat(props.depthAttachment_texture);
1256             res_info->tex_type = queryTexType(props.depthAttachment_texture);
1257             res_info->tex_multisamples =
1258                 queryTexSamples(props.colorAttachmenti_textures[colorAttachmentIndex]);
1259         } else {
1260             res_info->type = FBO_ATTACHMENT_NONE;
1261         }
1262         break;
1263     case GL_STENCIL_ATTACHMENT:
1264         if (props.stencilAttachment_hasRbo) {
1265             res_info->type = FBO_ATTACHMENT_RENDERBUFFER;
1266             res_info->rb_format = queryRboFormat(props.stencilAttachment_rbo);
1267             res_info->rb_multisamples =
1268                 queryRboSamples(
1269                         props.colorAttachmenti_rbos[colorAttachmentIndex]);
1270         } else if (props.stencilAttachment_hasTexObj) {
1271             res_info->type = FBO_ATTACHMENT_TEXTURE;
1272             res_info->tex_internalformat = queryTexInternalFormat(props.stencilAttachment_texture);
1273             res_info->tex_format = queryTexFormat(props.stencilAttachment_texture);
1274             res_info->tex_type = queryTexType(props.stencilAttachment_texture);
1275             res_info->tex_multisamples =
1276                 queryTexSamples(props.colorAttachmenti_textures[colorAttachmentIndex]);
1277         } else {
1278             res_info->type = FBO_ATTACHMENT_NONE;
1279         }
1280         break;
1281     case GL_DEPTH_STENCIL_ATTACHMENT:
1282         if (props.depthstencilAttachment_hasRbo) {
1283             res_info->type = FBO_ATTACHMENT_RENDERBUFFER;
1284             res_info->rb_format = queryRboFormat(props.depthstencilAttachment_rbo);
1285             res_info->rb_multisamples =
1286                 queryRboSamples(
1287                         props.colorAttachmenti_rbos[colorAttachmentIndex]);
1288         } else if (props.depthstencilAttachment_hasTexObj) {
1289             res_info->type = FBO_ATTACHMENT_TEXTURE;
1290             res_info->tex_internalformat = queryTexInternalFormat(props.depthstencilAttachment_texture);
1291             res_info->tex_format = queryTexFormat(props.depthstencilAttachment_texture);
1292             res_info->tex_type = queryTexType(props.depthstencilAttachment_texture);
1293             res_info->tex_multisamples =
1294                 queryTexSamples(props.colorAttachmenti_textures[colorAttachmentIndex]);
1295         } else {
1296             res_info->type = FBO_ATTACHMENT_NONE;
1297         }
1298         break;
1299     }
1300 }
1301
1302 FboAttachmentType GLClientState::getBoundFramebufferAttachmentType(GLenum target, GLenum attachment) const {
1303     FboFormatInfo info;
1304     getBoundFramebufferFormat(target, attachment, &info);
1305     return info.type;
1306 }
1307
1308
1309 int GLClientState::getMaxColorAttachments() const {
1310     return m_max_color_attachments;
1311 }
1312
1313 int GLClientState::getMaxDrawBuffers() const {
1314     return m_max_draw_buffers;
1315 }
1316
1317 void GLClientState::addFreshFramebuffer(GLuint name) {
1318     FboProps props;
1319     props.name = name;
1320     props.previouslyBound = false;
1321
1322     props.colorAttachmenti_textures.resize(m_max_color_attachments, 0);
1323     props.depthAttachment_texture = 0;
1324     props.stencilAttachment_texture = 0;
1325     props.depthstencilAttachment_texture = 0;
1326
1327     props.colorAttachmenti_hasTex.resize(m_max_color_attachments, false);
1328     props.depthAttachment_hasTexObj = false;
1329     props.stencilAttachment_hasTexObj = false;
1330     props.depthstencilAttachment_hasTexObj = false;
1331
1332     props.colorAttachmenti_rbos.resize(m_max_color_attachments, 0);
1333     props.depthAttachment_rbo = 0;
1334     props.stencilAttachment_rbo = 0;
1335     props.depthstencilAttachment_rbo = 0;
1336
1337     props.colorAttachmenti_hasRbo.resize(m_max_color_attachments, false);
1338     props.depthAttachment_hasRbo = false;
1339     props.stencilAttachment_hasRbo = false;
1340     props.depthstencilAttachment_hasRbo = false;
1341     mFboState.fboData[name] = props;
1342 }
1343
1344 void GLClientState::addFramebuffers(GLsizei n, GLuint* framebuffers) {
1345     for (size_t i = 0; i < n; i++) {
1346         addFreshFramebuffer(framebuffers[i]);
1347     }
1348 }
1349
1350 void GLClientState::removeFramebuffers(GLsizei n, const GLuint* framebuffers) {
1351     for (size_t i = 0; i < n; i++) {
1352         if (framebuffers[i] != 0) { // Never remove the zero fb.
1353             if (framebuffers[i] == mFboState.boundDrawFramebuffer) {
1354                 bindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
1355             }
1356             if (framebuffers[i] == mFboState.boundReadFramebuffer) {
1357                 bindFramebuffer(GL_READ_FRAMEBUFFER, 0);
1358             }
1359             mFboState.fboData.erase(framebuffers[i]);
1360         }
1361     }
1362 }
1363
1364 bool GLClientState::usedFramebufferName(GLuint name) const {
1365     return mFboState.fboData.find(name) != mFboState.fboData.end();
1366 }
1367
1368 FboProps& GLClientState::boundFboProps(GLenum target) {
1369     switch (target) {
1370     case GL_DRAW_FRAMEBUFFER:
1371         return mFboState.fboData[mFboState.boundDrawFramebuffer];
1372     case GL_READ_FRAMEBUFFER:
1373         return mFboState.fboData[mFboState.boundReadFramebuffer];
1374     case GL_FRAMEBUFFER:
1375         return mFboState.fboData[mFboState.boundDrawFramebuffer];
1376     }
1377     return mFboState.fboData[mFboState.boundDrawFramebuffer];
1378 }
1379
1380 const FboProps& GLClientState::boundFboProps_const(GLenum target) const {
1381     switch (target) {
1382     case GL_DRAW_FRAMEBUFFER:
1383         return mFboState.fboData.find(mFboState.boundDrawFramebuffer)->second;
1384     case GL_READ_FRAMEBUFFER:
1385         return mFboState.fboData.find(mFboState.boundReadFramebuffer)->second;
1386     case GL_FRAMEBUFFER:
1387         return mFboState.fboData.find(mFboState.boundDrawFramebuffer)->second;
1388     }
1389     return mFboState.fboData.find(mFboState.boundDrawFramebuffer)->second;
1390 }
1391
1392 void GLClientState::bindFramebuffer(GLenum target, GLuint name) {
1393     // If unused, add it.
1394     if (!usedFramebufferName(name)) {
1395         addFreshFramebuffer(name);
1396     }
1397     switch (target) {
1398         case GL_DRAW_FRAMEBUFFER:
1399             mFboState.boundDrawFramebuffer = name;
1400             break;
1401         case GL_READ_FRAMEBUFFER:
1402             mFboState.boundReadFramebuffer = name;
1403             break;
1404         default: // case GL_FRAMEBUFFER:
1405             mFboState.boundDrawFramebuffer = name;
1406             mFboState.boundReadFramebuffer = name;
1407             break;
1408     }
1409     boundFboProps(target).previouslyBound = true;
1410 }
1411
1412 void GLClientState::setCheckFramebufferStatus(GLenum target, GLenum status) {
1413     switch (target) {
1414         case GL_DRAW_FRAMEBUFFER:
1415             mFboState.drawFboCheckStatus = status;
1416             break;
1417         case GL_READ_FRAMEBUFFER:
1418             mFboState.readFboCheckStatus = status;
1419             break;
1420         case GL_FRAMEBUFFER:
1421             mFboState.drawFboCheckStatus = status;
1422             break;
1423     }
1424 }
1425
1426 GLenum GLClientState::getCheckFramebufferStatus(GLenum target) const {
1427     switch (target) {
1428     case GL_DRAW_FRAMEBUFFER:
1429         return mFboState.drawFboCheckStatus;
1430     case GL_READ_FRAMEBUFFER:
1431         return mFboState.readFboCheckStatus;
1432     case GL_FRAMEBUFFER:
1433         return mFboState.drawFboCheckStatus;
1434     }
1435     return mFboState.drawFboCheckStatus;
1436 }
1437
1438 GLuint GLClientState::boundFramebuffer(GLenum target) const {
1439     return boundFboProps_const(target).name;
1440 }
1441
1442 // Texture objects for FBOs/////////////////////////////////////////////////////
1443
1444 void GLClientState::attachTextureObject(
1445         GLenum target,
1446         GLenum attachment, GLuint texture) {
1447
1448     int colorAttachmentIndex =
1449         glUtilsColorAttachmentIndex(attachment);
1450
1451     if (colorAttachmentIndex != -1) {
1452         boundFboProps(target).colorAttachmenti_textures[colorAttachmentIndex] = texture;
1453         boundFboProps(target).colorAttachmenti_hasTex[colorAttachmentIndex] = true;
1454     }
1455
1456     switch (attachment) {
1457     case GL_DEPTH_ATTACHMENT:
1458         boundFboProps(target).depthAttachment_texture = texture;
1459         boundFboProps(target).depthAttachment_hasTexObj = true;
1460         break;
1461     case GL_STENCIL_ATTACHMENT:
1462         boundFboProps(target).stencilAttachment_texture = texture;
1463         boundFboProps(target).stencilAttachment_hasTexObj = true;
1464         break;
1465     case GL_DEPTH_STENCIL_ATTACHMENT:
1466         boundFboProps(target).depthstencilAttachment_texture = texture;
1467         boundFboProps(target).depthstencilAttachment_hasTexObj = true;
1468         boundFboProps(target).stencilAttachment_texture = texture;
1469         boundFboProps(target).stencilAttachment_hasTexObj = true;
1470         boundFboProps(target).depthAttachment_texture = texture;
1471         boundFboProps(target).depthAttachment_hasTexObj = true;
1472         break;
1473     }
1474 }
1475
1476 GLuint GLClientState::getFboAttachmentTextureId(GLenum target, GLenum attachment) const {
1477     GLuint res = 0; // conservative
1478
1479     int colorAttachmentIndex =
1480         glUtilsColorAttachmentIndex(attachment);
1481
1482     if (colorAttachmentIndex != -1) {
1483         res = boundFboProps_const(target).colorAttachmenti_textures[colorAttachmentIndex];
1484     }
1485
1486     switch (attachment) {
1487     case GL_DEPTH_ATTACHMENT:
1488         res = boundFboProps_const(target).depthAttachment_texture;
1489         break;
1490     case GL_STENCIL_ATTACHMENT:
1491         res = boundFboProps_const(target).stencilAttachment_texture;
1492         break;
1493     case GL_DEPTH_STENCIL_ATTACHMENT:
1494         res = boundFboProps_const(target).depthstencilAttachment_texture;
1495         break;
1496     }
1497     return res;
1498 }
1499
1500 // RBOs for FBOs////////////////////////////////////////////////////////////////
1501
1502 void GLClientState::detachRbo(GLuint renderbuffer) {
1503     for (int i = 0; i < m_max_color_attachments; i++) {
1504         detachRboFromFbo(GL_DRAW_FRAMEBUFFER, glUtilsColorAttachmentName(i), renderbuffer);
1505         detachRboFromFbo(GL_READ_FRAMEBUFFER, glUtilsColorAttachmentName(i), renderbuffer);
1506     }
1507
1508     detachRboFromFbo(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, renderbuffer);
1509     detachRboFromFbo(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, renderbuffer);
1510
1511     detachRboFromFbo(GL_DRAW_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, renderbuffer);
1512     detachRboFromFbo(GL_READ_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, renderbuffer);
1513
1514     detachRboFromFbo(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, renderbuffer);
1515     detachRboFromFbo(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, renderbuffer);
1516 }
1517
1518 void GLClientState::detachRboFromFbo(GLenum target, GLenum attachment, GLuint renderbuffer) {
1519     int colorAttachmentIndex =
1520         glUtilsColorAttachmentIndex(attachment);
1521
1522     if (colorAttachmentIndex != -1) {
1523         if (boundFboProps(target).colorAttachmenti_hasRbo[colorAttachmentIndex] &&
1524             boundFboProps(target).colorAttachmenti_rbos[colorAttachmentIndex] == renderbuffer) {
1525             boundFboProps(target).colorAttachmenti_rbos[colorAttachmentIndex] = 0;
1526             boundFboProps(target).colorAttachmenti_hasRbo[colorAttachmentIndex] = false;
1527         }
1528     }
1529
1530     switch (attachment) {
1531     case GL_DEPTH_ATTACHMENT:
1532         if (boundFboProps(target).depthAttachment_rbo == renderbuffer &&
1533             boundFboProps(target).depthAttachment_hasRbo) {
1534             boundFboProps(target).depthAttachment_rbo = 0;
1535             boundFboProps(target).depthAttachment_hasRbo = false;
1536         }
1537         break;
1538     case GL_STENCIL_ATTACHMENT:
1539         if (boundFboProps(target).stencilAttachment_rbo == renderbuffer &&
1540             boundFboProps(target).stencilAttachment_hasRbo) {
1541             boundFboProps(target).stencilAttachment_rbo = 0;
1542             boundFboProps(target).stencilAttachment_hasRbo = false;
1543         }
1544         break;
1545     case GL_DEPTH_STENCIL_ATTACHMENT:
1546         if (boundFboProps(target).depthAttachment_rbo == renderbuffer &&
1547             boundFboProps(target).depthAttachment_hasRbo) {
1548             boundFboProps(target).depthAttachment_rbo = 0;
1549             boundFboProps(target).depthAttachment_hasRbo = false;
1550         }
1551         if (boundFboProps(target).stencilAttachment_rbo == renderbuffer &&
1552             boundFboProps(target).stencilAttachment_hasRbo) {
1553             boundFboProps(target).stencilAttachment_rbo = 0;
1554             boundFboProps(target).stencilAttachment_hasRbo = false;
1555         }
1556         if (boundFboProps(target).depthstencilAttachment_rbo == renderbuffer &&
1557             boundFboProps(target).depthstencilAttachment_hasRbo) {
1558             boundFboProps(target).depthstencilAttachment_rbo = 0;
1559             boundFboProps(target).depthstencilAttachment_hasRbo = false;
1560         }
1561         break;
1562     }
1563 }
1564
1565 void GLClientState::attachRbo(GLenum target, GLenum attachment, GLuint renderbuffer) {
1566
1567     int colorAttachmentIndex =
1568         glUtilsColorAttachmentIndex(attachment);
1569
1570     if (colorAttachmentIndex != -1) {
1571         boundFboProps(target).colorAttachmenti_rbos[colorAttachmentIndex] = renderbuffer;
1572         boundFboProps(target).colorAttachmenti_hasRbo[colorAttachmentIndex] = true;
1573     }
1574
1575     switch (attachment) {
1576     case GL_DEPTH_ATTACHMENT:
1577         boundFboProps(target).depthAttachment_rbo = renderbuffer;
1578         boundFboProps(target).depthAttachment_hasRbo = true;
1579         break;
1580     case GL_STENCIL_ATTACHMENT:
1581         boundFboProps(target).stencilAttachment_rbo = renderbuffer;
1582         boundFboProps(target).stencilAttachment_hasRbo = true;
1583         break;
1584     case GL_DEPTH_STENCIL_ATTACHMENT:
1585         boundFboProps(target).depthAttachment_rbo = renderbuffer;
1586         boundFboProps(target).depthAttachment_hasRbo = true;
1587         boundFboProps(target).stencilAttachment_rbo = renderbuffer;
1588         boundFboProps(target).stencilAttachment_hasRbo = true;
1589         boundFboProps(target).depthstencilAttachment_rbo = renderbuffer;
1590         boundFboProps(target).depthstencilAttachment_hasRbo = true;
1591         break;
1592     }
1593 }
1594
1595 GLuint GLClientState::getFboAttachmentRboId(GLenum target, GLenum attachment) const {
1596     GLuint res = 0; // conservative
1597
1598     int colorAttachmentIndex =
1599         glUtilsColorAttachmentIndex(attachment);
1600
1601     if (colorAttachmentIndex != -1) {
1602         res = boundFboProps_const(target).colorAttachmenti_rbos[colorAttachmentIndex];
1603     }
1604
1605     switch (attachment) {
1606     case GL_DEPTH_ATTACHMENT:
1607         res = boundFboProps_const(target).depthAttachment_rbo;
1608         break;
1609     case GL_STENCIL_ATTACHMENT:
1610         res = boundFboProps_const(target).stencilAttachment_rbo;
1611         break;
1612     case GL_DEPTH_STENCIL_ATTACHMENT:
1613         res = boundFboProps_const(target).depthstencilAttachment_rbo;
1614         break;
1615     }
1616     return res;
1617 }
1618
1619 bool GLClientState::attachmentHasObject(GLenum target, GLenum attachment) const {
1620     bool res = true; // liberal
1621
1622     int colorAttachmentIndex =
1623         glUtilsColorAttachmentIndex(attachment);
1624
1625     if (colorAttachmentIndex != -1) {
1626         res = boundFboProps_const(target).colorAttachmenti_hasTex[colorAttachmentIndex] ||
1627               boundFboProps_const(target).colorAttachmenti_hasRbo[colorAttachmentIndex];
1628     }
1629
1630     switch (attachment) {
1631     case GL_DEPTH_ATTACHMENT:
1632         res = (boundFboProps_const(target).depthAttachment_hasTexObj) ||
1633               (boundFboProps_const(target).depthAttachment_hasRbo);
1634         break;
1635     case GL_STENCIL_ATTACHMENT:
1636         res = (boundFboProps_const(target).stencilAttachment_hasTexObj) ||
1637               (boundFboProps_const(target).stencilAttachment_hasRbo);
1638         break;
1639     case GL_DEPTH_STENCIL_ATTACHMENT:
1640         res = (boundFboProps_const(target).depthstencilAttachment_hasTexObj) ||
1641               (boundFboProps_const(target).depthstencilAttachment_hasRbo);
1642         break;
1643     }
1644     return res;
1645 }
1646
1647 GLuint GLClientState::objectOfAttachment(GLenum target, GLenum attachment) const {
1648     const FboProps& props = boundFboProps_const(target);
1649
1650     int colorAttachmentIndex =
1651         glUtilsColorAttachmentIndex(attachment);
1652
1653     if (colorAttachmentIndex != -1) {
1654         if (props.colorAttachmenti_hasTex[colorAttachmentIndex]) {
1655             return props.colorAttachmenti_textures[colorAttachmentIndex];
1656         } else if (props.colorAttachmenti_hasRbo[colorAttachmentIndex]) {
1657             return props.colorAttachmenti_rbos[colorAttachmentIndex];
1658         } else {
1659             return 0;
1660         }
1661     }
1662
1663     switch (attachment) {
1664     case GL_DEPTH_ATTACHMENT:
1665         if (props.depthAttachment_hasTexObj) {
1666             return props.depthAttachment_texture;
1667         } else if (props.depthAttachment_hasRbo) {
1668             return props.depthAttachment_rbo;
1669         } else {
1670             return 0;
1671         }
1672         break;
1673     case GL_STENCIL_ATTACHMENT:
1674         if (props.stencilAttachment_hasTexObj) {
1675             return props.stencilAttachment_texture;
1676         } else if (props.stencilAttachment_hasRbo) {
1677             return props.stencilAttachment_rbo;
1678         } else {
1679             return 0;
1680         }
1681     case GL_DEPTH_STENCIL_ATTACHMENT:
1682         if (props.depthstencilAttachment_hasTexObj) {
1683             return props.depthstencilAttachment_texture;
1684         } else if (props.depthstencilAttachment_hasRbo) {
1685             return props.depthstencilAttachment_rbo;
1686         } else {
1687             return 0;
1688         }
1689         break;
1690     }
1691     return 0;
1692 }
1693
1694 void GLClientState::setTransformFeedbackActiveUnpaused(bool activeUnpaused) {
1695     m_transformFeedbackActiveUnpaused = activeUnpaused;
1696 }
1697
1698 bool GLClientState::getTransformFeedbackActiveUnpaused() const {
1699     return m_transformFeedbackActiveUnpaused;
1700 }
1701
1702 void GLClientState::setTextureData(SharedTextureDataMap* sharedTexData) {
1703     m_tex.textureRecs = sharedTexData;
1704 }
1705
1706 void GLClientState::fromMakeCurrent() {
1707     if (mFboState.fboData.find(0) == mFboState.fboData.end()) {
1708         addFreshFramebuffer(0);
1709     }
1710     FboProps& default_fb_props = mFboState.fboData[0];
1711     default_fb_props.colorAttachmenti_hasRbo[0] = true;
1712     default_fb_props.depthAttachment_hasRbo = true;
1713     default_fb_props.stencilAttachment_hasRbo = true;
1714     default_fb_props.depthstencilAttachment_hasRbo = true;
1715 }
1716
1717 void GLClientState::initFromCaps(
1718     int max_transform_feedback_separate_attribs,
1719     int max_uniform_buffer_bindings,
1720     int max_atomic_counter_buffer_bindings,
1721     int max_shader_storage_buffer_bindings,
1722     int max_vertex_attrib_bindings,
1723     int max_color_attachments,
1724     int max_draw_buffers) {
1725
1726     m_max_vertex_attrib_bindings = max_vertex_attrib_bindings;
1727
1728     if (m_glesMajorVersion >= 3) {
1729         m_max_transform_feedback_separate_attribs = max_transform_feedback_separate_attribs;
1730         m_max_uniform_buffer_bindings = max_uniform_buffer_bindings;
1731         m_max_atomic_counter_buffer_bindings = max_atomic_counter_buffer_bindings;
1732         m_max_shader_storage_buffer_bindings = max_shader_storage_buffer_bindings;
1733
1734         if (m_max_transform_feedback_separate_attribs)
1735             m_indexedTransformFeedbackBuffers.resize(m_max_transform_feedback_separate_attribs);
1736         if (m_max_uniform_buffer_bindings)
1737             m_indexedUniformBuffers.resize(m_max_uniform_buffer_bindings);
1738         if (m_max_atomic_counter_buffer_bindings)
1739             m_indexedAtomicCounterBuffers.resize(m_max_atomic_counter_buffer_bindings);
1740         if (m_max_shader_storage_buffer_bindings)
1741             m_indexedShaderStorageBuffers.resize(m_max_shader_storage_buffer_bindings);
1742
1743         BufferBinding buf0Binding;
1744         buf0Binding.buffer = 0;
1745         buf0Binding.offset = 0;
1746         buf0Binding.size = 0;
1747         buf0Binding.stride = 0;
1748         buf0Binding.effectiveStride = 0;
1749
1750         for (size_t i = 0; i < m_indexedTransformFeedbackBuffers.size(); ++i)
1751             m_indexedTransformFeedbackBuffers[i] = buf0Binding;
1752         for (size_t i = 0; i < m_indexedUniformBuffers.size(); ++i)
1753             m_indexedUniformBuffers[i] = buf0Binding;
1754         for (size_t i = 0; i < m_indexedAtomicCounterBuffers.size(); ++i)
1755             m_indexedAtomicCounterBuffers[i] = buf0Binding;
1756         for (size_t i = 0; i < m_indexedShaderStorageBuffers.size(); ++i)
1757             m_indexedShaderStorageBuffers[i] = buf0Binding;
1758     }
1759
1760     m_max_color_attachments = max_color_attachments;
1761     m_max_draw_buffers = max_draw_buffers;
1762
1763     addFreshRenderbuffer(0);
1764     addFreshFramebuffer(0);
1765
1766     m_initialized = true;
1767 }
1768
1769 bool GLClientState::needsInitFromCaps() const {
1770     return !m_initialized;
1771 }