/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "GLClientState.h"
#include "ErrorLog.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "glUtils.h"
#include <cutils/log.h>
#ifndef MAX
#define MAX(a, b) ((a) < (b) ? (b) : (a))
#endif
GLClientState::GLClientState(int nLocations)
{
if (nLocations < LAST_LOCATION) {
nLocations = LAST_LOCATION;
}
m_nLocations = nLocations;
m_states = new VertexAttribState[m_nLocations];
for (int i = 0; i < m_nLocations; i++) {
m_states[i].enabled = 0;
m_states[i].enableDirty = false;
m_states[i].data = 0;
}
m_currentArrayVbo = 0;
m_currentIndexVbo = 0;
// init gl constans;
m_states[VERTEX_LOCATION].glConst = GL_VERTEX_ARRAY;
m_states[NORMAL_LOCATION].glConst = GL_NORMAL_ARRAY;
m_states[COLOR_LOCATION].glConst = GL_COLOR_ARRAY;
m_states[POINTSIZE_LOCATION].glConst = GL_POINT_SIZE_ARRAY_OES;
m_states[TEXCOORD0_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
m_states[TEXCOORD1_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
m_states[TEXCOORD2_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
m_states[TEXCOORD3_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
m_states[TEXCOORD4_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
m_states[TEXCOORD5_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
m_states[TEXCOORD6_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
m_states[TEXCOORD7_LOCATION].glConst = GL_TEXTURE_COORD_ARRAY;
m_states[MATRIXINDEX_LOCATION].glConst = GL_MATRIX_INDEX_ARRAY_OES;
m_states[WEIGHT_LOCATION].glConst = GL_WEIGHT_ARRAY_OES;
m_activeTexture = 0;
m_currentProgram = 0;
m_pixelStore.unpack_alignment = 4;
m_pixelStore.pack_alignment = 4;
memset(m_tex.unit, 0, sizeof(m_tex.unit));
m_tex.activeUnit = &m_tex.unit[0];
m_tex.textures = NULL;
m_tex.numTextures = 0;
m_tex.allocTextures = 0;
mRboState.boundRenderbuffer = 0;
mRboState.boundRenderbufferIndex = 0;
addFreshRenderbuffer(0);
mFboState.boundFramebuffer = 0;
mFboState.boundFramebufferIndex = 0;
mFboState.fboCheckStatus = GL_NONE;
addFreshFramebuffer(0);
m_maxVertexAttribsDirty = true;
}
GLClientState::~GLClientState()
{
delete m_states;
}
void GLClientState::enable(int location, int state)
{
if (!validLocation(location)) {
return;
}
m_states[location].enableDirty |= (state != m_states[location].enabled);
m_states[location].enabled = state;
}
void GLClientState::setState(int location, int size, GLenum type, GLboolean normalized, GLsizei stride, const void *data)
{
if (!validLocation(location)) {
return;
}
m_states[location].size = size;
m_states[location].type = type;
m_states[location].stride = stride;
m_states[location].data = (void*)data;
m_states[location].bufferObject = m_currentArrayVbo;
m_states[location].elementSize = size ? (glSizeof(type) * size) : 0;
m_states[location].normalized = normalized;
}
void GLClientState::setBufferObject(int location, GLuint id)
{
if (!validLocation(location)) {
return;
}
m_states[location].bufferObject = id;
}
const GLClientState::VertexAttribState * GLClientState::getState(int location)
{
if (!validLocation(location)) {
return NULL;
}
return & m_states[location];
}
const GLClientState::VertexAttribState * GLClientState::getStateAndEnableDirty(int location, bool *enableChanged)
{
if (!validLocation(location)) {
return NULL;
}
if (enableChanged) {
*enableChanged = m_states[location].enableDirty;
}
m_states[location].enableDirty = false;
return & m_states[location];
}
int GLClientState::getLocation(GLenum loc)
{
int retval;
switch(loc) {
case GL_VERTEX_ARRAY:
retval = int(VERTEX_LOCATION);
break;
case GL_NORMAL_ARRAY:
retval = int(NORMAL_LOCATION);
break;
case GL_COLOR_ARRAY:
retval = int(COLOR_LOCATION);
break;
case GL_POINT_SIZE_ARRAY_OES:
retval = int(POINTSIZE_LOCATION);
break;
case GL_TEXTURE_COORD_ARRAY:
retval = int (TEXCOORD0_LOCATION + m_activeTexture);
break;
case GL_MATRIX_INDEX_ARRAY_OES:
retval = int (MATRIXINDEX_LOCATION);
break;
case GL_WEIGHT_ARRAY_OES:
retval = int (WEIGHT_LOCATION);
break;
default:
retval = loc;
}
return retval;
}
void GLClientState::getClientStatePointer(GLenum pname, GLvoid** params)
{
const GLClientState::VertexAttribState *state = NULL;
switch (pname) {
case GL_VERTEX_ARRAY_POINTER: {
state = getState(GLClientState::VERTEX_LOCATION);
break;
}
case GL_NORMAL_ARRAY_POINTER: {
state = getState(GLClientState::NORMAL_LOCATION);
break;
}
case GL_COLOR_ARRAY_POINTER: {
state = getState(GLClientState::COLOR_LOCATION);
break;
}
case GL_TEXTURE_COORD_ARRAY_POINTER: {
state = getState(getActiveTexture() + GLClientState::TEXCOORD0_LOCATION);
break;
}
case GL_POINT_SIZE_ARRAY_POINTER_OES: {
state = getState(GLClientState::POINTSIZE_LOCATION);
break;
}
case GL_MATRIX_INDEX_ARRAY_POINTER_OES: {
state = getState(GLClientState::MATRIXINDEX_LOCATION);
break;
}
case GL_WEIGHT_ARRAY_POINTER_OES: {
state = getState(GLClientState::WEIGHT_LOCATION);
break;
}
}
if (state && params)
*params = state->data;
}
int GLClientState::setPixelStore(GLenum param, GLint value)
{
int retval = 0;
switch(param) {
case GL_UNPACK_ALIGNMENT:
if (value == 1 || value == 2 || value == 4 || value == 8) {
m_pixelStore.unpack_alignment = value;
} else {
retval = GL_INVALID_VALUE;
}
break;
case GL_PACK_ALIGNMENT:
if (value == 1 || value == 2 || value == 4 || value == 8) {
m_pixelStore.pack_alignment = value;
} else {
retval = GL_INVALID_VALUE;
}
break;
default:
retval = GL_INVALID_ENUM;
}
return retval;
}
size_t GLClientState::pixelDataSize(GLsizei width, GLsizei height, GLenum format, GLenum type, int pack) const
{
if (width <= 0 || height <= 0) return 0;
int pixelsize = glUtilsPixelBitSize(format, type) >> 3;
int alignment = pack ? m_pixelStore.pack_alignment : m_pixelStore.unpack_alignment;
if (pixelsize == 0 ) {
ERR("unknown pixel size: width: %d height: %d format: %d type: %d pack: %d align: %d\n",
width, height, format, type, pack, alignment);
}
size_t linesize = pixelsize * width;
size_t aligned_linesize = int(linesize / alignment) * alignment;
if (aligned_linesize < linesize) {
aligned_linesize += alignment;
}
return aligned_linesize * height;
}
GLenum GLClientState::setActiveTextureUnit(GLenum texture)
{
GLuint unit = texture - GL_TEXTURE0;
if (unit >= MAX_TEXTURE_UNITS) {
return GL_INVALID_ENUM;
}
m_tex.activeUnit = &m_tex.unit[unit];
return GL_NO_ERROR;
}
GLenum GLClientState::getActiveTextureUnit() const
{
return GL_TEXTURE0 + (m_tex.activeUnit - &m_tex.unit[0]);
}
void GLClientState::enableTextureTarget(GLenum target)
{
switch (target) {
case GL_TEXTURE_2D:
m_tex.activeUnit->enables |= (1u << TEXTURE_2D);
break;
case GL_TEXTURE_EXTERNAL_OES:
m_tex.activeUnit->enables |= (1u << TEXTURE_EXTERNAL);
break;
}
}
void GLClientState::disableTextureTarget(GLenum target)
{
switch (target) {
case GL_TEXTURE_2D:
m_tex.activeUnit->enables &= ~(1u << TEXTURE_2D);
break;
case GL_TEXTURE_EXTERNAL_OES:
m_tex.activeUnit->enables &= ~(1u << TEXTURE_EXTERNAL);
break;
}
}
GLenum GLClientState::getPriorityEnabledTarget(GLenum allDisabled) const
{
unsigned int enables = m_tex.activeUnit->enables;
if (enables & (1u << TEXTURE_EXTERNAL)) {
return GL_TEXTURE_EXTERNAL_OES;
} else if (enables & (1u << TEXTURE_2D)) {
return GL_TEXTURE_2D;
} else {
return allDisabled;
}
}
int GLClientState::compareTexId(const void* pid, const void* prec)
{
const GLuint* id = (const GLuint*)pid;
const TextureRec* rec = (const TextureRec*)prec;
return (GLint)(*id) - (GLint)rec->id;
}
GLenum GLClientState::bindTexture(GLenum target, GLuint texture,
GLboolean* firstUse)
{
GLboolean first = GL_FALSE;
TextureRec* texrec = NULL;
if (texture != 0) {
if (m_tex.textures) {
texrec = (TextureRec*)bsearch(&texture, m_tex.textures,
m_tex.numTextures, sizeof(TextureRec), compareTexId);
}
if (!texrec) {
if (!(texrec = addTextureRec(texture, target))) {
return GL_OUT_OF_MEMORY;
}
first = GL_TRUE;
}
if (target != texrec->target) {
return GL_INVALID_OPERATION;
}
}
switch (target) {
case GL_TEXTURE_2D:
m_tex.activeUnit->texture[TEXTURE_2D] = texture;
break;
case GL_TEXTURE_EXTERNAL_OES:
m_tex.activeUnit->texture[TEXTURE_EXTERNAL] = texture;
break;
}
if (firstUse) {
*firstUse = first;
}
return GL_NO_ERROR;
}
GLClientState::TextureRec* GLClientState::addTextureRec(GLuint id,
GLenum target)
{
if (m_tex.numTextures == m_tex.allocTextures) {
const GLuint MAX_TEXTURES = 0xFFFFFFFFu;
GLuint newAlloc;
if (MAX_TEXTURES - m_tex.allocTextures >= m_tex.allocTextures) {
newAlloc = MAX(4, 2 * m_tex.allocTextures);
} else {
if (m_tex.allocTextures == MAX_TEXTURES) {
return NULL;
}
newAlloc = MAX_TEXTURES;
}
TextureRec* newTextures = (TextureRec*)realloc(m_tex.textures,
newAlloc * sizeof(TextureRec));
if (!newTextures) {
return NULL;
}
m_tex.textures = newTextures;
m_tex.allocTextures = newAlloc;
}
TextureRec* tex = m_tex.textures + m_tex.numTextures;
TextureRec* prev = tex - 1;
while (tex != m_tex.textures && id < prev->id) {
*tex-- = *prev--;
}
tex->id = id;
tex->target = target;
tex->format = -1;
m_tex.numTextures++;
return tex;
}
void GLClientState::setBoundTextureInternalFormat(GLenum target, GLint internalformat) {
GLuint texture = getBoundTexture(target);
TextureRec* texrec = NULL;
texrec = (TextureRec*)bsearch(&texture, m_tex.textures,
m_tex.numTextures,
sizeof(TextureRec),
compareTexId);
if (!texrec) return;
texrec->internalformat = internalformat;
}
void GLClientState::setBoundTextureFormat(GLenum target, GLenum format) {
GLuint texture = getBoundTexture(target);
TextureRec* texrec = NULL;
texrec = (TextureRec*)bsearch(&texture, m_tex.textures,
m_tex.numTextures,
sizeof(TextureRec),
compareTexId);
if (!texrec) return;
texrec->format = format;
}
void GLClientState::setBoundTextureType(GLenum target, GLenum type) {
GLuint texture = getBoundTexture(target);
TextureRec* texrec = NULL;
texrec = (TextureRec*)bsearch(&texture, m_tex.textures,
m_tex.numTextures,
sizeof(TextureRec),
compareTexId);
if (!texrec) return;
texrec->type = type;
}
GLuint GLClientState::getBoundTexture(GLenum target) const
{
switch (target) {
case GL_TEXTURE_2D:
return m_tex.activeUnit->texture[TEXTURE_2D];
case GL_TEXTURE_EXTERNAL_OES:
return m_tex.activeUnit->texture[TEXTURE_EXTERNAL];
default:
return 0;
}
}
// BEGIN driver workarounds-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
// (>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')>
static bool unreliableInternalFormat(GLenum internalformat) {
switch (internalformat) {
case GL_LUMINANCE:
return true;
default:
return false;
}
}
void GLClientState::writeCopyTexImageState
(GLenum target, GLint level, GLenum internalformat) {
if (unreliableInternalFormat(internalformat)) {
CubeMapDef entry;
entry.id = getBoundTexture(GL_TEXTURE_2D);
entry.target = target;
entry.level = level;
entry.internalformat = internalformat;
m_cubeMapDefs.insert(entry);
}
}
static GLenum identifyPositiveCubeMapComponent(GLenum target) {
switch (target) {
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
return GL_TEXTURE_CUBE_MAP_POSITIVE_X;
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
return GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
default:
return 0;
}
}
GLenum GLClientState::copyTexImageNeededTarget
(GLenum target, GLint level, GLenum internalformat) {
if (unreliableInternalFormat(internalformat)) {
GLenum positiveComponent =
identifyPositiveCubeMapComponent(target);
if (positiveComponent) {
CubeMapDef query;
query.id = getBoundTexture(GL_TEXTURE_2D);
query.target = positiveComponent;
query.level = level;
query.internalformat = internalformat;
if (m_cubeMapDefs.find(query) ==
m_cubeMapDefs.end()) {
return positiveComponent;
}
}
}
return 0;
}
GLenum GLClientState::copyTexImageLuminanceCubeMapAMDWorkaround
(GLenum target, GLint level, GLenum internalformat) {
writeCopyTexImageState(target, level, internalformat);
return copyTexImageNeededTarget(target, level, internalformat);
}
// (>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')><(' '<)(>' ')>
// END driver workarounds-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
void GLClientState::deleteTextures(GLsizei n, const GLuint* textures)
{
// Updating the textures array could be made more efficient when deleting
// several textures:
// - compacting the array could be done in a single pass once the deleted
// textures are marked, or
// - could swap deleted textures to the end and re-sort.
TextureRec* texrec;
for (const GLuint* texture = textures; texture != textures + n; texture++) {
texrec = (TextureRec*)bsearch(texture, m_tex.textures,
m_tex.numTextures, sizeof(TextureRec), compareTexId);
if (texrec) {
const TextureRec* end = m_tex.textures + m_tex.numTextures;
memmove(texrec, texrec + 1,
(end - texrec - 1) * sizeof(TextureRec));
m_tex.numTextures--;
for (TextureUnit* unit = m_tex.unit;
unit != m_tex.unit + MAX_TEXTURE_UNITS;
unit++)
{
if (unit->texture[TEXTURE_2D] == *texture) {
unit->texture[TEXTURE_2D] = 0;
} else if (unit->texture[TEXTURE_EXTERNAL] == *texture) {
unit->texture[TEXTURE_EXTERNAL] = 0;
}
}
}
}
}
// RBO//////////////////////////////////////////////////////////////////////////
void GLClientState::addFreshRenderbuffer(GLuint name) {
mRboState.rboData.push_back(RboProps());
RboProps& props = mRboState.rboData.back();
props.target = GL_RENDERBUFFER;
props.name = name;
props.format = GL_NONE;
props.previouslyBound = false;
}
void GLClientState::addRenderbuffers(GLsizei n, GLuint* renderbuffers) {
for (size_t i = 0; i < n; i++) {
addFreshRenderbuffer(renderbuffers[i]);
}
}
size_t GLClientState::getRboIndex(GLuint name) const {
for (size_t i = 0; i < mRboState.rboData.size(); i++) {
if (mRboState.rboData[i].name == name) {
return i;
}
}
return -1;
}
void GLClientState::removeRenderbuffers(GLsizei n, const GLuint* renderbuffers) {
size_t bound_rbo_idx = getRboIndex(boundRboProps_const().name);
std::vector<GLuint> to_remove;
for (size_t i = 0; i < n; i++) {
if (renderbuffers[i] != 0) { // Never remove the zero rb.
to_remove.push_back(getRboIndex(renderbuffers[i]));
}
}
for (size_t i = 0; i < to_remove.size(); i++) {
mRboState.rboData[to_remove[i]] = mRboState.rboData.back();
mRboState.rboData.pop_back();
}
// If we just deleted the currently bound rb,
// bind the zero rb
if (getRboIndex(boundRboProps_const().name) != bound_rbo_idx) {
bindRenderbuffer(GL_RENDERBUFFER, 0);
}
}
bool GLClientState::usedRenderbufferName(GLuint name) const {
for (size_t i = 0; i < mRboState.rboData.size(); i++) {
if (mRboState.rboData[i].name == name) {
return true;
}
}
return false;
}
void GLClientState::setBoundRenderbufferIndex() {
for (size_t i = 0; i < mRboState.rboData.size(); i++) {
if (mRboState.rboData[i].name == mRboState.boundRenderbuffer) {
mRboState.boundRenderbufferIndex = i;
break;
}
}
}
RboProps& GLClientState::boundRboProps() {
return mRboState.rboData[mRboState.boundRenderbufferIndex];
}
const RboProps& GLClientState::boundRboProps_const() const {
return mRboState.rboData[mRboState.boundRenderbufferIndex];
}
void GLClientState::bindRenderbuffer(GLenum target, GLuint name) {
// If unused, add it.
if (!usedRenderbufferName(name)) {
addFreshRenderbuffer(name);
}
mRboState.boundRenderbuffer = name;
setBoundRenderbufferIndex();
boundRboProps().target = target;
boundRboProps().previouslyBound = true;
}
GLuint GLClientState::boundRenderbuffer() const {
return boundRboProps_const().name;
}
void GLClientState::setBoundRenderbufferFormat(GLenum format) {
boundRboProps().format = format;
}
// FBO//////////////////////////////////////////////////////////////////////////
// Format querying
GLenum GLClientState::queryRboFormat(GLuint rbo_name) const {
return mRboState.rboData[getRboIndex(rbo_name)].format;
}
GLint GLClientState::queryTexInternalFormat(GLuint tex_name) const {
TextureRec* texrec = NULL;
texrec = (TextureRec*)bsearch(&tex_name, m_tex.textures,
m_tex.numTextures, sizeof(TextureRec), compareTexId);
if (!texrec) return -1;
return texrec->internalformat;
}
GLenum GLClientState::queryTexFormat(GLuint tex_name) const {
TextureRec* texrec = NULL;
texrec = (TextureRec*)bsearch(&tex_name, m_tex.textures,
m_tex.numTextures, sizeof(TextureRec), compareTexId);
if (!texrec) return -1;
return texrec->format;
}
GLenum GLClientState::queryTexType(GLuint tex_name) const {
TextureRec* texrec = NULL;
texrec = (TextureRec*)bsearch(&tex_name, m_tex.textures,
m_tex.numTextures, sizeof(TextureRec), compareTexId);
if (!texrec) return -1;
return texrec->type;
}
void GLClientState::getBoundFramebufferFormat(
GLenum attachment, FboFormatInfo* res_info) const {
const FboProps& props = boundFboProps_const();
res_info->type = FBO_ATTACHMENT_NONE;
res_info->rb_format = GL_NONE;
res_info->tex_internalformat = -1;
res_info->tex_format = GL_NONE;
res_info->tex_type = GL_NONE;
switch (attachment) {
case GL_COLOR_ATTACHMENT0:
if (props.colorAttachment0_hasRbo) {
res_info->type = FBO_ATTACHMENT_RENDERBUFFER;
res_info->rb_format = queryRboFormat(props.colorAttachment0_rbo);
} else if (props.colorAttachment0_hasTexObj) {
res_info->type = FBO_ATTACHMENT_TEXTURE;
res_info->tex_internalformat = queryTexInternalFormat(props.colorAttachment0_texture);
res_info->tex_format = queryTexFormat(props.colorAttachment0_texture);
res_info->tex_type = queryTexType(props.colorAttachment0_texture);
} else {
res_info->type = FBO_ATTACHMENT_NONE;
}
break;
case GL_DEPTH_ATTACHMENT:
if (props.depthAttachment_hasRbo) {
res_info->type = FBO_ATTACHMENT_RENDERBUFFER;
res_info->rb_format = queryRboFormat(props.depthAttachment_rbo);
} else if (props.depthAttachment_hasTexObj) {
res_info->type = FBO_ATTACHMENT_TEXTURE;
res_info->tex_internalformat = queryTexInternalFormat(props.depthAttachment_texture);
res_info->tex_format = queryTexFormat(props.depthAttachment_texture);
res_info->tex_type = queryTexType(props.depthAttachment_texture);
} else {
res_info->type = FBO_ATTACHMENT_NONE;
}
break;
case GL_STENCIL_ATTACHMENT:
if (props.stencilAttachment_hasRbo) {
res_info->type = FBO_ATTACHMENT_RENDERBUFFER;
res_info->rb_format = queryRboFormat(props.stencilAttachment_rbo);
} else if (props.stencilAttachment_hasTexObj) {
res_info->type = FBO_ATTACHMENT_TEXTURE;
res_info->tex_internalformat = queryTexInternalFormat(props.stencilAttachment_texture);
res_info->tex_format = queryTexFormat(props.stencilAttachment_texture);
res_info->tex_type = queryTexType(props.stencilAttachment_texture);
} else {
res_info->type = FBO_ATTACHMENT_NONE;
}
break;
default:
res_info->type = FBO_ATTACHMENT_NONE;
break;
}
}
void GLClientState::addFreshFramebuffer(GLuint name) {
mFboState.fboData.push_back(FboProps());
FboProps& props = mFboState.fboData.back();
props.target = GL_FRAMEBUFFER;
props.name = name;
props.previouslyBound = false;
props.colorAttachment0_texture = 0;
props.depthAttachment_texture = 0;
props.stencilAttachment_texture = 0;
props.colorAttachment0_hasTexObj = false;
props.depthAttachment_hasTexObj = false;
props.stencilAttachment_hasTexObj = false;
props.colorAttachment0_rbo = 0;
props.depthAttachment_rbo = 0;
props.stencilAttachment_rbo = 0;
props.colorAttachment0_hasRbo = false;
props.depthAttachment_hasRbo = false;
props.stencilAttachment_hasRbo = false;
}
void GLClientState::addFramebuffers(GLsizei n, GLuint* framebuffers) {
for (size_t i = 0; i < n; i++) {
addFreshFramebuffer(framebuffers[i]);
}
}
size_t GLClientState::getFboIndex(GLuint name) const {
for (size_t i = 0; i < mFboState.fboData.size(); i++) {
if (mFboState.fboData[i].name == name) {
return i;
}
}
return -1;
}
void GLClientState::removeFramebuffers(GLsizei n, const GLuint* framebuffers) {
size_t bound_fbo_idx = getFboIndex(boundFboProps_const().name);
std::vector<GLuint> to_remove;
for (size_t i = 0; i < n; i++) {
if (framebuffers[i] != 0) { // Never remove the zero fb.
to_remove.push_back(getFboIndex(framebuffers[i]));
}
}
for (size_t i = 0; i < to_remove.size(); i++) {
mFboState.fboData[to_remove[i]] = mFboState.fboData.back();
mFboState.fboData.pop_back();
}
// If we just deleted the currently bound fb<
// bind the zero fb
if (getFboIndex(boundFboProps_const().name) != bound_fbo_idx) {
bindFramebuffer(GL_FRAMEBUFFER, 0);
}
}
bool GLClientState::usedFramebufferName(GLuint name) const {
for (size_t i = 0; i < mFboState.fboData.size(); i++) {
if (mFboState.fboData[i].name == name) {
return true;
}
}
return false;
}
void GLClientState::setBoundFramebufferIndex() {
for (size_t i = 0; i < mFboState.fboData.size(); i++) {
if (mFboState.fboData[i].name == mFboState.boundFramebuffer) {
mFboState.boundFramebufferIndex = i;
break;
}
}
}
FboProps& GLClientState::boundFboProps() {
return mFboState.fboData[mFboState.boundFramebufferIndex];
}
const FboProps& GLClientState::boundFboProps_const() const {
return mFboState.fboData[mFboState.boundFramebufferIndex];
}
void GLClientState::bindFramebuffer(GLenum target, GLuint name) {
// If unused, add it.
if (!usedFramebufferName(name)) {
addFreshFramebuffer(name);
}
mFboState.boundFramebuffer = name;
setBoundFramebufferIndex();
boundFboProps().target = target;
boundFboProps().previouslyBound = true;
}
void GLClientState::setCheckFramebufferStatus(GLenum status) {
mFboState.fboCheckStatus = status;
}
GLenum GLClientState::getCheckFramebufferStatus() const {
return mFboState.fboCheckStatus;
}
GLuint GLClientState::boundFramebuffer() const {
return boundFboProps_const().name;
}
// Texture objects for FBOs/////////////////////////////////////////////////////
void GLClientState::attachTextureObject(GLenum attachment, GLuint texture) {
switch (attachment) {
case GL_COLOR_ATTACHMENT0:
boundFboProps().colorAttachment0_texture = texture;
boundFboProps().colorAttachment0_hasTexObj = true;
break;
case GL_DEPTH_ATTACHMENT:
boundFboProps().depthAttachment_texture = texture;
boundFboProps().depthAttachment_hasTexObj = true;
break;
case GL_STENCIL_ATTACHMENT:
boundFboProps().stencilAttachment_texture = texture;
boundFboProps().stencilAttachment_hasTexObj = true;
break;
default:
break;
}
}
GLuint GLClientState::getFboAttachmentTextureId(GLenum attachment) const {
GLuint res;
switch (attachment) {
case GL_COLOR_ATTACHMENT0:
res = boundFboProps_const().colorAttachment0_texture;
break;
case GL_DEPTH_ATTACHMENT:
res = boundFboProps_const().depthAttachment_texture;
break;
case GL_STENCIL_ATTACHMENT:
res = boundFboProps_const().stencilAttachment_texture;
break;
default:
res = 0; // conservative validation for now
}
return res;
}
// RBOs for FBOs////////////////////////////////////////////////////////////////
void GLClientState::attachRbo(GLenum attachment, GLuint renderbuffer) {
switch (attachment) {
case GL_COLOR_ATTACHMENT0:
boundFboProps().colorAttachment0_rbo = renderbuffer;
boundFboProps().colorAttachment0_hasRbo = true;
break;
case GL_DEPTH_ATTACHMENT:
boundFboProps().depthAttachment_rbo = renderbuffer;
boundFboProps().depthAttachment_hasRbo = true;
break;
case GL_STENCIL_ATTACHMENT:
boundFboProps().stencilAttachment_rbo = renderbuffer;
boundFboProps().stencilAttachment_hasRbo = true;
break;
default:
break;
}
}
GLuint GLClientState::getFboAttachmentRboId(GLenum attachment) const {
GLuint res;
switch (attachment) {
case GL_COLOR_ATTACHMENT0:
res = boundFboProps_const().colorAttachment0_rbo;
break;
case GL_DEPTH_ATTACHMENT:
res = boundFboProps_const().depthAttachment_rbo;
break;
case GL_STENCIL_ATTACHMENT:
res = boundFboProps_const().stencilAttachment_rbo;
break;
default:
res = 0; // conservative validation for now
}
return res;
}
bool GLClientState::attachmentHasObject(GLenum attachment) const {
bool res;
switch (attachment) {
case GL_COLOR_ATTACHMENT0:
res = (boundFboProps_const().colorAttachment0_hasTexObj) ||
(boundFboProps_const().colorAttachment0_hasRbo);
break;
case GL_DEPTH_ATTACHMENT:
res = (boundFboProps_const().depthAttachment_hasTexObj) ||
(boundFboProps_const().depthAttachment_hasRbo);
break;
case GL_STENCIL_ATTACHMENT:
res = (boundFboProps_const().stencilAttachment_hasTexObj) ||
(boundFboProps_const().stencilAttachment_hasRbo);
break;
default:
res = true; // liberal validation for now
}
return res;
}
void GLClientState::fromMakeCurrent() {
FboProps& default_fb_props = mFboState.fboData[getFboIndex(0)];
default_fb_props.colorAttachment0_hasRbo = true;
default_fb_props.depthAttachment_hasRbo = true;
default_fb_props.stencilAttachment_hasRbo = true;
}