Home | History | Annotate | Download | only in GLcommon 
      1 #include <GLcommon/GLEScontext.h>
      2 #include <GLcommon/GLconversion_macros.h>
      3 #include <GLcommon/GLESmacros.h>
      4 #include <GLES/gl.h>
      5 #include <GLES/glext.h>
      6 #include <GLcommon/GLESvalidate.h>
      7 #include <GLcommon/TextureUtils.h>
      8 #include <GLcommon/FramebufferData.h>
      9 #include <strings.h>
     10 
     11 //decleration
     12 static void convertFixedDirectLoop(const char* dataIn,unsigned int strideIn,void* dataOut,unsigned int nBytes,unsigned int strideOut,int attribSize);
     13 static void convertFixedIndirectLoop(const char* dataIn,unsigned int strideIn,void* dataOut,GLsizei count,GLenum indices_type,const GLvoid* indices,unsigned int strideOut,int attribSize);
     14 static void convertByteDirectLoop(const char* dataIn,unsigned int strideIn,void* dataOut,unsigned int nBytes,unsigned int strideOut,int attribSize);
     15 static void convertByteIndirectLoop(const char* dataIn,unsigned int strideIn,void* dataOut,GLsizei count,GLenum indices_type,const GLvoid* indices,unsigned int strideOut,int attribSize);
     16 
     17 GLESConversionArrays::~GLESConversionArrays() {
     18     for(std::map<GLenum,ArrayData>::iterator it = m_arrays.begin(); it != m_arrays.end();it++) {
     19         if((*it).second.allocated){
     20             if((*it).second.type == GL_FLOAT){
     21                 GLfloat* p = (GLfloat *)((*it).second.data);
     22                 if(p) delete[] p;
     23             } else if((*it).second.type == GL_SHORT){
     24                 GLshort* p = (GLshort *)((*it).second.data);
     25                 if(p) delete[] p;
     26             }
     27         }
     28     }
     29 }
     30 
     31 void GLESConversionArrays::allocArr(unsigned int size,GLenum type){
     32     if(type == GL_FIXED){
     33         m_arrays[m_current].data = new GLfloat[size];
     34         m_arrays[m_current].type = GL_FLOAT;
     35     } else if(type == GL_BYTE){
     36         m_arrays[m_current].data = new GLshort[size];
     37         m_arrays[m_current].type = GL_SHORT;
     38     }
     39     m_arrays[m_current].stride = 0;
     40     m_arrays[m_current].allocated = true;
     41 }
     42 
     43 void GLESConversionArrays::setArr(void* data,unsigned int stride,GLenum type){
     44    m_arrays[m_current].type = type;
     45    m_arrays[m_current].data = data;
     46    m_arrays[m_current].stride = stride;
     47    m_arrays[m_current].allocated = false;
     48 }
     49 
     50 void* GLESConversionArrays::getCurrentData(){
     51     return m_arrays[m_current].data;
     52 }
     53 
     54 ArrayData& GLESConversionArrays::getCurrentArray(){
     55     return m_arrays[m_current];
     56 }
     57 
     58 unsigned int GLESConversionArrays::getCurrentIndex(){
     59     return m_current;
     60 }
     61 
     62 ArrayData& GLESConversionArrays::operator[](int i){
     63     return m_arrays[i];
     64 }
     65 
     66 void GLESConversionArrays::operator++(){
     67     m_current++;
     68 }
     69 
     70 GLDispatch     GLEScontext::s_glDispatch;
     71 android::Mutex GLEScontext::s_lock;
     72 std::string*   GLEScontext::s_glExtensions= NULL;
     73 std::string    GLEScontext::s_glRenderer;
     74 GLSupport      GLEScontext::s_glSupport;
     75 
     76 Version::Version():m_major(0),
     77                    m_minor(0),
     78                    m_release(0){};
     79 
     80 Version::Version(int major,int minor,int release):m_major(major),
     81                                                   m_minor(minor),
     82                                                   m_release(release){};
     83 
     84 Version::Version(const Version& ver):m_major(ver.m_major),
     85                                      m_minor(ver.m_minor),
     86                                      m_release(ver.m_release){}
     87 
     88 Version::Version(const char* versionString){
     89     m_release = 0;
     90     if((!versionString) ||
     91       ((!(sscanf(versionString,"%d.%d"   ,&m_major,&m_minor) == 2)) &&
     92        (!(sscanf(versionString,"%d.%d.%d",&m_major,&m_minor,&m_release) == 3)))){
     93         m_major = m_minor = 0; // the version is not in the right format
     94     }
     95 }
     96 
     97 Version& Version::operator=(const Version& ver){
     98     m_major   = ver.m_major;
     99     m_minor   = ver.m_minor;
    100     m_release = ver.m_release;
    101     return *this;
    102 }
    103 
    104 bool Version::operator<(const Version& ver) const{
    105     if(m_major < ver.m_major) return true;
    106     if(m_major == ver.m_major){
    107         if(m_minor < ver.m_minor) return true;
    108         if(m_minor == ver.m_minor){
    109            return m_release < ver.m_release;
    110         }
    111     }
    112     return false;
    113 }
    114 
    115 void GLEScontext::init() {
    116 
    117     if (!s_glExtensions) {
    118         initCapsLocked(s_glDispatch.glGetString(GL_EXTENSIONS));
    119         s_glExtensions = new std::string("");
    120     }
    121 
    122     if (!m_initialized) {
    123         initExtensionString();
    124 
    125         int maxTexUnits = getMaxTexUnits();
    126         m_texState = new textureUnitState[maxTexUnits];
    127         for (int i=0;i<maxTexUnits;++i) {
    128             for (int j=0;j<NUM_TEXTURE_TARGETS;++j)
    129             {
    130                 m_texState[i][j].texture = 0;
    131                 m_texState[i][j].enabled = GL_FALSE;
    132             }
    133         }
    134     }
    135 }
    136 
    137 GLEScontext::GLEScontext():
    138                            m_initialized(false)    ,
    139                            m_activeTexture(0)      ,
    140                            m_unpackAlignment(4)    ,
    141                            m_glError(GL_NO_ERROR)  ,
    142                            m_texState(0)          ,
    143                            m_arrayBuffer(0)        ,
    144                            m_elementBuffer(0),
    145                            m_renderbuffer(0),
    146                            m_framebuffer(0)
    147 {
    148 };
    149 
    150 GLenum GLEScontext::getGLerror() {
    151     return m_glError;
    152 }
    153 
    154 void GLEScontext::setGLerror(GLenum err) {
    155     m_glError = err;
    156 }
    157 
    158 void GLEScontext::setActiveTexture(GLenum tex) {
    159    m_activeTexture = tex - GL_TEXTURE0;
    160 }
    161 
    162 GLEScontext::~GLEScontext() {
    163     for(ArraysMap::iterator it = m_map.begin(); it != m_map.end();it++) {
    164         GLESpointer* p = (*it).second;
    165         if(p) {
    166             delete p;
    167         }
    168     }
    169     delete[] m_texState;
    170     m_texState = NULL;
    171 }
    172 
    173 const GLvoid* GLEScontext::setPointer(GLenum arrType,GLint size,GLenum type,GLsizei stride,const GLvoid* data,bool normalize) {
    174     GLuint bufferName = m_arrayBuffer;
    175     if(bufferName) {
    176         unsigned int offset = reinterpret_cast<unsigned int>(data);
    177         GLESbuffer* vbo = static_cast<GLESbuffer*>(m_shareGroup->getObjectData(VERTEXBUFFER,bufferName).Ptr());
    178         m_map[arrType]->setBuffer(size,type,stride,vbo,bufferName,offset,normalize);
    179         return  static_cast<const unsigned char*>(vbo->getData()) +  offset;
    180     }
    181     m_map[arrType]->setArray(size,type,stride,data,normalize);
    182     return data;
    183 }
    184 
    185 void GLEScontext::enableArr(GLenum arr,bool enable) {
    186     m_map[arr]->enable(enable);
    187 }
    188 
    189 bool GLEScontext::isArrEnabled(GLenum arr) {
    190     return m_map[arr]->isEnable();
    191 }
    192 
    193 const GLESpointer* GLEScontext::getPointer(GLenum arrType) {
    194     if (m_map.find(arrType) != m_map.end()) return m_map[arrType];
    195     return NULL;
    196 }
    197 
    198 static void convertFixedDirectLoop(const char* dataIn,unsigned int strideIn,void* dataOut,unsigned int nBytes,unsigned int strideOut,int attribSize) {
    199 
    200     for(unsigned int i = 0; i < nBytes;i+=strideOut) {
    201         const GLfixed* fixed_data = (const GLfixed *)dataIn;
    202         //filling attrib
    203         for(int j=0;j<attribSize;j++) {
    204             reinterpret_cast<GLfloat*>(&static_cast<unsigned char*>(dataOut)[i])[j] = X2F(fixed_data[j]);
    205         }
    206         dataIn += strideIn;
    207     }
    208 }
    209 
    210 static void convertFixedIndirectLoop(const char* dataIn,unsigned int strideIn,void* dataOut,GLsizei count,GLenum indices_type,const GLvoid* indices,unsigned int strideOut,int attribSize) {
    211     for(int i = 0 ;i < count ;i++) {
    212         unsigned short index = indices_type == GL_UNSIGNED_BYTE? ((GLubyte *)indices)[i]:
    213                                                              ((GLushort *)indices)[i];
    214         const GLfixed* fixed_data = (GLfixed *)(dataIn  + index*strideIn);
    215         GLfloat* float_data = reinterpret_cast<GLfloat*>(static_cast<unsigned char*>(dataOut) + index*strideOut);
    216 
    217         for(int j=0;j<attribSize;j++) {
    218             float_data[j] = X2F(fixed_data[j]);
    219          }
    220     }
    221 }
    222 
    223 static void convertByteDirectLoop(const char* dataIn,unsigned int strideIn,void* dataOut,unsigned int nBytes,unsigned int strideOut,int attribSize) {
    224 
    225     for(unsigned int i = 0; i < nBytes;i+=strideOut) {
    226         const GLbyte* byte_data = (const GLbyte *)dataIn;
    227         //filling attrib
    228         for(int j=0;j<attribSize;j++) {
    229             reinterpret_cast<GLshort*>(&static_cast<unsigned char*>(dataOut)[i])[j] = B2S(byte_data[j]);
    230         }
    231         dataIn += strideIn;
    232     }
    233 }
    234 
    235 static void convertByteIndirectLoop(const char* dataIn,unsigned int strideIn,void* dataOut,GLsizei count,GLenum indices_type,const GLvoid* indices,unsigned int strideOut,int attribSize) {
    236     for(int i = 0 ;i < count ;i++) {
    237         unsigned short index = indices_type == GL_UNSIGNED_BYTE? ((GLubyte *)indices)[i]:
    238                                                              ((GLushort *)indices)[i];
    239         const GLbyte* bytes_data = (GLbyte *)(dataIn  + index*strideIn);
    240         GLshort* short_data = reinterpret_cast<GLshort*>(static_cast<unsigned char*>(dataOut) + index*strideOut);
    241 
    242         for(int j=0;j<attribSize;j++) {
    243             short_data[j] = B2S(bytes_data[j]);
    244          }
    245     }
    246 }
    247 static void directToBytesRanges(GLint first,GLsizei count,GLESpointer* p,RangeList& list) {
    248 
    249     int attribSize = p->getSize()*4; //4 is the sizeof GLfixed or GLfloat in bytes
    250     int stride = p->getStride()?p->getStride():attribSize;
    251     int start  = p->getBufferOffset()+first*attribSize;
    252     if(!p->getStride()) {
    253         list.addRange(Range(start,count*attribSize));
    254     } else {
    255         for(int i = 0 ;i < count; i++,start+=stride) {
    256             list.addRange(Range(start,attribSize));
    257         }
    258     }
    259 }
    260 
    261 static void indirectToBytesRanges(const GLvoid* indices,GLenum indices_type,GLsizei count,GLESpointer* p,RangeList& list) {
    262 
    263     int attribSize = p->getSize() * 4; //4 is the sizeof GLfixed or GLfloat in bytes
    264     int stride = p->getStride()?p->getStride():attribSize;
    265     int start  = p->getBufferOffset();
    266     for(int i=0 ; i < count; i++) {
    267         GLushort index = (indices_type == GL_UNSIGNED_SHORT?
    268                          static_cast<const GLushort*>(indices)[i]:
    269                          static_cast<const GLubyte*>(indices)[i]);
    270         list.addRange(Range(start+index*stride,attribSize));
    271 
    272     }
    273 }
    274 
    275 int bytesRangesToIndices(RangeList& ranges,GLESpointer* p,GLushort* indices) {
    276 
    277     int attribSize = p->getSize() * 4; //4 is the sizeof GLfixed or GLfloat in bytes
    278     int stride = p->getStride()?p->getStride():attribSize;
    279     int offset = p->getBufferOffset();
    280 
    281     int n = 0;
    282     for(int i=0;i<ranges.size();i++) {
    283         int startIndex = (ranges[i].getStart() - offset) / stride;
    284         int nElements = ranges[i].getSize()/attribSize;
    285         for(int j=0;j<nElements;j++) {
    286             indices[n++] = startIndex+j;
    287         }
    288     }
    289     return n;
    290 }
    291 
    292 void GLEScontext::convertDirect(GLESConversionArrays& cArrs,GLint first,GLsizei count,GLenum array_id,GLESpointer* p) {
    293 
    294     GLenum type    = p->getType();
    295     int attribSize = p->getSize();
    296     unsigned int size = attribSize*count + first;
    297     unsigned int bytes = type == GL_FIXED ? sizeof(GLfixed):sizeof(GLbyte);
    298     cArrs.allocArr(size,type);
    299     int stride = p->getStride()?p->getStride():bytes*attribSize;
    300     const char* data = (const char*)p->getArrayData() + (first*stride);
    301 
    302     if(type == GL_FIXED) {
    303         convertFixedDirectLoop(data,stride,cArrs.getCurrentData(),size*sizeof(GLfloat),attribSize*sizeof(GLfloat),attribSize);
    304     } else if(type == GL_BYTE) {
    305         convertByteDirectLoop(data,stride,cArrs.getCurrentData(),size*sizeof(GLshort),attribSize*sizeof(GLshort),attribSize);
    306     }
    307 }
    308 
    309 void GLEScontext::convertDirectVBO(GLESConversionArrays& cArrs,GLint first,GLsizei count,GLenum array_id,GLESpointer* p) {
    310 
    311     RangeList ranges;
    312     RangeList conversions;
    313     GLushort* indices = NULL;
    314     GLenum type    = p->getType();
    315     int attribSize = p->getSize();
    316     int stride = p->getStride()?p->getStride():sizeof(GLfixed)*attribSize;
    317     unsigned int size = p->getStride()?p->getStride()*count:attribSize*count*sizeof(GLfixed);
    318     char* data = (char*)p->getBufferData() + (first*stride);
    319 
    320     if(p->bufferNeedConversion()) {
    321         directToBytesRanges(first,count,p,ranges); //converting indices range to buffer bytes ranges by offset
    322         p->getBufferConversions(ranges,conversions); // getting from the buffer the relevant ranges that still needs to be converted
    323 
    324         if(conversions.size()) { // there are some elements to convert
    325            indices = new GLushort[count];
    326            int nIndices = bytesRangesToIndices(conversions,p,indices); //converting bytes ranges by offset to indices in this array
    327            convertFixedIndirectLoop(data,stride,data,nIndices,GL_UNSIGNED_SHORT,indices,stride,attribSize);
    328         }
    329     }
    330     if(indices) delete[] indices;
    331     cArrs.setArr(data,p->getStride(),GL_FLOAT);
    332 }
    333 
    334 int GLEScontext::findMaxIndex(GLsizei count,GLenum type,const GLvoid* indices) {
    335     //finding max index
    336     int max = 0;
    337     if(type == GL_UNSIGNED_BYTE) {
    338         GLubyte*  b_indices  =(GLubyte *)indices;
    339         for(int i=0;i<count;i++) {
    340             if(b_indices[i] > max) max = b_indices[i];
    341         }
    342     } else {
    343         GLushort* us_indices =(GLushort *)indices;
    344         for(int i=0;i<count;i++) {
    345             if(us_indices[i] > max) max = us_indices[i];
    346         }
    347     }
    348     return max;
    349 }
    350 
    351 void GLEScontext::convertIndirect(GLESConversionArrays& cArrs,GLsizei count,GLenum indices_type,const GLvoid* indices,GLenum array_id,GLESpointer* p) {
    352     GLenum type    = p->getType();
    353     int maxElements = findMaxIndex(count,type,indices) + 1;
    354 
    355     int attribSize = p->getSize();
    356     int size = attribSize * maxElements;
    357     unsigned int bytes = type == GL_FIXED ? sizeof(GLfixed):sizeof(GLbyte);
    358     cArrs.allocArr(size,type);
    359     int stride = p->getStride()?p->getStride():bytes*attribSize;
    360 
    361     const char* data = (const char*)p->getArrayData();
    362     if(type == GL_FIXED) {
    363         convertFixedIndirectLoop(data,stride,cArrs.getCurrentData(),count,indices_type,indices,attribSize*sizeof(GLfloat),attribSize);
    364     } else if(type == GL_BYTE){
    365         convertByteIndirectLoop(data,stride,cArrs.getCurrentData(),count,indices_type,indices,attribSize*sizeof(GLshort),attribSize);
    366     }
    367 }
    368 
    369 void GLEScontext::convertIndirectVBO(GLESConversionArrays& cArrs,GLsizei count,GLenum indices_type,const GLvoid* indices,GLenum array_id,GLESpointer* p) {
    370     RangeList ranges;
    371     RangeList conversions;
    372     GLushort* conversionIndices = NULL;
    373     GLenum type    = p->getType();
    374     int attribSize = p->getSize();
    375     int stride = p->getStride()?p->getStride():sizeof(GLfixed)*attribSize;
    376     char* data = static_cast<char*>(p->getBufferData());
    377     if(p->bufferNeedConversion()) {
    378         indirectToBytesRanges(indices,indices_type,count,p,ranges); //converting indices range to buffer bytes ranges by offset
    379         p->getBufferConversions(ranges,conversions); // getting from the buffer the relevant ranges that still needs to be converted
    380         if(conversions.size()) { // there are some elements to convert
    381             conversionIndices = new GLushort[count];
    382             int nIndices = bytesRangesToIndices(conversions,p,conversionIndices); //converting bytes ranges by offset to indices in this array
    383             convertFixedIndirectLoop(data,stride,data,nIndices,GL_UNSIGNED_SHORT,conversionIndices,stride,attribSize);
    384         }
    385     }
    386     if(conversionIndices) delete[] conversionIndices;
    387     cArrs.setArr(data,p->getStride(),GL_FLOAT);
    388 }
    389 
    390 
    391 
    392 void GLEScontext::bindBuffer(GLenum target,GLuint buffer) {
    393     if(target == GL_ARRAY_BUFFER) {
    394         m_arrayBuffer = buffer;
    395     } else {
    396        m_elementBuffer = buffer;
    397     }
    398 }
    399 
    400 void GLEScontext::unbindBuffer(GLuint buffer) {
    401     if(m_arrayBuffer == buffer)
    402     {
    403         m_arrayBuffer = 0;
    404     }
    405     if(m_elementBuffer == buffer)
    406     {
    407         m_elementBuffer = 0;
    408     }
    409 }
    410 
    411 //checks if any buffer is binded to target
    412 bool GLEScontext::isBindedBuffer(GLenum target) {
    413     if(target == GL_ARRAY_BUFFER) {
    414         return m_arrayBuffer != 0;
    415     } else {
    416         return m_elementBuffer != 0;
    417     }
    418 }
    419 
    420 GLuint GLEScontext::getBuffer(GLenum target) {
    421     return target == GL_ARRAY_BUFFER ? m_arrayBuffer:m_elementBuffer;
    422 }
    423 
    424 GLvoid* GLEScontext::getBindedBuffer(GLenum target) {
    425     GLuint bufferName = getBuffer(target);
    426     if(!bufferName) return NULL;
    427 
    428     GLESbuffer* vbo = static_cast<GLESbuffer*>(m_shareGroup->getObjectData(VERTEXBUFFER,bufferName).Ptr());
    429     return vbo->getData();
    430 }
    431 
    432 void GLEScontext::getBufferSize(GLenum target,GLint* param) {
    433     GLuint bufferName = getBuffer(target);
    434     GLESbuffer* vbo = static_cast<GLESbuffer*>(m_shareGroup->getObjectData(VERTEXBUFFER,bufferName).Ptr());
    435     *param = vbo->getSize();
    436 }
    437 
    438 void GLEScontext::getBufferUsage(GLenum target,GLint* param) {
    439     GLuint bufferName = getBuffer(target);
    440     GLESbuffer* vbo = static_cast<GLESbuffer*>(m_shareGroup->getObjectData(VERTEXBUFFER,bufferName).Ptr());
    441     *param = vbo->getUsage();
    442 }
    443 
    444 bool GLEScontext::setBufferData(GLenum target,GLsizeiptr size,const GLvoid* data,GLenum usage) {
    445     GLuint bufferName = getBuffer(target);
    446     if(!bufferName) return false;
    447     GLESbuffer* vbo = static_cast<GLESbuffer*>(m_shareGroup->getObjectData(VERTEXBUFFER,bufferName).Ptr());
    448     return vbo->setBuffer(size,usage,data);
    449 }
    450 
    451 bool GLEScontext::setBufferSubData(GLenum target,GLintptr offset,GLsizeiptr size,const GLvoid* data) {
    452 
    453     GLuint bufferName = getBuffer(target);
    454     if(!bufferName) return false;
    455     GLESbuffer* vbo = static_cast<GLESbuffer*>(m_shareGroup->getObjectData(VERTEXBUFFER,bufferName).Ptr());
    456     return vbo->setSubBuffer(offset,size,data);
    457 }
    458 
    459 const char * GLEScontext::getExtensionString() {
    460     const char * ret;
    461     s_lock.lock();
    462     if (s_glExtensions)
    463         ret = s_glExtensions->c_str();
    464     else
    465         ret="";
    466     s_lock.unlock();
    467     return ret;
    468 }
    469 
    470 const char * GLEScontext::getRendererString() const {
    471     return s_glRenderer.c_str();
    472 }
    473 
    474 void GLEScontext::getGlobalLock() {
    475     s_lock.lock();
    476 }
    477 
    478 void GLEScontext::releaseGlobalLock() {
    479     s_lock.unlock();
    480 }
    481 
    482 
    483 void GLEScontext::initCapsLocked(const GLubyte * extensionString)
    484 {
    485     const char* cstring = (const char*)extensionString;
    486 
    487     s_glDispatch.glGetIntegerv(GL_MAX_VERTEX_ATTRIBS,&s_glSupport.maxVertexAttribs);
    488     s_glDispatch.glGetIntegerv(GL_MAX_CLIP_PLANES,&s_glSupport.maxClipPlane);
    489     s_glDispatch.glGetIntegerv(GL_MAX_LIGHTS,&s_glSupport.maxLights);
    490     s_glDispatch.glGetIntegerv(GL_MAX_TEXTURE_SIZE,&s_glSupport.maxTexSize);
    491     s_glDispatch.glGetIntegerv(GL_MAX_TEXTURE_UNITS,&s_glSupport.maxTexUnits);
    492     s_glDispatch.glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS,&s_glSupport.maxTexImageUnits);
    493     const GLubyte* glslVersion = s_glDispatch.glGetString(GL_SHADING_LANGUAGE_VERSION);
    494     s_glSupport.glslVersion = Version((const  char*)(glslVersion));
    495 
    496     if (strstr(cstring,"GL_EXT_bgra ")!=NULL)
    497         s_glSupport.GL_EXT_TEXTURE_FORMAT_BGRA8888 = true;
    498 
    499     if (strstr(cstring,"GL_EXT_framebuffer_object ")!=NULL)
    500         s_glSupport.GL_EXT_FRAMEBUFFER_OBJECT = true;
    501 
    502     if (strstr(cstring,"GL_ARB_vertex_blend ")!=NULL)
    503         s_glSupport.GL_ARB_VERTEX_BLEND = true;
    504 
    505     if (strstr(cstring,"GL_ARB_matrix_palette ")!=NULL)
    506         s_glSupport.GL_ARB_MATRIX_PALETTE = true;
    507 
    508     if (strstr(cstring,"GL_EXT_packed_depth_stencil ")!=NULL )
    509         s_glSupport.GL_EXT_PACKED_DEPTH_STENCIL = true;
    510 
    511     if (strstr(cstring,"GL_OES_read_format ")!=NULL)
    512         s_glSupport.GL_OES_READ_FORMAT = true;
    513 
    514     if (strstr(cstring,"GL_ARB_half_float_pixel ")!=NULL)
    515         s_glSupport.GL_ARB_HALF_FLOAT_PIXEL = true;
    516 
    517     if (strstr(cstring,"GL_NV_half_float ")!=NULL)
    518         s_glSupport.GL_NV_HALF_FLOAT = true;
    519 
    520     if (strstr(cstring,"GL_ARB_half_float_vertex ")!=NULL)
    521         s_glSupport.GL_ARB_HALF_FLOAT_VERTEX = true;
    522 
    523     if (strstr(cstring,"GL_SGIS_generate_mipmap ")!=NULL)
    524         s_glSupport.GL_SGIS_GENERATE_MIPMAP = true;
    525 
    526     if (strstr(cstring,"GL_ARB_ES2_compatibility ")!=NULL)
    527         s_glSupport.GL_ARB_ES2_COMPATIBILITY = true;
    528 
    529     if (strstr(cstring,"GL_OES_standard_derivatives ")!=NULL)
    530         s_glSupport.GL_OES_STANDARD_DERIVATIVES = true;
    531 
    532 }
    533 
    534 bool GLEScontext::isTextureUnitEnabled(GLenum unit) {
    535     for (int i=0;i<NUM_TEXTURE_TARGETS;++i) {
    536         if (m_texState[unit-GL_TEXTURE0][i].enabled)
    537             return true;
    538     }
    539     return false;
    540 }
    541 
    542 bool GLEScontext::glGetBooleanv(GLenum pname, GLboolean *params)
    543 {
    544     GLint iParam;
    545 
    546     if(glGetIntegerv(pname, &iParam))
    547     {
    548         *params = (iParam != 0);
    549         return true;
    550     }
    551 
    552     return false;
    553 }
    554 
    555 bool GLEScontext::glGetFixedv(GLenum pname, GLfixed *params)
    556 {
    557     bool result = false;
    558     GLint numParams = 1;
    559 
    560     GLint* iParams = new GLint[numParams];
    561     if (numParams>0 && glGetIntegerv(pname,iParams)) {
    562         while(numParams >= 0)
    563         {
    564             params[numParams] = I2X(iParams[numParams]);
    565             numParams--;
    566         }
    567         result = true;
    568     }
    569     delete [] iParams;
    570 
    571     return result;
    572 }
    573 
    574 bool GLEScontext::glGetFloatv(GLenum pname, GLfloat *params)
    575 {
    576     bool result = false;
    577     GLint numParams = 1;
    578 
    579     GLint* iParams = new GLint[numParams];
    580     if (numParams>0 && glGetIntegerv(pname,iParams)) {
    581         while(numParams >= 0)
    582         {
    583             params[numParams] = (GLfloat)iParams[numParams];
    584             numParams--;
    585         }
    586         result = true;
    587     }
    588     delete [] iParams;
    589 
    590     return result;
    591 }
    592 
    593 bool GLEScontext::glGetIntegerv(GLenum pname, GLint *params)
    594 {
    595     switch(pname)
    596     {
    597         case GL_ARRAY_BUFFER_BINDING:
    598             *params = m_arrayBuffer;
    599             break;
    600 
    601         case GL_ELEMENT_ARRAY_BUFFER_BINDING:
    602             *params = m_elementBuffer;
    603             break;
    604 
    605         case GL_TEXTURE_BINDING_CUBE_MAP:
    606             *params = m_texState[m_activeTexture][TEXTURE_CUBE_MAP].texture;
    607             break;
    608 
    609         case GL_TEXTURE_BINDING_2D:
    610             *params = m_texState[m_activeTexture][TEXTURE_2D].texture;
    611             break;
    612 
    613         case GL_ACTIVE_TEXTURE:
    614             *params = m_activeTexture+GL_TEXTURE0;
    615             break;
    616 
    617         case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
    618             *params = GL_UNSIGNED_BYTE;
    619             break;
    620 
    621         case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
    622             *params = GL_RGBA;
    623             break;
    624         default:
    625             return false;
    626     }
    627 
    628     return true;
    629 }
    630 
    631 TextureTarget GLEScontext::GLTextureTargetToLocal(GLenum target) {
    632     TextureTarget value=TEXTURE_2D;
    633     switch (target) {
    634     case GL_TEXTURE_CUBE_MAP:
    635     case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
    636     case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
    637     case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
    638     case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
    639     case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
    640     case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
    641         value = TEXTURE_CUBE_MAP;
    642         break;
    643     case GL_TEXTURE_2D:
    644         value = TEXTURE_2D;
    645         break;
    646     }
    647     return value;
    648 }
    649 
    650 unsigned int GLEScontext::getBindedTexture(GLenum target) {
    651     TextureTarget pos = GLTextureTargetToLocal(target);
    652     return m_texState[m_activeTexture][pos].texture;
    653 }
    654 
    655 unsigned int GLEScontext::getBindedTexture(GLenum unit, GLenum target) {
    656     TextureTarget pos = GLTextureTargetToLocal(target);
    657     return m_texState[unit-GL_TEXTURE0][pos].texture;
    658 }
    659 
    660 void GLEScontext::setBindedTexture(GLenum target, unsigned int tex) {
    661     TextureTarget pos = GLTextureTargetToLocal(target);
    662     m_texState[m_activeTexture][pos].texture = tex;
    663 }
    664 
    665 void GLEScontext::setTextureEnabled(GLenum target, GLenum enable) {
    666     TextureTarget pos = GLTextureTargetToLocal(target);
    667     m_texState[m_activeTexture][pos].enabled = enable;
    668 }
    669 
    670 #define INTERNAL_NAME(x) (x +0x100000000ll);
    671 
    672 ObjectLocalName GLEScontext::getDefaultTextureName(GLenum target) {
    673     ObjectLocalName name = 0;
    674     switch (GLTextureTargetToLocal(target)) {
    675     case TEXTURE_2D:
    676         name = INTERNAL_NAME(0);
    677         break;
    678     case TEXTURE_CUBE_MAP:
    679         name = INTERNAL_NAME(1);
    680         break;
    681     default:
    682         name = 0;
    683         break;
    684     }
    685     return name;
    686 }
    687 
    688 void GLEScontext::drawValidate(void)
    689 {
    690     if(m_framebuffer == 0)
    691         return;
    692 
    693     ObjectDataPtr fbObj = m_shareGroup->getObjectData(FRAMEBUFFER,m_framebuffer);
    694     if (fbObj.Ptr() == NULL)
    695         return;
    696 
    697     FramebufferData *fbData = (FramebufferData *)fbObj.Ptr();
    698 
    699     fbData->validate(this);
    700 }
    701