/* * 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. */ #ifndef _GL_CLIENT_STATE_H_ #define _GL_CLIENT_STATE_H_ #define GL_API #ifndef ANDROID #define GL_APIENTRY #define GL_APIENTRYP #endif #include #include #include #include #include #include #include "ErrorLog.h" #include "codec_defs.h" class GLClientState { public: typedef enum { VERTEX_LOCATION = 0, NORMAL_LOCATION = 1, COLOR_LOCATION = 2, POINTSIZE_LOCATION = 3, TEXCOORD0_LOCATION = 4, TEXCOORD1_LOCATION = 5, TEXCOORD2_LOCATION = 6, TEXCOORD3_LOCATION = 7, TEXCOORD4_LOCATION = 8, TEXCOORD5_LOCATION = 9, TEXCOORD6_LOCATION = 10, TEXCOORD7_LOCATION = 11, MATRIXINDEX_LOCATION = 12, WEIGHT_LOCATION = 13, LAST_LOCATION = 14 } StateLocation; typedef struct { GLint enabled; GLint size; GLenum type; GLsizei stride; void *data; GLuint bufferObject; GLenum glConst; unsigned int elementSize; bool enableDirty; // true if any enable state has changed since last draw bool normalized; } VertexAttribState; typedef struct { int unpack_alignment; int pack_alignment; } PixelStoreState; enum { MAX_TEXTURE_UNITS = 32, }; public: GLClientState(int nLocations = CODEC_MAX_VERTEX_ATTRIBUTES); ~GLClientState(); int nLocations() { return m_nLocations; } const PixelStoreState *pixelStoreState() { return &m_pixelStore; } int setPixelStore(GLenum param, GLint value); GLuint currentArrayVbo() { return m_currentArrayVbo; } GLuint currentIndexVbo() { return m_currentIndexVbo; } void enable(int location, int state); void setState(int location, int size, GLenum type, GLboolean normalized, GLsizei stride, const void *data); void setBufferObject(int location, GLuint id); const VertexAttribState *getState(int location); const VertexAttribState *getStateAndEnableDirty(int location, bool *enableChanged); int getLocation(GLenum loc); void setActiveTexture(int texUnit) {m_activeTexture = texUnit; }; int getActiveTexture() const { return m_activeTexture; } void setMaxVertexAttribs(int val) { m_maxVertexAttribs = val; m_maxVertexAttribsDirty = false; } void unBindBuffer(GLuint id) { if (m_currentArrayVbo == id) m_currentArrayVbo = 0; else if (m_currentIndexVbo == id) m_currentIndexVbo = 0; } int bindBuffer(GLenum target, GLuint id) { int err = 0; switch(target) { case GL_ARRAY_BUFFER: m_currentArrayVbo = id; break; case GL_ELEMENT_ARRAY_BUFFER: m_currentIndexVbo = id; break; default: err = -1; } return err; } int getBuffer(GLenum target) { int ret=0; switch (target) { case GL_ARRAY_BUFFER: ret = m_currentArrayVbo; break; case GL_ELEMENT_ARRAY_BUFFER: ret = m_currentIndexVbo; break; default: ret = -1; } return ret; } size_t pixelDataSize(GLsizei width, GLsizei height, GLenum format, GLenum type, int pack) const; void setCurrentProgram(GLint program) { m_currentProgram = program; } GLint currentProgram() const { return m_currentProgram; } /* OES_EGL_image_external * * These functions manipulate GL state which interacts with the * OES_EGL_image_external extension, to support client-side emulation on * top of host implementations that don't have it. * * Most of these calls should only be used with TEXTURE_2D or * TEXTURE_EXTERNAL_OES texture targets; TEXTURE_CUBE_MAP or other extension * targets should bypass this. An exception is bindTexture(), which should * see all glBindTexture() calls for any target. */ // glActiveTexture(GL_TEXTURE0 + i) // Sets the active texture unit. Up to MAX_TEXTURE_UNITS are supported. GLenum setActiveTextureUnit(GLenum texture); GLenum getActiveTextureUnit() const; // glEnable(GL_TEXTURE_(2D|EXTERNAL_OES)) void enableTextureTarget(GLenum target); // glDisable(GL_TEXTURE_(2D|EXTERNAL_OES)) void disableTextureTarget(GLenum target); // Implements the target priority logic: // * Return GL_TEXTURE_EXTERNAL_OES if enabled, else // * Return GL_TEXTURE_2D if enabled, else // * Return the allDisabled value. // For some cases passing GL_TEXTURE_2D for allDisabled makes callee code // simpler; for other cases passing a recognizable enum like GL_ZERO or // GL_INVALID_ENUM is appropriate. GLenum getPriorityEnabledTarget(GLenum allDisabled) const; // glBindTexture(GL_TEXTURE_*, ...) // Set the target binding of the active texture unit to texture. Returns // GL_NO_ERROR on success or GL_INVALID_OPERATION if the texture has // previously been bound to a different target. If firstUse is not NULL, // it is set to indicate whether this is the first use of the texture. // For accurate error detection, bindTexture should be called for *all* // targets, not just 2D and EXTERNAL_OES. GLenum bindTexture(GLenum target, GLuint texture, GLboolean* firstUse); // Return the texture currently bound to GL_TEXTURE_(2D|EXTERNAL_OES). GLuint getBoundTexture(GLenum target) const; // glDeleteTextures(...) // Remove references to the to-be-deleted textures. void deleteTextures(GLsizei n, const GLuint* textures); private: PixelStoreState m_pixelStore; VertexAttribState *m_states; int m_maxVertexAttribs; bool m_maxVertexAttribsDirty; int m_nLocations; GLuint m_currentArrayVbo; GLuint m_currentIndexVbo; int m_activeTexture; GLint m_currentProgram; bool validLocation(int location) { return (location >= 0 && location < m_nLocations); } enum TextureTarget { TEXTURE_2D = 0, TEXTURE_EXTERNAL = 1, TEXTURE_TARGET_COUNT }; struct TextureUnit { unsigned int enables; GLuint texture[TEXTURE_TARGET_COUNT]; }; struct TextureRec { GLuint id; GLenum target; }; struct TextureState { TextureUnit unit[MAX_TEXTURE_UNITS]; TextureUnit* activeUnit; TextureRec* textures; GLuint numTextures; GLuint allocTextures; }; TextureState m_tex; static int compareTexId(const void* pid, const void* prec); TextureRec* addTextureRec(GLuint id, GLenum target); public: void getClientStatePointer(GLenum pname, GLvoid** params); template int getVertexAttribParameter(GLuint index, GLenum param, T *ptr) { bool handled = true; const VertexAttribState *vertexAttrib = getState(index); if (vertexAttrib == NULL) { ERR("getVeterxAttriParameter for non existant index %d\n", index); // set gl error; return handled; } switch(param) { case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: *ptr = (T)(vertexAttrib->bufferObject); break; case GL_VERTEX_ATTRIB_ARRAY_ENABLED: *ptr = (T)(vertexAttrib->enabled); break; case GL_VERTEX_ATTRIB_ARRAY_SIZE: *ptr = (T)(vertexAttrib->size); break; case GL_VERTEX_ATTRIB_ARRAY_STRIDE: *ptr = (T)(vertexAttrib->stride); break; case GL_VERTEX_ATTRIB_ARRAY_TYPE: *ptr = (T)(vertexAttrib->type); break; case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED: *ptr = (T)(vertexAttrib->normalized); break; case GL_CURRENT_VERTEX_ATTRIB: handled = false; break; default: handled = false; ERR("unknown vertex-attrib parameter param %d\n", param); } return handled; } template bool getClientStateParameter(GLenum param, T* ptr) { bool isClientStateParam = false; switch (param) { case GL_CLIENT_ACTIVE_TEXTURE: { GLint tex = getActiveTexture() + GL_TEXTURE0; *ptr = tex; isClientStateParam = true; break; } case GL_VERTEX_ARRAY_SIZE: { const GLClientState::VertexAttribState *state = getState(GLClientState::VERTEX_LOCATION); *ptr = state->size; isClientStateParam = true; break; } case GL_VERTEX_ARRAY_TYPE: { const GLClientState::VertexAttribState *state = getState(GLClientState::VERTEX_LOCATION); *ptr = state->type; isClientStateParam = true; break; } case GL_VERTEX_ARRAY_STRIDE: { const GLClientState::VertexAttribState *state = getState(GLClientState::VERTEX_LOCATION); *ptr = state->stride; isClientStateParam = true; break; } case GL_COLOR_ARRAY_SIZE: { const GLClientState::VertexAttribState *state = getState(GLClientState::COLOR_LOCATION); *ptr = state->size; isClientStateParam = true; break; } case GL_COLOR_ARRAY_TYPE: { const GLClientState::VertexAttribState *state = getState(GLClientState::COLOR_LOCATION); *ptr = state->type; isClientStateParam = true; break; } case GL_COLOR_ARRAY_STRIDE: { const GLClientState::VertexAttribState *state = getState(GLClientState::COLOR_LOCATION); *ptr = state->stride; isClientStateParam = true; break; } case GL_NORMAL_ARRAY_TYPE: { const GLClientState::VertexAttribState *state = getState(GLClientState::NORMAL_LOCATION); *ptr = state->type; isClientStateParam = true; break; } case GL_NORMAL_ARRAY_STRIDE: { const GLClientState::VertexAttribState *state = getState(GLClientState::NORMAL_LOCATION); *ptr = state->stride; isClientStateParam = true; break; } case GL_TEXTURE_COORD_ARRAY_SIZE: { const GLClientState::VertexAttribState *state = getState(getActiveTexture() + GLClientState::TEXCOORD0_LOCATION); *ptr = state->size; isClientStateParam = true; break; } case GL_TEXTURE_COORD_ARRAY_TYPE: { const GLClientState::VertexAttribState *state = getState(getActiveTexture() + GLClientState::TEXCOORD0_LOCATION); *ptr = state->type; isClientStateParam = true; break; } case GL_TEXTURE_COORD_ARRAY_STRIDE: { const GLClientState::VertexAttribState *state = getState(getActiveTexture() + GLClientState::TEXCOORD0_LOCATION); *ptr = state->stride; isClientStateParam = true; break; } case GL_POINT_SIZE_ARRAY_TYPE_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::POINTSIZE_LOCATION); *ptr = state->type; isClientStateParam = true; break; } case GL_POINT_SIZE_ARRAY_STRIDE_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::POINTSIZE_LOCATION); *ptr = state->stride; isClientStateParam = true; break; } case GL_MATRIX_INDEX_ARRAY_SIZE_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::MATRIXINDEX_LOCATION); *ptr = state->size; isClientStateParam = true; break; } case GL_MATRIX_INDEX_ARRAY_TYPE_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::MATRIXINDEX_LOCATION); *ptr = state->type; isClientStateParam = true; break; } case GL_MATRIX_INDEX_ARRAY_STRIDE_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::MATRIXINDEX_LOCATION); *ptr = state->stride; isClientStateParam = true; break; } case GL_WEIGHT_ARRAY_SIZE_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::WEIGHT_LOCATION); *ptr = state->size; isClientStateParam = true; break; } case GL_WEIGHT_ARRAY_TYPE_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::WEIGHT_LOCATION); *ptr = state->type; isClientStateParam = true; break; } case GL_WEIGHT_ARRAY_STRIDE_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::WEIGHT_LOCATION); *ptr = state->stride; isClientStateParam = true; break; } case GL_VERTEX_ARRAY_BUFFER_BINDING: { const GLClientState::VertexAttribState *state = getState(GLClientState::VERTEX_LOCATION); *ptr = state->bufferObject; isClientStateParam = true; break; } case GL_NORMAL_ARRAY_BUFFER_BINDING: { const GLClientState::VertexAttribState *state = getState(GLClientState::NORMAL_LOCATION); *ptr = state->bufferObject; isClientStateParam = true; break; } case GL_COLOR_ARRAY_BUFFER_BINDING: { const GLClientState::VertexAttribState *state = getState(GLClientState::COLOR_LOCATION); *ptr = state->bufferObject; isClientStateParam = true; break; } case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING: { const GLClientState::VertexAttribState *state = getState(getActiveTexture()+GLClientState::TEXCOORD0_LOCATION); *ptr = state->bufferObject; isClientStateParam = true; break; } case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::POINTSIZE_LOCATION); *ptr = state->bufferObject; isClientStateParam = true; break; } case GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::MATRIXINDEX_LOCATION); *ptr = state->bufferObject; isClientStateParam = true; break; } case GL_WEIGHT_ARRAY_BUFFER_BINDING_OES: { const GLClientState::VertexAttribState *state = getState(GLClientState::WEIGHT_LOCATION); *ptr = state->bufferObject; isClientStateParam = true; break; } case GL_ARRAY_BUFFER_BINDING: { int buffer = getBuffer(GL_ARRAY_BUFFER); *ptr = buffer; isClientStateParam = true; break; } case GL_ELEMENT_ARRAY_BUFFER_BINDING: { int buffer = getBuffer(GL_ELEMENT_ARRAY_BUFFER); *ptr = buffer; isClientStateParam = true; break; } case GL_MAX_VERTEX_ATTRIBS: { if (m_maxVertexAttribsDirty) { isClientStateParam = false; } else { *ptr = m_maxVertexAttribs; isClientStateParam = true; } break; } } return isClientStateParam; } }; #endif