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 "ErrorLog.h" 18 #include <stdio.h> 19 #include <stdlib.h> 20 #include <string.h> 21 #include "glUtils.h" 22 #include <cutils/log.h> 23 24 #ifndef MAX 25 #define MAX(a, b) ((a) < (b) ? (b) : (a)) 26 #endif 27 28 GLClientState::GLClientState(int nLocations) 29 { 30 if (nLocations < LAST_LOCATION) { 31 nLocations = LAST_LOCATION; 32 } 33 m_nLocations = nLocations; 34 m_states = new VertexAttribState[m_nLocations]; 35 for (int i = 0; i < m_nLocations; i++) { 36 m_states[i].enabled = 0; 37 m_states[i].enableDirty = false; 38 m_states[i].data = 0; 39 } 40 m_currentArrayVbo = 0; 41 m_currentIndexVbo = 0; 42 // init gl constans; 43 m_states[VERTEX_LOCATION].glConst = GL_VERTEX_ARRAY; 44 m_states[NORMAL_LOCATION].glConst = GL_NORMAL_ARRAY; 45 m_states[COLOR_LOCATION].glConst = GL_COLOR_ARRAY; 46 m_states[POINTSIZE_LOCATION].glConst = GL_POINT_SIZE_ARRAY_OES; 47 m_states[TEXCOORD0_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY; 48 m_states[TEXCOORD1_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY; 49 m_states[TEXCOORD2_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY; 50 m_states[TEXCOORD3_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY; 51 m_states[TEXCOORD4_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY; 52 m_states[TEXCOORD5_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY; 53 m_states[TEXCOORD6_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY; 54 m_states[TEXCOORD7_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY; 55 m_states[MATRIXINDEX_LOCATION].glConst = GL_MATRIX_INDEX_ARRAY_OES; 56 m_states[WEIGHT_LOCATION].glConst = GL_WEIGHT_ARRAY_OES; 57 m_activeTexture = 0; 58 m_currentProgram = 0; 59 60 m_pixelStore.unpack_alignment = 4; 61 m_pixelStore.pack_alignment = 4; 62 63 memset(m_tex.unit, 0, sizeof(m_tex.unit)); 64 m_tex.activeUnit = &m_tex.unit[0]; 65 m_tex.textures = NULL; 66 m_tex.numTextures = 0; 67 m_tex.allocTextures = 0; 68 69 mRboState.boundRenderbuffer = 0; 70 mRboState.boundRenderbufferIndex = 0; 71 addFreshRenderbuffer(0); 72 73 mFboState.boundFramebuffer = 0; 74 mFboState.boundFramebufferIndex = 0; 75 mFboState.fboCheckStatus = GL_NONE; 76 addFreshFramebuffer(0); 77 78 m_maxVertexAttribsDirty = true; 79 } 80 81 GLClientState::~GLClientState() 82 { 83 delete m_states; 84 } 85 86 void GLClientState::enable(int location, int state) 87 { 88 if (!validLocation(location)) { 89 return; 90 } 91 92 m_states[location].enableDirty |= (state != m_states[location].enabled); 93 m_states[location].enabled = state; 94 } 95 96 void GLClientState::setState(int location, int size, GLenum type, GLboolean normalized, GLsizei stride, const void *data) 97 { 98 if (!validLocation(location)) { 99 return; 100 } 101 m_states[location].size = size; 102 m_states[location].type = type; 103 m_states[location].stride = stride; 104 m_states[location].data = (void*)data; 105 m_states[location].bufferObject = m_currentArrayVbo; 106 m_states[location].elementSize = size ? (glSizeof(type) * size) : 0; 107 m_states[location].normalized = normalized; 108 } 109 110 void GLClientState::setBufferObject(int location, GLuint id) 111 { 112 if (!validLocation(location)) { 113 return; 114 } 115 116 m_states[location].bufferObject = id; 117 } 118 119 const GLClientState::VertexAttribState * GLClientState::getState(int location) 120 { 121 if (!validLocation(location)) { 122 return NULL; 123 } 124 return & m_states[location]; 125 } 126 127 const GLClientState::VertexAttribState * GLClientState::getStateAndEnableDirty(int location, bool *enableChanged) 128 { 129 if (!validLocation(location)) { 130 return NULL; 131 } 132 133 if (enableChanged) { 134 *enableChanged = m_states[location].enableDirty; 135 } 136 137 m_states[location].enableDirty = false; 138 return & m_states[location]; 139 } 140 141 int GLClientState::getLocation(GLenum loc) 142 { 143 int retval; 144 145 switch(loc) { 146 case GL_VERTEX_ARRAY: 147 retval = int(VERTEX_LOCATION); 148 break; 149 case GL_NORMAL_ARRAY: 150 retval = int(NORMAL_LOCATION); 151 break; 152 case GL_COLOR_ARRAY: 153 retval = int(COLOR_LOCATION); 154 break; 155 case GL_POINT_SIZE_ARRAY_OES: 156 retval = int(POINTSIZE_LOCATION); 157 break; 158 case GL_TEXTURE_COORD_ARRAY: 159 retval = int (TEXCOORD0_LOCATION + m_activeTexture); 160 break; 161 case GL_MATRIX_INDEX_ARRAY_OES: 162 retval = int (MATRIXINDEX_LOCATION); 163 break; 164 case GL_WEIGHT_ARRAY_OES: 165 retval = int (WEIGHT_LOCATION); 166 break; 167 default: 168 retval = loc; 169 } 170 return retval; 171 } 172 173 void GLClientState::getClientStatePointer(GLenum pname, GLvoid** params) 174 { 175 const GLClientState::VertexAttribState *state = NULL; 176 switch (pname) { 177 case GL_VERTEX_ARRAY_POINTER: { 178 state = getState(GLClientState::VERTEX_LOCATION); 179 break; 180 } 181 case GL_NORMAL_ARRAY_POINTER: { 182 state = getState(GLClientState::NORMAL_LOCATION); 183 break; 184 } 185 case GL_COLOR_ARRAY_POINTER: { 186 state = getState(GLClientState::COLOR_LOCATION); 187 break; 188 } 189 case GL_TEXTURE_COORD_ARRAY_POINTER: { 190 state = getState(getActiveTexture() + GLClientState::TEXCOORD0_LOCATION); 191 break; 192 } 193 case GL_POINT_SIZE_ARRAY_POINTER_OES: { 194 state = getState(GLClientState::POINTSIZE_LOCATION); 195 break; 196 } 197 case GL_MATRIX_INDEX_ARRAY_POINTER_OES: { 198 state = getState(GLClientState::MATRIXINDEX_LOCATION); 199 break; 200 } 201 case GL_WEIGHT_ARRAY_POINTER_OES: { 202 state = getState(GLClientState::WEIGHT_LOCATION); 203 break; 204 } 205 } 206 if (state && params) 207 *params = state->data; 208 } 209 210 int GLClientState::setPixelStore(GLenum param, GLint value) 211 { 212 int retval = 0; 213 switch(param) { 214 case GL_UNPACK_ALIGNMENT: 215 if (value == 1 || value == 2 || value == 4 || value == 8) { 216 m_pixelStore.unpack_alignment = value; 217 } else { 218 retval = GL_INVALID_VALUE; 219 } 220 break; 221 case GL_PACK_ALIGNMENT: 222 if (value == 1 || value == 2 || value == 4 || value == 8) { 223 m_pixelStore.pack_alignment = value; 224 } else { 225 retval = GL_INVALID_VALUE; 226 } 227 break; 228 default: 229 retval = GL_INVALID_ENUM; 230 } 231 return retval; 232 } 233 234 235 236 237 size_t GLClientState::pixelDataSize(GLsizei width, GLsizei height, GLenum format, GLenum type, int pack) const 238 { 239 if (width <= 0 || height <= 0) return 0; 240 241 int pixelsize = glUtilsPixelBitSize(format, type) >> 3; 242 243 int alignment = pack ? m_pixelStore.pack_alignment : m_pixelStore.unpack_alignment; 244 245 if (pixelsize == 0 ) { 246 ERR("unknown pixel size: width: %d height: %d format: %d type: %d pack: %d align: %d\n", 247 width, height, format, type, pack, alignment); 248 } 249 size_t linesize = pixelsize * width; 250 size_t aligned_linesize = int(linesize / alignment) * alignment; 251 if (aligned_linesize < linesize) { 252 aligned_linesize += alignment; 253 } 254 return aligned_linesize * height; 255 } 256 257 GLenum GLClientState::setActiveTextureUnit(GLenum texture) 258 { 259 GLuint unit = texture - GL_TEXTURE0; 260 if (unit >= MAX_TEXTURE_UNITS) { 261 return GL_INVALID_ENUM; 262 } 263 m_tex.activeUnit = &m_tex.unit[unit]; 264 return GL_NO_ERROR; 265 } 266 267 GLenum GLClientState::getActiveTextureUnit() const 268 { 269 return GL_TEXTURE0 + (m_tex.activeUnit - &m_tex.unit[0]); 270 } 271 272 void GLClientState::enableTextureTarget(GLenum target) 273 { 274 switch (target) { 275 case GL_TEXTURE_2D: 276 m_tex.activeUnit->enables |= (1u << TEXTURE_2D); 277 break; 278 case GL_TEXTURE_EXTERNAL_OES: 279 m_tex.activeUnit->enables |= (1u << TEXTURE_EXTERNAL); 280 break; 281 } 282 } 283 284 void GLClientState::disableTextureTarget(GLenum target) 285 { 286 switch (target) { 287 case GL_TEXTURE_2D: 288 m_tex.activeUnit->enables &= ~(1u << TEXTURE_2D); 289 break; 290 case GL_TEXTURE_EXTERNAL_OES: 291 m_tex.activeUnit->enables &= ~(1u << TEXTURE_EXTERNAL); 292 break; 293 } 294 } 295 296 GLenum GLClientState::getPriorityEnabledTarget(GLenum allDisabled) const 297 { 298 unsigned int enables = m_tex.activeUnit->enables; 299 if (enables & (1u << TEXTURE_EXTERNAL)) { 300 return GL_TEXTURE_EXTERNAL_OES; 301 } else if (enables & (1u << TEXTURE_2D)) { 302 return GL_TEXTURE_2D; 303 } else { 304 return allDisabled; 305 } 306 } 307 308 int GLClientState::compareTexId(const void* pid, const void* prec) 309 { 310 const GLuint* id = (const GLuint*)pid; 311 const TextureRec* rec = (const TextureRec*)prec; 312 return (GLint)(*id) - (GLint)rec->id; 313 } 314 315 GLenum GLClientState::bindTexture(GLenum target, GLuint texture, 316 GLboolean* firstUse) 317 { 318 GLboolean first = GL_FALSE; 319 TextureRec* texrec = NULL; 320 if (texture != 0) { 321 if (m_tex.textures) { 322 texrec = (TextureRec*)bsearch(&texture, m_tex.textures, 323 m_tex.numTextures, sizeof(TextureRec), compareTexId); 324 } 325 if (!texrec) { 326 if (!(texrec = addTextureRec(texture, target))) { 327 return GL_OUT_OF_MEMORY; 328 } 329 first = GL_TRUE; 330 } 331 if (target != texrec->target) { 332 return GL_INVALID_OPERATION; 333 } 334 } 335 336 switch (target) { 337 case GL_TEXTURE_2D: 338 m_tex.activeUnit->texture[TEXTURE_2D] = texture; 339 break; 340 case GL_TEXTURE_EXTERNAL_OES: 341 m_tex.activeUnit->texture[TEXTURE_EXTERNAL] = texture; 342 break; 343 } 344 345 if (firstUse) { 346 *firstUse = first; 347 } 348 349 return GL_NO_ERROR; 350 } 351 352 GLClientState::TextureRec* GLClientState::addTextureRec(GLuint id, 353 GLenum target) 354 { 355 if (m_tex.numTextures == m_tex.allocTextures) { 356 const GLuint MAX_TEXTURES = 0xFFFFFFFFu; 357 358 GLuint newAlloc; 359 if (MAX_TEXTURES - m_tex.allocTextures >= m_tex.allocTextures) { 360 newAlloc = MAX(4, 2 * m_tex.allocTextures); 361 } else { 362 if (m_tex.allocTextures == MAX_TEXTURES) { 363 return NULL; 364 } 365 newAlloc = MAX_TEXTURES; 366 } 367 368 TextureRec* newTextures = (TextureRec*)realloc(m_tex.textures, 369 newAlloc * sizeof(TextureRec)); 370 if (!newTextures) { 371 return NULL; 372 } 373 374 m_tex.textures = newTextures; 375 m_tex.allocTextures = newAlloc; 376 } 377 378 TextureRec* tex = m_tex.textures + m_tex.numTextures; 379 TextureRec* prev = tex - 1; 380 while (tex != m_tex.textures && id < prev->id) { 381 *tex-- = *prev--; 382 } 383 tex->id = id; 384 tex->target = target; 385 tex->format = -1; 386 m_tex.numTextures++; 387 388 return tex; 389 } 390 391 void GLClientState::setBoundTextureInternalFormat(GLenum target, GLint internalformat) { 392 GLuint texture = getBoundTexture(target); 393 TextureRec* texrec = NULL; 394 texrec = (TextureRec*)bsearch(&texture, m_tex.textures, 395 m_tex.numTextures, 396 sizeof(TextureRec), 397 compareTexId); 398 if (!texrec) return; 399 texrec->internalformat = internalformat; 400 } 401 402 void GLClientState::setBoundTextureFormat(GLenum target, GLenum format) { 403 GLuint texture = getBoundTexture(target); 404 TextureRec* texrec = NULL; 405 texrec = (TextureRec*)bsearch(&texture, m_tex.textures, 406 m_tex.numTextures, 407 sizeof(TextureRec), 408 compareTexId); 409 if (!texrec) return; 410 texrec->format = format; 411 } 412 413 void GLClientState::setBoundTextureType(GLenum target, GLenum type) { 414 GLuint texture = getBoundTexture(target); 415 TextureRec* texrec = NULL; 416 texrec = (TextureRec*)bsearch(&texture, m_tex.textures, 417 m_tex.numTextures, 418 sizeof(TextureRec), 419 compareTexId); 420 if (!texrec) return; 421 texrec->type = type; 422 } 423 424 GLuint GLClientState::getBoundTexture(GLenum target) const 425 { 426 switch (target) { 427 case GL_TEXTURE_2D: 428 return m_tex.activeUnit->texture[TEXTURE_2D]; 429 case GL_TEXTURE_EXTERNAL_OES: 430 return m_tex.activeUnit->texture[TEXTURE_EXTERNAL]; 431 default: 432 return 0; 433 } 434 } 435 436 // BEGIN driver workarounds-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- 437 // (>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')> 438 439 static bool unreliableInternalFormat(GLenum internalformat) { 440 switch (internalformat) { 441 case GL_LUMINANCE: 442 return true; 443 default: 444 return false; 445 } 446 } 447 448 void GLClientState::writeCopyTexImageState 449 (GLenum target, GLint level, GLenum internalformat) { 450 if (unreliableInternalFormat(internalformat)) { 451 CubeMapDef entry; 452 entry.id = getBoundTexture(GL_TEXTURE_2D); 453 entry.target = target; 454 entry.level = level; 455 entry.internalformat = internalformat; 456 m_cubeMapDefs.insert(entry); 457 } 458 } 459 460 static GLenum identifyPositiveCubeMapComponent(GLenum target) { 461 switch (target) { 462 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: 463 return GL_TEXTURE_CUBE_MAP_POSITIVE_X; 464 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: 465 return GL_TEXTURE_CUBE_MAP_POSITIVE_Y; 466 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: 467 return GL_TEXTURE_CUBE_MAP_POSITIVE_Z; 468 default: 469 return 0; 470 } 471 } 472 473 GLenum GLClientState::copyTexImageNeededTarget 474 (GLenum target, GLint level, GLenum internalformat) { 475 if (unreliableInternalFormat(internalformat)) { 476 GLenum positiveComponent = 477 identifyPositiveCubeMapComponent(target); 478 if (positiveComponent) { 479 CubeMapDef query; 480 query.id = getBoundTexture(GL_TEXTURE_2D); 481 query.target = positiveComponent; 482 query.level = level; 483 query.internalformat = internalformat; 484 if (m_cubeMapDefs.find(query) == 485 m_cubeMapDefs.end()) { 486 return positiveComponent; 487 } 488 } 489 } 490 return 0; 491 } 492 493 GLenum GLClientState::copyTexImageLuminanceCubeMapAMDWorkaround 494 (GLenum target, GLint level, GLenum internalformat) { 495 writeCopyTexImageState(target, level, internalformat); 496 return copyTexImageNeededTarget(target, level, internalformat); 497 } 498 499 // (>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')> 500 // END driver workarounds-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- 501 502 void GLClientState::deleteTextures(GLsizei n, const GLuint* textures) 503 { 504 // Updating the textures array could be made more efficient when deleting 505 // several textures: 506 // - compacting the array could be done in a single pass once the deleted 507 // textures are marked, or 508 // - could swap deleted textures to the end and re-sort. 509 TextureRec* texrec; 510 for (const GLuint* texture = textures; texture != textures + n; texture++) { 511 texrec = (TextureRec*)bsearch(texture, m_tex.textures, 512 m_tex.numTextures, sizeof(TextureRec), compareTexId); 513 if (texrec) { 514 const TextureRec* end = m_tex.textures + m_tex.numTextures; 515 memmove(texrec, texrec + 1, 516 (end - texrec - 1) * sizeof(TextureRec)); 517 m_tex.numTextures--; 518 519 for (TextureUnit* unit = m_tex.unit; 520 unit != m_tex.unit + MAX_TEXTURE_UNITS; 521 unit++) 522 { 523 if (unit->texture[TEXTURE_2D] == *texture) { 524 unit->texture[TEXTURE_2D] = 0; 525 } else if (unit->texture[TEXTURE_EXTERNAL] == *texture) { 526 unit->texture[TEXTURE_EXTERNAL] = 0; 527 } 528 } 529 } 530 } 531 } 532 533 // RBO////////////////////////////////////////////////////////////////////////// 534 535 void GLClientState::addFreshRenderbuffer(GLuint name) { 536 mRboState.rboData.push_back(RboProps()); 537 RboProps& props = mRboState.rboData.back(); 538 props.target = GL_RENDERBUFFER; 539 props.name = name; 540 props.format = GL_NONE; 541 props.previouslyBound = false; 542 } 543 544 void GLClientState::addRenderbuffers(GLsizei n, GLuint* renderbuffers) { 545 for (size_t i = 0; i < n; i++) { 546 addFreshRenderbuffer(renderbuffers[i]); 547 } 548 } 549 550 size_t GLClientState::getRboIndex(GLuint name) const { 551 for (size_t i = 0; i < mRboState.rboData.size(); i++) { 552 if (mRboState.rboData[i].name == name) { 553 return i; 554 } 555 } 556 return -1; 557 } 558 559 void GLClientState::removeRenderbuffers(GLsizei n, const GLuint* renderbuffers) { 560 size_t bound_rbo_idx = getRboIndex(boundRboProps_const().name); 561 562 std::vector<GLuint> to_remove; 563 for (size_t i = 0; i < n; i++) { 564 if (renderbuffers[i] != 0) { // Never remove the zero rb. 565 to_remove.push_back(getRboIndex(renderbuffers[i])); 566 } 567 } 568 569 for (size_t i = 0; i < to_remove.size(); i++) { 570 mRboState.rboData[to_remove[i]] = mRboState.rboData.back(); 571 mRboState.rboData.pop_back(); 572 } 573 574 // If we just deleted the currently bound rb, 575 // bind the zero rb 576 if (getRboIndex(boundRboProps_const().name) != bound_rbo_idx) { 577 bindRenderbuffer(GL_RENDERBUFFER, 0); 578 } 579 } 580 581 bool GLClientState::usedRenderbufferName(GLuint name) const { 582 for (size_t i = 0; i < mRboState.rboData.size(); i++) { 583 if (mRboState.rboData[i].name == name) { 584 return true; 585 } 586 } 587 return false; 588 } 589 590 void GLClientState::setBoundRenderbufferIndex() { 591 for (size_t i = 0; i < mRboState.rboData.size(); i++) { 592 if (mRboState.rboData[i].name == mRboState.boundRenderbuffer) { 593 mRboState.boundRenderbufferIndex = i; 594 break; 595 } 596 } 597 } 598 599 RboProps& GLClientState::boundRboProps() { 600 return mRboState.rboData[mRboState.boundRenderbufferIndex]; 601 } 602 603 const RboProps& GLClientState::boundRboProps_const() const { 604 return mRboState.rboData[mRboState.boundRenderbufferIndex]; 605 } 606 607 void GLClientState::bindRenderbuffer(GLenum target, GLuint name) { 608 // If unused, add it. 609 if (!usedRenderbufferName(name)) { 610 addFreshRenderbuffer(name); 611 } 612 mRboState.boundRenderbuffer = name; 613 setBoundRenderbufferIndex(); 614 boundRboProps().target = target; 615 boundRboProps().previouslyBound = true; 616 } 617 618 GLuint GLClientState::boundRenderbuffer() const { 619 return boundRboProps_const().name; 620 } 621 622 void GLClientState::setBoundRenderbufferFormat(GLenum format) { 623 boundRboProps().format = format; 624 } 625 626 // FBO////////////////////////////////////////////////////////////////////////// 627 628 // Format querying 629 630 GLenum GLClientState::queryRboFormat(GLuint rbo_name) const { 631 return mRboState.rboData[getRboIndex(rbo_name)].format; 632 } 633 634 GLint GLClientState::queryTexInternalFormat(GLuint tex_name) const { 635 TextureRec* texrec = NULL; 636 texrec = (TextureRec*)bsearch(&tex_name, m_tex.textures, 637 m_tex.numTextures, sizeof(TextureRec), compareTexId); 638 if (!texrec) return -1; 639 return texrec->internalformat; 640 } 641 642 GLenum GLClientState::queryTexFormat(GLuint tex_name) const { 643 TextureRec* texrec = NULL; 644 texrec = (TextureRec*)bsearch(&tex_name, m_tex.textures, 645 m_tex.numTextures, sizeof(TextureRec), compareTexId); 646 if (!texrec) return -1; 647 return texrec->format; 648 } 649 650 GLenum GLClientState::queryTexType(GLuint tex_name) const { 651 TextureRec* texrec = NULL; 652 texrec = (TextureRec*)bsearch(&tex_name, m_tex.textures, 653 m_tex.numTextures, sizeof(TextureRec), compareTexId); 654 if (!texrec) return -1; 655 return texrec->type; 656 } 657 658 void GLClientState::getBoundFramebufferFormat( 659 GLenum attachment, FboFormatInfo* res_info) const { 660 const FboProps& props = boundFboProps_const(); 661 662 res_info->type = FBO_ATTACHMENT_NONE; 663 res_info->rb_format = GL_NONE; 664 res_info->tex_internalformat = -1; 665 res_info->tex_format = GL_NONE; 666 res_info->tex_type = GL_NONE; 667 668 switch (attachment) { 669 case GL_COLOR_ATTACHMENT0: 670 if (props.colorAttachment0_hasRbo) { 671 res_info->type = FBO_ATTACHMENT_RENDERBUFFER; 672 res_info->rb_format = queryRboFormat(props.colorAttachment0_rbo); 673 } else if (props.colorAttachment0_hasTexObj) { 674 res_info->type = FBO_ATTACHMENT_TEXTURE; 675 res_info->tex_internalformat = queryTexInternalFormat(props.colorAttachment0_texture); 676 res_info->tex_format = queryTexFormat(props.colorAttachment0_texture); 677 res_info->tex_type = queryTexType(props.colorAttachment0_texture); 678 } else { 679 res_info->type = FBO_ATTACHMENT_NONE; 680 } 681 break; 682 case GL_DEPTH_ATTACHMENT: 683 if (props.depthAttachment_hasRbo) { 684 res_info->type = FBO_ATTACHMENT_RENDERBUFFER; 685 res_info->rb_format = queryRboFormat(props.depthAttachment_rbo); 686 } else if (props.depthAttachment_hasTexObj) { 687 res_info->type = FBO_ATTACHMENT_TEXTURE; 688 res_info->tex_internalformat = queryTexInternalFormat(props.depthAttachment_texture); 689 res_info->tex_format = queryTexFormat(props.depthAttachment_texture); 690 res_info->tex_type = queryTexType(props.depthAttachment_texture); 691 } else { 692 res_info->type = FBO_ATTACHMENT_NONE; 693 } 694 break; 695 case GL_STENCIL_ATTACHMENT: 696 if (props.stencilAttachment_hasRbo) { 697 res_info->type = FBO_ATTACHMENT_RENDERBUFFER; 698 res_info->rb_format = queryRboFormat(props.stencilAttachment_rbo); 699 } else if (props.stencilAttachment_hasTexObj) { 700 res_info->type = FBO_ATTACHMENT_TEXTURE; 701 res_info->tex_internalformat = queryTexInternalFormat(props.stencilAttachment_texture); 702 res_info->tex_format = queryTexFormat(props.stencilAttachment_texture); 703 res_info->tex_type = queryTexType(props.stencilAttachment_texture); 704 } else { 705 res_info->type = FBO_ATTACHMENT_NONE; 706 } 707 break; 708 default: 709 res_info->type = FBO_ATTACHMENT_NONE; 710 break; 711 } 712 } 713 714 void GLClientState::addFreshFramebuffer(GLuint name) { 715 mFboState.fboData.push_back(FboProps()); 716 FboProps& props = mFboState.fboData.back(); 717 props.target = GL_FRAMEBUFFER; 718 props.name = name; 719 props.previouslyBound = false; 720 721 props.colorAttachment0_texture = 0; 722 props.depthAttachment_texture = 0; 723 props.stencilAttachment_texture = 0; 724 725 props.colorAttachment0_hasTexObj = false; 726 props.depthAttachment_hasTexObj = false; 727 props.stencilAttachment_hasTexObj = false; 728 729 props.colorAttachment0_rbo = 0; 730 props.depthAttachment_rbo = 0; 731 props.stencilAttachment_rbo = 0; 732 733 props.colorAttachment0_hasRbo = false; 734 props.depthAttachment_hasRbo = false; 735 props.stencilAttachment_hasRbo = false; 736 } 737 738 void GLClientState::addFramebuffers(GLsizei n, GLuint* framebuffers) { 739 for (size_t i = 0; i < n; i++) { 740 addFreshFramebuffer(framebuffers[i]); 741 } 742 } 743 744 size_t GLClientState::getFboIndex(GLuint name) const { 745 for (size_t i = 0; i < mFboState.fboData.size(); i++) { 746 if (mFboState.fboData[i].name == name) { 747 return i; 748 } 749 } 750 return -1; 751 } 752 753 754 void GLClientState::removeFramebuffers(GLsizei n, const GLuint* framebuffers) { 755 size_t bound_fbo_idx = getFboIndex(boundFboProps_const().name); 756 757 std::vector<GLuint> to_remove; 758 for (size_t i = 0; i < n; i++) { 759 if (framebuffers[i] != 0) { // Never remove the zero fb. 760 to_remove.push_back(getFboIndex(framebuffers[i])); 761 } 762 } 763 764 for (size_t i = 0; i < to_remove.size(); i++) { 765 mFboState.fboData[to_remove[i]] = mFboState.fboData.back(); 766 mFboState.fboData.pop_back(); 767 } 768 769 // If we just deleted the currently bound fb< 770 // bind the zero fb 771 if (getFboIndex(boundFboProps_const().name) != bound_fbo_idx) { 772 bindFramebuffer(GL_FRAMEBUFFER, 0); 773 } 774 } 775 776 bool GLClientState::usedFramebufferName(GLuint name) const { 777 for (size_t i = 0; i < mFboState.fboData.size(); i++) { 778 if (mFboState.fboData[i].name == name) { 779 return true; 780 } 781 } 782 return false; 783 } 784 785 void GLClientState::setBoundFramebufferIndex() { 786 for (size_t i = 0; i < mFboState.fboData.size(); i++) { 787 if (mFboState.fboData[i].name == mFboState.boundFramebuffer) { 788 mFboState.boundFramebufferIndex = i; 789 break; 790 } 791 } 792 } 793 794 FboProps& GLClientState::boundFboProps() { 795 return mFboState.fboData[mFboState.boundFramebufferIndex]; 796 } 797 798 const FboProps& GLClientState::boundFboProps_const() const { 799 return mFboState.fboData[mFboState.boundFramebufferIndex]; 800 } 801 802 void GLClientState::bindFramebuffer(GLenum target, GLuint name) { 803 // If unused, add it. 804 if (!usedFramebufferName(name)) { 805 addFreshFramebuffer(name); 806 } 807 mFboState.boundFramebuffer = name; 808 setBoundFramebufferIndex(); 809 boundFboProps().target = target; 810 boundFboProps().previouslyBound = true; 811 } 812 813 void GLClientState::setCheckFramebufferStatus(GLenum status) { 814 mFboState.fboCheckStatus = status; 815 } 816 817 GLenum GLClientState::getCheckFramebufferStatus() const { 818 return mFboState.fboCheckStatus; 819 } 820 821 GLuint GLClientState::boundFramebuffer() const { 822 return boundFboProps_const().name; 823 } 824 825 // Texture objects for FBOs///////////////////////////////////////////////////// 826 827 void GLClientState::attachTextureObject(GLenum attachment, GLuint texture) { 828 switch (attachment) { 829 case GL_COLOR_ATTACHMENT0: 830 boundFboProps().colorAttachment0_texture = texture; 831 boundFboProps().colorAttachment0_hasTexObj = true; 832 break; 833 case GL_DEPTH_ATTACHMENT: 834 boundFboProps().depthAttachment_texture = texture; 835 boundFboProps().depthAttachment_hasTexObj = true; 836 break; 837 case GL_STENCIL_ATTACHMENT: 838 boundFboProps().stencilAttachment_texture = texture; 839 boundFboProps().stencilAttachment_hasTexObj = true; 840 break; 841 default: 842 break; 843 } 844 } 845 846 GLuint GLClientState::getFboAttachmentTextureId(GLenum attachment) const { 847 GLuint res; 848 switch (attachment) { 849 case GL_COLOR_ATTACHMENT0: 850 res = boundFboProps_const().colorAttachment0_texture; 851 break; 852 case GL_DEPTH_ATTACHMENT: 853 res = boundFboProps_const().depthAttachment_texture; 854 break; 855 case GL_STENCIL_ATTACHMENT: 856 res = boundFboProps_const().stencilAttachment_texture; 857 break; 858 default: 859 res = 0; // conservative validation for now 860 } 861 return res; 862 } 863 864 // RBOs for FBOs//////////////////////////////////////////////////////////////// 865 866 void GLClientState::attachRbo(GLenum attachment, GLuint renderbuffer) { 867 switch (attachment) { 868 case GL_COLOR_ATTACHMENT0: 869 boundFboProps().colorAttachment0_rbo = renderbuffer; 870 boundFboProps().colorAttachment0_hasRbo = true; 871 break; 872 case GL_DEPTH_ATTACHMENT: 873 boundFboProps().depthAttachment_rbo = renderbuffer; 874 boundFboProps().depthAttachment_hasRbo = true; 875 break; 876 case GL_STENCIL_ATTACHMENT: 877 boundFboProps().stencilAttachment_rbo = renderbuffer; 878 boundFboProps().stencilAttachment_hasRbo = true; 879 break; 880 default: 881 break; 882 } 883 } 884 885 GLuint GLClientState::getFboAttachmentRboId(GLenum attachment) const { 886 GLuint res; 887 switch (attachment) { 888 case GL_COLOR_ATTACHMENT0: 889 res = boundFboProps_const().colorAttachment0_rbo; 890 break; 891 case GL_DEPTH_ATTACHMENT: 892 res = boundFboProps_const().depthAttachment_rbo; 893 break; 894 case GL_STENCIL_ATTACHMENT: 895 res = boundFboProps_const().stencilAttachment_rbo; 896 break; 897 default: 898 res = 0; // conservative validation for now 899 } 900 return res; 901 } 902 903 bool GLClientState::attachmentHasObject(GLenum attachment) const { 904 bool res; 905 switch (attachment) { 906 case GL_COLOR_ATTACHMENT0: 907 res = (boundFboProps_const().colorAttachment0_hasTexObj) || 908 (boundFboProps_const().colorAttachment0_hasRbo); 909 break; 910 case GL_DEPTH_ATTACHMENT: 911 res = (boundFboProps_const().depthAttachment_hasTexObj) || 912 (boundFboProps_const().depthAttachment_hasRbo); 913 break; 914 case GL_STENCIL_ATTACHMENT: 915 res = (boundFboProps_const().stencilAttachment_hasTexObj) || 916 (boundFboProps_const().stencilAttachment_hasRbo); 917 break; 918 default: 919 res = true; // liberal validation for now 920 } 921 return res; 922 } 923 924 void GLClientState::fromMakeCurrent() { 925 FboProps& default_fb_props = mFboState.fboData[getFboIndex(0)]; 926 default_fb_props.colorAttachment0_hasRbo = true; 927 default_fb_props.depthAttachment_hasRbo = true; 928 default_fb_props.stencilAttachment_hasRbo = true; 929 } 930
