From 624176d51acf46bedba926424aaa935ef4ce0c49 Mon Sep 17 00:00:00 2001 From: Amit Feller Date: Thu, 12 May 2011 10:22:16 +0300 Subject: [PATCH] Emulators's GLES 2.0 translator implementation This is the GLESv2 on top of openGL implementation on the host most of this change is moving code which is necessary by both GLES 1.0 and GLES 2.0 implementations from GLES_CM folder into GLcommon folder. GLESv2Imp - includes GLES 2.0 entry points implementation Change-Id: I934fb963478a7f596d824612f847a5aa77d2ed9d --- .../host/libs/Translator/EGL/EglContext.h | 6 +- .../host/libs/Translator/EGL/EglImp.cpp | 28 +- .../host/libs/Translator/GLES_CM/Android.mk | 16 +- .../libs/Translator/GLES_CM/GLEScmContext.cpp | 184 +++ .../libs/Translator/GLES_CM/GLEScmContext.h | 71 + .../GLES_CM/{GLESimp.cpp => GLEScmImp.cpp} | 176 +-- .../{GLESutils.cpp => GLEScmUtils.cpp} | 2 +- .../GLES_CM/{GLESutils.h => GLEScmUtils.h} | 0 .../{GLESvalidate.cpp => GLEScmValidate.cpp} | 144 +- .../{GLESvalidate.h => GLEScmValidate.h} | 21 +- .../host/libs/Translator/GLES_V2/Android.mk | 29 + .../libs/Translator/GLES_V2/GLESv2Context.cpp | 55 + .../libs/Translator/GLES_V2/GLESv2Context.h | 45 + .../libs/Translator/GLES_V2/GLESv2Imp.cpp | 1204 +++++++++++++++++ .../Translator/GLES_V2/GLESv2Validate.cpp | 184 +++ .../libs/Translator/GLES_V2/GLESv2Validate.h | 42 + .../host/libs/Translator/GLcommon/Android.mk | 15 +- .../libs/Translator/GLcommon/GLDispatch.cpp | 479 +++++++ .../{GLES_CM => GLcommon}/GLESbuffer.cpp | 2 +- .../libs/Translator/GLcommon/GLEScontext.cpp | 317 +++++ .../{GLES_CM => GLcommon}/GLESpointer.cpp | 21 +- .../libs/Translator/GLcommon/GLESvalidate.cpp | 66 + .../{GLES_CM => GLcommon}/RangeManip.cpp | 2 +- .../Translator/include/GLcommon/GLDispatch.h | 248 ++++ .../GLcommon}/GLESbuffer.h | 2 +- .../GLcommon}/GLEScontext.h | 90 +- .../Translator/include/GLcommon/GLESmacros.h | 61 + .../GLcommon}/GLESpointer.h | 6 +- .../include/GLcommon/GLESvalidate.h | 33 + .../GLcommon}/GLfixed_ops.h | 0 .../Translator/include/GLcommon/GLutils.h | 6 + .../GLcommon}/RangeManip.h | 0 .../tests/translator_tests/GLES_CM/Android.mk | 30 + .../translator_tests/GLES_CM/triangleCM.cpp | 385 ++++++ .../tests/translator_tests/GLES_V2/Android.mk | 29 + .../translator_tests/GLES_V2/triangleV2.cpp | 315 +++++ 36 files changed, 3997 insertions(+), 317 deletions(-) create mode 100644 tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmContext.cpp create mode 100644 tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmContext.h rename tools/emulator/opengl/host/libs/Translator/GLES_CM/{GLESimp.cpp => GLEScmImp.cpp} (85%) rename tools/emulator/opengl/host/libs/Translator/GLES_CM/{GLESutils.cpp => GLEScmUtils.cpp} (99%) rename tools/emulator/opengl/host/libs/Translator/GLES_CM/{GLESutils.h => GLEScmUtils.h} (100%) rename tools/emulator/opengl/host/libs/Translator/GLES_CM/{GLESvalidate.cpp => GLEScmValidate.cpp} (63%) rename tools/emulator/opengl/host/libs/Translator/GLES_CM/{GLESvalidate.h => GLEScmValidate.h} (78%) create mode 100644 tools/emulator/opengl/host/libs/Translator/GLES_V2/Android.mk create mode 100644 tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Context.cpp create mode 100644 tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Context.h create mode 100644 tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Imp.cpp create mode 100644 tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Validate.cpp create mode 100644 tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Validate.h create mode 100644 tools/emulator/opengl/host/libs/Translator/GLcommon/GLDispatch.cpp rename tools/emulator/opengl/host/libs/Translator/{GLES_CM => GLcommon}/GLESbuffer.cpp (97%) create mode 100644 tools/emulator/opengl/host/libs/Translator/GLcommon/GLEScontext.cpp rename tools/emulator/opengl/host/libs/Translator/{GLES_CM => GLcommon}/GLESpointer.cpp (74%) create mode 100644 tools/emulator/opengl/host/libs/Translator/GLcommon/GLESvalidate.cpp rename tools/emulator/opengl/host/libs/Translator/{GLES_CM => GLcommon}/RangeManip.cpp (99%) create mode 100644 tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLDispatch.h rename tools/emulator/opengl/host/libs/Translator/{GLES_CM => include/GLcommon}/GLESbuffer.h (97%) rename tools/emulator/opengl/host/libs/Translator/{GLES_CM => include/GLcommon}/GLEScontext.h (52%) create mode 100644 tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLESmacros.h rename tools/emulator/opengl/host/libs/Translator/{GLES_CM => include/GLcommon}/GLESpointer.h (90%) create mode 100644 tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLESvalidate.h rename tools/emulator/opengl/host/libs/Translator/{GLES_CM => include/GLcommon}/GLfixed_ops.h (100%) rename tools/emulator/opengl/host/libs/Translator/{GLES_CM => include/GLcommon}/RangeManip.h (100%) create mode 100644 tools/emulator/opengl/tests/translator_tests/GLES_CM/Android.mk create mode 100644 tools/emulator/opengl/tests/translator_tests/GLES_CM/triangleCM.cpp create mode 100644 tools/emulator/opengl/tests/translator_tests/GLES_V2/Android.mk create mode 100644 tools/emulator/opengl/tests/translator_tests/GLES_V2/triangleV2.cpp diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglContext.h b/tools/emulator/opengl/host/libs/Translator/EGL/EglContext.h index 0c2072372..c162e28e7 100644 --- a/tools/emulator/opengl/host/libs/Translator/EGL/EglContext.h +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglContext.h @@ -18,6 +18,7 @@ #include #include +#include #include #include #include @@ -27,11 +28,6 @@ #include "EglSurface.h" -typedef enum{ - GLES_1_1 = 0, - GLES_2_0 = 1, - MAX_GLES_VERSION //Must be last - }GLESVersion; class EglContext; typedef SmartPtr ContextPtr; diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglImp.cpp b/tools/emulator/opengl/host/libs/Translator/EGL/EglImp.cpp index 8c432d388..e8963465b 100644 --- a/tools/emulator/opengl/host/libs/Translator/EGL/EglImp.cpp +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglImp.cpp @@ -159,14 +159,15 @@ static __translator_getGLESIfaceFunc loadIfaces(const char* libName){ return func; } - - #ifdef _WIN32 -#define LIB_GLES_NAME "libGLES_CM_translator" +#define LIB_GLES_CM_NAME "libGLES_CM_translator" +#define LIB_GLES_V2_NAME "libGLES_V2_translator" #elif __linux__ -#define LIB_GLES_NAME "libGLES_CM_translator.so" +#define LIB_GLES_CM_NAME "libGLES_CM_translator.so" +#define LIB_GLES_V2_NAME "libGLES_V2_translator.so" #else -#define LIB_GLES_NAME "libGLES_CM_translator" +#define LIB_GLES_CM_NAME "libGLES_CM_translator" +#define LIB_GLES_V2_NAME "libGLES_V2_translator" #endif EGLAPI EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay display, EGLint *major, EGLint *minor) { @@ -177,13 +178,24 @@ EGLAPI EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay display, EGLint *major, E if(major) *major = MAJOR; if(minor) *minor = MINOR; - if(!g_eglInfo->getIface(GLES_1_1)) { - __translator_getGLESIfaceFunc func = loadIfaces(LIB_GLES_NAME); + __translator_getGLESIfaceFunc func = NULL; + + if(!g_eglInfo->getIface(GLES_1_1)) { + func = loadIfaces(LIB_GLES_CM_NAME); if(func){ g_eglInfo->setIface(func(&s_eglIface),GLES_1_1); } else { - fprintf(stderr,"could not find ifaces...\n"); + fprintf(stderr,"could not find ifaces for GLES CM 1.1\n"); + return EGL_FALSE; + } + } + if(!g_eglInfo->getIface(GLES_2_0)) { + func = loadIfaces(LIB_GLES_V2_NAME); + if(func){ + g_eglInfo->setIface(func(&s_eglIface),GLES_2_0); + } else { + fprintf(stderr,"could not find ifaces for GLES 2.0\n"); return EGL_FALSE; } } diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_CM/Android.mk b/tools/emulator/opengl/host/libs/Translator/GLES_CM/Android.mk index 67eab95e9..59052b2ed 100644 --- a/tools/emulator/opengl/host/libs/Translator/GLES_CM/Android.mk +++ b/tools/emulator/opengl/host/libs/Translator/GLES_CM/Android.mk @@ -7,16 +7,12 @@ translator_path := $(LOCAL_PATH)/.. #exclude darwin builds ifeq (, $(findstring $(HOST_OS), darwin)) -LOCAL_SRC_FILES := \ - GLDispatch.cpp \ - GLEScontext.cpp \ - GLESimp.cpp \ - GLESpointer.cpp \ - GLESvalidate.cpp \ - GLESutils.cpp \ - GLESbuffer.cpp \ - TextureUtils.cpp \ - RangeManip.cpp +LOCAL_SRC_FILES := \ + GLEScmImp.cpp \ + GLEScmUtils.cpp \ + TextureUtils.cpp \ + GLEScmContext.cpp \ + GLEScmValidate.cpp LOCAL_C_INCLUDES += \ $(translator_path)/include \ diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmContext.cpp b/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmContext.cpp new file mode 100644 index 000000000..67ffa89f0 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmContext.cpp @@ -0,0 +1,184 @@ +/* +* 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 "GLEScmContext.h" +#include "GLEScmUtils.h" +#include +#include +#include + +GLcmSupport GLEScmContext::s_glSupport; + +void GLEScmContext::init() { + android::Mutex::Autolock mutex(s_lock); + if(!m_initialized) { + int maxTexUnits; + s_glDispatch.dispatchFuncs(GLES_1_1); + s_glDispatch.glGetIntegerv(GL_MAX_CLIP_PLANES,&s_glSupport.maxClipPlane); + s_glDispatch.glGetIntegerv(GL_MAX_LIGHTS,&s_glSupport.maxLights); + s_glDispatch.glGetIntegerv(GL_MAX_TEXTURE_SIZE,&s_glSupport.maxTexSize); + s_glDispatch.glGetIntegerv(GL_MAX_TEXTURE_UNITS,&maxTexUnits); + s_glSupport.maxTexUnits = maxTexUnits < MAX_TEX_UNITS ? maxTexUnits:MAX_TEX_UNITS; + } + + m_texCoords = new GLESpointer[s_glSupport.maxTexUnits]; + m_map[GL_TEXTURE_COORD_ARRAY] = &m_texCoords[m_activeTexture]; + m_initialized = true; +} + +GLEScmContext::GLEScmContext():GLEScontext(),m_pointsIndex(-1){ + + m_map[GL_COLOR_ARRAY] = new GLESpointer(); + m_map[GL_NORMAL_ARRAY] = new GLESpointer(); + m_map[GL_VERTEX_ARRAY] = new GLESpointer(); + m_map[GL_POINT_SIZE_ARRAY_OES] = new GLESpointer(); +} + + +void GLEScmContext::setActiveTexture(GLenum tex) { + m_activeTexture = tex - GL_TEXTURE0; + m_map[GL_TEXTURE_COORD_ARRAY] = &m_texCoords[m_activeTexture]; +} + +GLEScmContext::~GLEScmContext(){ + if(m_texCoords){ + delete[] m_texCoords; + m_texCoords = NULL; + } +} + + +//sending data to server side +void GLEScmContext::sendArr(GLvoid* arr,GLenum arrayType,GLint size,GLsizei stride,int index) { + switch(arrayType) { + case GL_VERTEX_ARRAY: + s_glDispatch.glVertexPointer(size,GL_FLOAT,stride,arr); + break; + case GL_NORMAL_ARRAY: + s_glDispatch.glNormalPointer(GL_FLOAT,stride,arr); + break; + case GL_TEXTURE_COORD_ARRAY: + s_glDispatch.glTexCoordPointer(size,GL_FLOAT,stride,arr); + break; + case GL_COLOR_ARRAY: + s_glDispatch.glColorPointer(size,GL_FLOAT,stride,arr); + break; + case GL_POINT_SIZE_ARRAY_OES: + m_pointsIndex = index; + break; + } +} + +void GLEScmContext::convertArrs(GLESFloatArrays& fArrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices,bool direct) { + ArraysMap::iterator it; + unsigned int index = 0; + m_pointsIndex = -1; + + //going over all clients arrays Pointers + for ( it=m_map.begin() ; it != m_map.end(); it++ ) { + GLenum array_id = (*it).first; + GLESpointer* p = (*it).second; + + if(array_id == GL_TEXTURE_COORD_ARRAY) continue; //handling textures later + chooseConvertMethod(fArrs,first,count,type,indices,direct,p,array_id,index); + } + + unsigned int activeTexture = m_activeTexture + GL_TEXTURE0; + + s_lock.lock(); + int maxTexUnits = s_glSupport.maxTexUnits; + s_lock.unlock(); + + //converting all texture coords arrays + for(int i=0; i< maxTexUnits;i++) { + + unsigned int tex = GL_TEXTURE0+i; + setActiveTexture(tex); + s_glDispatch.glClientActiveTexture(tex); + + GLenum array_id = GL_TEXTURE_COORD_ARRAY; + GLESpointer* p = m_map[array_id]; + chooseConvertMethod(fArrs,first,count,type,indices,direct,p,array_id,index); + } + + setActiveTexture(activeTexture); + s_glDispatch.glClientActiveTexture(activeTexture); +} + +void GLEScmContext::drawPoints(PointSizeIndices* points) { + + GLushort* indices = NULL; + int last_size = 0; + + //drawing each group of vertices by the points size + for(PointSizeIndices::iterator it = points->begin();it != points->end(); it++) { + int count = (*it).second.size(); + int pointSize = (*it).first; + std::vector& arr = (*it).second; + + if(count > last_size) { + if(indices) delete [] indices; + indices = new GLushort[count]; + } + int i = 0 ; + for(std::vector::iterator it2 = arr.begin();it2 != arr.end();it2++) { + indices[i++] = (*it2); + } + s_glDispatch.glPointSize(pointSize); + s_glDispatch.glDrawElements(GL_POINTS,count,GL_UNSIGNED_SHORT,indices); + } + if(indices) delete [] indices; +} + +void GLEScmContext::drawPointsData(GLESFloatArrays& fArrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices_in,bool isElemsDraw) { + const GLfloat *pointsArr = NULL; + int stride = 0; //steps in GLfloats + + //choosing the right points sizes array source + if(m_pointsIndex >= 0) { //point size array was converted + pointsArr=fArrs.arrays[m_pointsIndex]; + stride = 1; + } else { + GLESpointer* p = m_map[GL_POINT_SIZE_ARRAY_OES]; + pointsArr = static_cast(isBindedBuffer(GL_ARRAY_BUFFER)?p->getBufferData():p->getArrayData()); + stride = p->getStride()?p->getStride()/sizeof(GLfloat):1; + } + + //filling arrays before sorting them + PointSizeIndices points; + if(isElemsDraw) { + for(int i=0; i< count; i++) { + GLushort index = (type == GL_UNSIGNED_SHORT? + static_cast(indices_in)[i]: + static_cast(indices_in)[i]); + points[pointsArr[index*stride]].push_back(index); + } + } else { + for(int i=0; i< count; i++) { + points[pointsArr[first+i*stride]].push_back(i+first); + } + } + drawPoints(&points); +} + +void GLEScmContext::drawPointsArrs(GLESFloatArrays& arrs,GLint first,GLsizei count) { + drawPointsData(arrs,first,count,0,NULL,false); +} + +void GLEScmContext::drawPointsElems(GLESFloatArrays& arrs,GLsizei count,GLenum type,const GLvoid* indices_in) { + drawPointsData(arrs,0,count,type,indices_in,true); +} + diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmContext.h b/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmContext.h new file mode 100644 index 000000000..f3b4b9dd5 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmContext.h @@ -0,0 +1,71 @@ +/* +* 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 GLES_CM_CONTEX_H +#define GLES_CM_CONTEX_H + +#include +#include +#include +#include +#include +#include +#include + + +typedef std::map > PointSizeIndices; + +struct GLcmSupport { + GLcmSupport():maxLights(0),maxClipPlane(0),maxTexUnits(0),maxTexSize(0){}; + int maxLights; + int maxClipPlane; + int maxTexUnits; + int maxTexSize; +}; + +class GLEScmContext: public GLEScontext +{ +public: + void init(); + GLEScmContext(); + + void setActiveTexture(GLenum tex); + void convertArrs(GLESFloatArrays& fArrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices,bool direct); + void drawPointsArrs(GLESFloatArrays& arrs,GLint first,GLsizei count); + void drawPointsElems(GLESFloatArrays& arrs,GLsizei count,GLenum type,const GLvoid* indices); + + ~GLEScmContext(); + + static int getMaxLights(){return s_glSupport.maxLights;} + static int getMaxClipPlanes(){return s_glSupport.maxClipPlane;} + static int getMaxTexUnits(){return s_glSupport.maxTexUnits;} + static int getMaxTexSize(){return s_glSupport.maxTexSize;} + + +private: + + void sendArr(GLvoid* arr,GLenum arrayType,GLint size,GLsizei stride,int pointsIndex = -1); + void drawPoints(PointSizeIndices* points); + void drawPointsData(GLESFloatArrays& arrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices_in,bool isElemsDraw); + + + static GLcmSupport s_glSupport; + + GLESpointer* m_texCoords; + int m_pointsIndex; +}; + +#endif + diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESimp.cpp b/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmImp.cpp similarity index 85% rename from tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESimp.cpp rename to tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmImp.cpp index d37791f5a..a8ff39e20 100644 --- a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESimp.cpp +++ b/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmImp.cpp @@ -18,14 +18,14 @@ #undef GL_API #define GL_API __declspec(dllexport) #endif -#include -#include "GLDispatch.h" -#include "GLEScontext.h" -#include "GLESvalidate.h" -#include "GLESutils.h" -#include "GLfixed_ops.h" +#include "GLEScmContext.h" +#include "GLEScmValidate.h" +#include "GLEScmUtils.h" #include "TextureUtils.h" +#include +#include +#include #include #include #include @@ -53,7 +53,6 @@ static ExtentionDescriptor s_glesExtentions[] = { {"glEGLImageTargetTexture2DOES",(__translatorMustCastToProperFunctionPointerType)glEGLImageTargetTexture2DOES} }; /****************************************************************************************************************/ -typedef void(*FUNCPTR)(); static EGLiface* s_eglIface = NULL; static GLESiface s_glesIface = { @@ -66,14 +65,16 @@ static GLESiface s_glesIface = { getProcAddress :getProcAddress }; +#include + extern "C" { static void initContext(GLEScontext* ctx) { ctx->init(); } + static GLEScontext* createGLESContext() { - GLEScontext* ctx = new GLEScontext(); - return ctx; + return new GLEScmContext(); } static void deleteGLESContext(GLEScontext* ctx) { @@ -101,40 +102,6 @@ GL_API GLESiface* __translator_getIfaces(EGLiface* eglIface){ } -#define GET_THREAD() \ - ThreadInfo* thrd = NULL; \ - if(s_eglIface) { \ - thrd = s_eglIface->getThreadInfo(); \ - } else { \ - fprintf(stderr,"Context wasn't initialized yet \n"); \ - } - - -#define GET_CTX() \ - GET_THREAD(); \ - if(!thrd) return; \ - GLEScontext *ctx = static_cast(thrd->glesContext); \ - if(!ctx) return; - -#define GET_CTX_RET(failure_ret) \ - GET_THREAD(); \ - if(!thrd) return failure_ret; \ - GLEScontext *ctx = static_cast(thrd->glesContext); \ - if(!ctx) return failure_ret; - - -#define SET_ERROR_IF(condition,err) if((condition)) { \ - ctx->setGLerror(err); \ - return; \ - } - - -#define RET_AND_SET_ERROR_IF(condition,err,ret) if((condition)) { \ - ctx->setGLerror(err); \ - return ret; \ - } - - GL_API GLboolean GL_APIENTRY glIsBuffer(GLuint buffer) { GET_CTX_RET(GL_FALSE) @@ -146,8 +113,8 @@ GL_API GLboolean GL_APIENTRY glIsBuffer(GLuint buffer) { } GL_API GLboolean GL_APIENTRY glIsEnabled( GLenum cap) { - GET_CTX_RET(GL_FALSE) - RET_AND_SET_ERROR_IF(!GLESvalidate::capability(cap,ctx->getMaxLights(),ctx->getMaxClipPlanes()),GL_INVALID_ENUM,GL_FALSE); + GET_CTX_CM_RET(GL_FALSE) + RET_AND_SET_ERROR_IF(!GLEScmValidate::capability(cap,ctx->getMaxLights(),ctx->getMaxClipPlanes()),GL_INVALID_ENUM,GL_FALSE); if(cap == GL_POINT_SIZE_ARRAY_OES) return ctx->isArrEnabled(cap); return ctx->dispatcher().glIsEnabled(cap); @@ -195,28 +162,28 @@ GL_API const GLubyte * GL_APIENTRY glGetString( GLenum name) { } GL_API void GL_APIENTRY glActiveTexture( GLenum texture) { - GET_CTX() - SET_ERROR_IF(!GLESvalidate::textureEnum(texture,ctx->getMaxTexUnits()),GL_INVALID_ENUM); + GET_CTX_CM() + SET_ERROR_IF(!GLEScmValidate::textureEnum(texture,ctx->getMaxTexUnits()),GL_INVALID_ENUM); ctx->dispatcher().glActiveTexture(texture); } GL_API void GL_APIENTRY glAlphaFunc( GLenum func, GLclampf ref) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::alphaFunc(func),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::alphaFunc(func),GL_INVALID_ENUM); ctx->dispatcher().glAlphaFunc(func,ref); } GL_API void GL_APIENTRY glAlphaFuncx( GLenum func, GLclampx ref) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::alphaFunc(func),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::alphaFunc(func),GL_INVALID_ENUM); ctx->dispatcher().glAlphaFunc(func,X2F(ref)); } GL_API void GL_APIENTRY glBindBuffer( GLenum target, GLuint buffer) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::bufferTarget(target),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::bufferTarget(target),GL_INVALID_ENUM); //if buffer wasn't generated before,generate one if(thrd->shareGroup.Ptr() && !thrd->shareGroup->isObject(VERTEXBUFFER,buffer)){ @@ -231,7 +198,7 @@ GL_API void GL_APIENTRY glBindBuffer( GLenum target, GLuint buffer) { GL_API void GL_APIENTRY glBindTexture( GLenum target, GLuint texture) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::textureTarget(target),GL_INVALID_ENUM) + SET_ERROR_IF(!GLEScmValidate::textureTarget(target),GL_INVALID_ENUM) GLuint globalTextureName = texture; if(texture && thrd->shareGroup.Ptr()){ @@ -248,13 +215,13 @@ GL_API void GL_APIENTRY glBindTexture( GLenum target, GLuint texture) { GL_API void GL_APIENTRY glBlendFunc( GLenum sfactor, GLenum dfactor) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::blendSrc(sfactor) || !GLESvalidate::blendDst(dfactor),GL_INVALID_ENUM) + SET_ERROR_IF(!GLEScmValidate::blendSrc(sfactor) || !GLEScmValidate::blendDst(dfactor),GL_INVALID_ENUM) ctx->dispatcher().glBlendFunc(sfactor,dfactor); } GL_API void GL_APIENTRY glBufferData( GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::bufferTarget(target),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::bufferTarget(target),GL_INVALID_ENUM); SET_ERROR_IF(!ctx->isBindedBuffer(target),GL_INVALID_OPERATION); ctx->setBufferData(target,size,data,usage); } @@ -262,7 +229,7 @@ GL_API void GL_APIENTRY glBufferData( GLenum target, GLsizeiptr size, const GLv GL_API void GL_APIENTRY glBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data) { GET_CTX() SET_ERROR_IF(!ctx->isBindedBuffer(target),GL_INVALID_OPERATION); - SET_ERROR_IF(!GLESvalidate::bufferTarget(target),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::bufferTarget(target),GL_INVALID_ENUM); SET_ERROR_IF(!ctx->setBufferSubData(target,offset,size,data),GL_INVALID_VALUE); } @@ -298,8 +265,8 @@ GL_API void GL_APIENTRY glClearStencil( GLint s) { } GL_API void GL_APIENTRY glClientActiveTexture( GLenum texture) { - GET_CTX() - SET_ERROR_IF(!GLESvalidate::textureEnum(texture,ctx->getMaxTexUnits()),GL_INVALID_ENUM); + GET_CTX_CM() + SET_ERROR_IF(!GLEScmValidate::textureEnum(texture,ctx->getMaxTexUnits()),GL_INVALID_ENUM); ctx->setActiveTexture(texture); ctx->dispatcher().glClientActiveTexture(texture); @@ -346,16 +313,16 @@ GL_API void GL_APIENTRY glColorMask( GLboolean red, GLboolean green, GLboolean GL_API void GL_APIENTRY glColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::colorPointerParams(size,stride),GL_INVALID_VALUE); + SET_ERROR_IF(!GLEScmValidate::colorPointerParams(size,stride),GL_INVALID_VALUE); const GLvoid* data = ctx->setPointer(GL_COLOR_ARRAY,size,type,stride,pointer); if(type != GL_FIXED) ctx->dispatcher().glColorPointer(size,type,stride,data); } GL_API void GL_APIENTRY glCompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) { - GET_CTX() - SET_ERROR_IF(!(GLESvalidate::texCompImgFrmt(internalformat) && GLESvalidate::textureTarget(target)),GL_INVALID_ENUM); - SET_ERROR_IF(level > log2(ctx->getMaxTexSize())|| border !=0 || level > 0 || !GLESvalidate::texImgDim(width,height,ctx->getMaxTexSize()+2),GL_INVALID_VALUE) + GET_CTX_CM() + SET_ERROR_IF(!(GLEScmValidate::texCompImgFrmt(internalformat) && GLEScmValidate::textureTarget(target)),GL_INVALID_ENUM); + SET_ERROR_IF(level > log2(ctx->getMaxTexSize())|| border !=0 || level > 0 || !GLEScmValidate::texImgDim(width,height,ctx->getMaxTexSize()+2),GL_INVALID_VALUE) int nMipmaps = -level + 1; GLsizei tmpWidth = width; @@ -374,8 +341,8 @@ GL_API void GL_APIENTRY glCompressedTexImage2D( GLenum target, GLint level, GLe } GL_API void GL_APIENTRY glCompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) { - GET_CTX() - SET_ERROR_IF(!(GLESvalidate::texCompImgFrmt(format) && GLESvalidate::textureTarget(target)),GL_INVALID_ENUM); + GET_CTX_CM() + SET_ERROR_IF(!(GLEScmValidate::texCompImgFrmt(format) && GLEScmValidate::textureTarget(target)),GL_INVALID_ENUM); SET_ERROR_IF(level < 0 || level > log2(ctx->getMaxTexSize()),GL_INVALID_VALUE) GLenum uncompressedFrmt; @@ -386,14 +353,14 @@ GL_API void GL_APIENTRY glCompressedTexSubImage2D( GLenum target, GLint level, GL_API void GL_APIENTRY glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { GET_CTX() - SET_ERROR_IF(!(GLESvalidate::pixelFrmt(internalformat) && GLESvalidate::textureTarget(target)),GL_INVALID_ENUM); + SET_ERROR_IF(!(GLEScmValidate::pixelFrmt(internalformat) && GLEScmValidate::textureTarget(target)),GL_INVALID_ENUM); SET_ERROR_IF(border != 0,GL_INVALID_VALUE); ctx->dispatcher().glCopyTexImage2D(target,level,internalformat,x,y,width,height,border); } GL_API void GL_APIENTRY glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::textureTarget(target),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::textureTarget(target),GL_INVALID_ENUM); ctx->dispatcher().glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height); } @@ -414,6 +381,7 @@ GL_API void GL_APIENTRY glDeleteBuffers( GLsizei n, const GLuint *buffers) { GL_API void GL_APIENTRY glDeleteTextures( GLsizei n, const GLuint *textures) { GET_CTX() + SET_ERROR_IF(n<0,GL_INVALID_VALUE); if(thrd->shareGroup.Ptr()) { for(int i=0; i < n; i++){ thrd->shareGroup->deleteName(TEXTURE,textures[i]); @@ -450,7 +418,7 @@ GL_API void GL_APIENTRY glDisable( GLenum cap) { GL_API void GL_APIENTRY glDisableClientState( GLenum array) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::supportedArrays(array),GL_INVALID_ENUM) + SET_ERROR_IF(!GLEScmValidate::supportedArrays(array),GL_INVALID_ENUM) ctx->enableArr(array,false); if(array != GL_POINT_SIZE_ARRAY_OES) ctx->dispatcher().glDisableClientState(array); @@ -458,9 +426,9 @@ GL_API void GL_APIENTRY glDisableClientState( GLenum array) { GL_API void GL_APIENTRY glDrawArrays( GLenum mode, GLint first, GLsizei count) { - GET_CTX() + GET_CTX_CM() SET_ERROR_IF(count < 0,GL_INVALID_VALUE) - SET_ERROR_IF(!GLESvalidate::drawMode(mode),GL_INVALID_ENUM) + SET_ERROR_IF(!GLEScmValidate::drawMode(mode),GL_INVALID_ENUM) if(!ctx->isArrEnabled(GL_VERTEX_ARRAY)) return; @@ -475,9 +443,11 @@ GL_API void GL_APIENTRY glDrawArrays( GLenum mode, GLint first, GLsizei count) } GL_API void GL_APIENTRY glDrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid *elementsIndices) { - GET_CTX() + GET_CTX_CM() SET_ERROR_IF(count < 0,GL_INVALID_VALUE) - SET_ERROR_IF((!GLESvalidate::drawMode(mode) || !GLESvalidate::drawType(type)),GL_INVALID_ENUM) + SET_ERROR_IF((!GLEScmValidate::drawMode(mode) || !GLEScmValidate::drawType(type)),GL_INVALID_ENUM) + if(!ctx->isArrEnabled(GL_VERTEX_ARRAY)) return; + const GLvoid* indices = elementsIndices; GLESFloatArrays tmpArrs; if(ctx->isBindedBuffer(GL_ELEMENT_ARRAY_BUFFER)) { // if vbo is binded take the indices from the vbo @@ -501,7 +471,7 @@ GL_API void GL_APIENTRY glEnable( GLenum cap) { GL_API void GL_APIENTRY glEnableClientState( GLenum array) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::supportedArrays(array),GL_INVALID_ENUM) + SET_ERROR_IF(!GLEScmValidate::supportedArrays(array),GL_INVALID_ENUM) ctx->enableArr(array,true); if(array != GL_POINT_SIZE_ARRAY_OES) ctx->dispatcher().glEnableClientState(array); @@ -590,7 +560,7 @@ GL_API void GL_APIENTRY glGetBooleanv( GLenum pname, GLboolean *params) { GL_API void GL_APIENTRY glGetBufferParameteriv( GLenum target, GLenum pname, GLint *params) { GET_CTX() - SET_ERROR_IF(!(GLESvalidate::bufferTarget(target) && GLESvalidate::bufferParam(pname)),GL_INVALID_ENUM); + SET_ERROR_IF(!(GLEScmValidate::bufferTarget(target) && GLEScmValidate::bufferParam(pname)),GL_INVALID_ENUM); SET_ERROR_IF(!ctx->isBindedBuffer(target),GL_INVALID_OPERATION); bool ret = true; switch(pname) { @@ -753,7 +723,7 @@ GL_API void GL_APIENTRY glGetTexParameterxv( GLenum target, GLenum pname, GLfix GL_API void GL_APIENTRY glHint( GLenum target, GLenum mode) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::hintTargetMode(target,mode),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::hintTargetMode(target,mode),GL_INVALID_ENUM); ctx->dispatcher().glHint(target,mode); } @@ -904,14 +874,14 @@ GL_API void GL_APIENTRY glMultMatrixx( const GLfixed *m) { } GL_API void GL_APIENTRY glMultiTexCoord4f( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) { - GET_CTX() - SET_ERROR_IF(!GLESvalidate::textureEnum(target,ctx->getMaxTexUnits()),GL_INVALID_ENUM); + GET_CTX_CM() + SET_ERROR_IF(!GLEScmValidate::textureEnum(target,ctx->getMaxTexUnits()),GL_INVALID_ENUM); ctx->dispatcher().glMultiTexCoord4f(target,s,t,r,q); } GL_API void GL_APIENTRY glMultiTexCoord4x( GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) { - GET_CTX() - SET_ERROR_IF(!GLESvalidate::textureEnum(target,ctx->getMaxTexUnits()),GL_INVALID_ENUM); + GET_CTX_CM() + SET_ERROR_IF(!GLEScmValidate::textureEnum(target,ctx->getMaxTexUnits()),GL_INVALID_ENUM); ctx->dispatcher().glMultiTexCoord4f(target,X2F(s),X2F(t),X2F(r),X2F(q)); } @@ -1013,8 +983,8 @@ GL_API void GL_APIENTRY glPushMatrix(void) { GL_API void GL_APIENTRY glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) { GET_CTX() - SET_ERROR_IF(!(GLESvalidate::pixelFrmt(format) && GLESvalidate::pixelType(type)),GL_INVALID_ENUM); - SET_ERROR_IF(!(GLESvalidate::pixelOp(format,type)),GL_INVALID_OPERATION); + SET_ERROR_IF(!(GLEScmValidate::pixelFrmt(format) && GLEScmValidate::pixelType(type)),GL_INVALID_ENUM); + SET_ERROR_IF(!(GLEScmValidate::pixelOp(format,type)),GL_INVALID_OPERATION); ctx->dispatcher().glReadPixels(x,y,width,height,format,type,pixels); } @@ -1076,7 +1046,7 @@ GL_API void GL_APIENTRY glStencilOp( GLenum fail, GLenum zfail, GLenum zpass) { GL_API void GL_APIENTRY glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::texCoordPointerParams(size,stride),GL_INVALID_VALUE); + SET_ERROR_IF(!GLEScmValidate::texCoordPointerParams(size,stride),GL_INVALID_VALUE); const GLvoid* data = ctx->setPointer(GL_TEXTURE_COORD_ARRAY,size,type,stride,pointer); if(type != GL_FIXED) ctx->dispatcher().glTexCoordPointer(size,type,stride,data); @@ -1084,38 +1054,38 @@ GL_API void GL_APIENTRY glTexCoordPointer( GLint size, GLenum type, GLsizei str GL_API void GL_APIENTRY glTexEnvf( GLenum target, GLenum pname, GLfloat param) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::texEnv(target,pname),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::texEnv(target,pname),GL_INVALID_ENUM); ctx->dispatcher().glTexEnvf(target,pname,param); } GL_API void GL_APIENTRY glTexEnvfv( GLenum target, GLenum pname, const GLfloat *params) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::texEnv(target,pname),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::texEnv(target,pname),GL_INVALID_ENUM); ctx->dispatcher().glTexEnvfv(target,pname,params); } GL_API void GL_APIENTRY glTexEnvi( GLenum target, GLenum pname, GLint param) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::texEnv(target,pname),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::texEnv(target,pname),GL_INVALID_ENUM); ctx->dispatcher().glTexEnvi(target,pname,param); } GL_API void GL_APIENTRY glTexEnviv( GLenum target, GLenum pname, const GLint *params) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::texEnv(target,pname),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::texEnv(target,pname),GL_INVALID_ENUM); ctx->dispatcher().glTexEnviv(target,pname,params); } GL_API void GL_APIENTRY glTexEnvx( GLenum target, GLenum pname, GLfixed param) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::texEnv(target,pname),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::texEnv(target,pname),GL_INVALID_ENUM); GLfloat tmpParam = static_cast(param); ctx->dispatcher().glTexEnvf(target,pname,tmpParam); } GL_API void GL_APIENTRY glTexEnvxv( GLenum target, GLenum pname, const GLfixed *params) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::texEnv(target,pname),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::texEnv(target,pname),GL_INVALID_ENUM); GLfloat tmpParams[4]; if(pname == GL_TEXTURE_ENV_COLOR) { @@ -1145,13 +1115,13 @@ static TextureData* getTextureData(){ GL_API void GL_APIENTRY glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { GET_CTX() - SET_ERROR_IF(!(GLESvalidate::textureTarget(target) && - GLESvalidate::pixelFrmt(internalformat) && - GLESvalidate::pixelFrmt(format)&& - GLESvalidate::pixelType(type)),GL_INVALID_ENUM); + SET_ERROR_IF(!(GLEScmValidate::textureTarget(target) && + GLEScmValidate::pixelFrmt(internalformat) && + GLEScmValidate::pixelFrmt(format)&& + GLEScmValidate::pixelType(type)),GL_INVALID_ENUM); - //SET_ERROR_IF(level < 0 || border !=0 || level > log2(ctx->getMaxTexSize()) || !GLESvalidate::texImgDim(width,height,ctx->getMaxTexSize()),GL_INVALID_VALUE); - SET_ERROR_IF(!(GLESvalidate::pixelOp(format,type) && internalformat == ((GLint)format)),GL_INVALID_OPERATION); + //SET_ERROR_IF(level < 0 || border !=0 || level > log2(ctx->getMaxTexSize()) || !GLEScmValidate::texImgDim(width,height,ctx->getMaxTexSize()),GL_INVALID_VALUE); + SET_ERROR_IF(!(GLEScmValidate::pixelOp(format,type) && internalformat == ((GLint)format)),GL_INVALID_OPERATION); if (thrd->shareGroup.Ptr()){ unsigned int tex = ctx->getBindedTexture(); @@ -1168,47 +1138,47 @@ GL_API void GL_APIENTRY glTexImage2D( GLenum target, GLint level, GLint interna GL_API void GL_APIENTRY glTexParameterf( GLenum target, GLenum pname, GLfloat param) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::texParams(target,pname),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::texParams(target,pname),GL_INVALID_ENUM); ctx->dispatcher().glTexParameterf(target,pname,param); } GL_API void GL_APIENTRY glTexParameterfv( GLenum target, GLenum pname, const GLfloat *params) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::texParams(target,pname),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::texParams(target,pname),GL_INVALID_ENUM); ctx->dispatcher().glTexParameterfv(target,pname,params); } GL_API void GL_APIENTRY glTexParameteri( GLenum target, GLenum pname, GLint param) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::texParams(target,pname),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::texParams(target,pname),GL_INVALID_ENUM); ctx->dispatcher().glTexParameteri(target,pname,param); } GL_API void GL_APIENTRY glTexParameteriv( GLenum target, GLenum pname, const GLint *params) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::texParams(target,pname),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::texParams(target,pname),GL_INVALID_ENUM); ctx->dispatcher().glTexParameteriv(target,pname,params); } GL_API void GL_APIENTRY glTexParameterx( GLenum target, GLenum pname, GLfixed param) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::texParams(target,pname),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::texParams(target,pname),GL_INVALID_ENUM); ctx->dispatcher().glTexParameterf(target,pname,static_cast(param)); } GL_API void GL_APIENTRY glTexParameterxv( GLenum target, GLenum pname, const GLfixed *params) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::texParams(target,pname),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::texParams(target,pname),GL_INVALID_ENUM); GLfloat param = static_cast(params[0]); ctx->dispatcher().glTexParameterfv(target,pname,¶m); } GL_API void GL_APIENTRY glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) { GET_CTX() - SET_ERROR_IF(!(GLESvalidate::textureTarget(target) && - GLESvalidate::pixelFrmt(format)&& - GLESvalidate::pixelType(type)),GL_INVALID_ENUM); - SET_ERROR_IF(!GLESvalidate::pixelOp(format,type),GL_INVALID_OPERATION); + SET_ERROR_IF(!(GLEScmValidate::textureTarget(target) && + GLEScmValidate::pixelFrmt(format)&& + GLEScmValidate::pixelType(type)),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::pixelOp(format,type),GL_INVALID_OPERATION); ctx->dispatcher().glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels); } @@ -1225,7 +1195,7 @@ GL_API void GL_APIENTRY glTranslatex( GLfixed x, GLfixed y, GLfixed z) { GL_API void GL_APIENTRY glVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) { GET_CTX() - SET_ERROR_IF(!GLESvalidate::vertexPointerParams(size,stride),GL_INVALID_VALUE); + SET_ERROR_IF(!GLEScmValidate::vertexPointerParams(size,stride),GL_INVALID_VALUE); const GLvoid* data = ctx->setPointer(GL_VERTEX_ARRAY,size,type,stride,pointer); if(type != GL_FIXED) ctx->dispatcher().glVertexPointer(size,type,stride,data); @@ -1239,7 +1209,7 @@ GL_API void GL_APIENTRY glViewport( GLint x, GLint y, GLsizei width, GLsizei he void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) { GET_CTX(); - SET_ERROR_IF(!GLESvalidate::textureTarget(target),GL_INVALID_ENUM); + SET_ERROR_IF(!GLEScmValidate::textureTarget(target),GL_INVALID_ENUM); EglImage *img = s_eglIface->eglAttachEGLImage((unsigned int)image); if (img) { // Create the texture object in the underlying EGL implementation, diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESutils.cpp b/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmUtils.cpp similarity index 99% rename from tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESutils.cpp rename to tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmUtils.cpp index 08c2d6a8c..891b4e366 100644 --- a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESutils.cpp +++ b/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmUtils.cpp @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "GLESutils.h" +#include "GLEScmUtils.h" size_t glParamSize(GLenum param) diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESutils.h b/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmUtils.h similarity index 100% rename from tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESutils.h rename to tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmUtils.h diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESvalidate.cpp b/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmValidate.cpp similarity index 63% rename from tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESvalidate.cpp rename to tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmValidate.cpp index 6bc211f4a..5ad8e2a4a 100644 --- a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESvalidate.cpp +++ b/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmValidate.cpp @@ -13,27 +13,24 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "GLESvalidate.h" +#include "GLEScmValidate.h" #include -bool GLESvalidate::textureEnum(GLenum e,unsigned int maxTex) { - return e >= GL_TEXTURE0 && e <= (GL_TEXTURE0 + maxTex); -} -bool GLESvalidate::lightEnum(GLenum e,unsigned int maxLights) { +bool GLEScmValidate::lightEnum(GLenum e,unsigned int maxLights) { return e >=GL_LIGHT0 && e <= (GL_LIGHT0+maxLights); } -bool GLESvalidate::clipPlaneEnum(GLenum e,unsigned int maxClipPlanes) { +bool GLEScmValidate::clipPlaneEnum(GLenum e,unsigned int maxClipPlanes) { return e >=GL_CLIP_PLANE0 && e <= (GL_CLIP_PLANE0+maxClipPlanes); } -bool GLESvalidate::textureTarget(GLenum target) { +bool GLEScmValidate::textureTarget(GLenum target) { return target == GL_TEXTURE_2D; } -bool GLESvalidate::alphaFunc(GLenum f) { +bool GLEScmValidate::alphaFunc(GLenum f) { switch(f) { case GL_NEVER: case GL_LESS: @@ -48,49 +45,20 @@ bool GLESvalidate::alphaFunc(GLenum f) { return false; } -bool GLESvalidate::blendSrc(GLenum s) { - switch(s) { - case GL_ZERO: - case GL_ONE: - case GL_DST_COLOR: - case GL_ONE_MINUS_DST_COLOR: - case GL_SRC_ALPHA: - case GL_ONE_MINUS_SRC_ALPHA: - case GL_DST_ALPHA: - case GL_ONE_MINUS_DST_ALPHA: - return true; - } - return false; -} -bool GLESvalidate::blendDst(GLenum d) { - switch(d) { - case GL_ZERO: - case GL_ONE: - case GL_SRC_COLOR: - case GL_ONE_MINUS_SRC_COLOR: - case GL_SRC_ALPHA: - case GL_ONE_MINUS_SRC_ALPHA: - case GL_DST_ALPHA: - case GL_ONE_MINUS_DST_ALPHA: - return true; - } - return false; -} - -bool GLESvalidate::vertexPointerParams(GLint size,GLsizei stride) { +bool GLEScmValidate::vertexPointerParams(GLint size,GLsizei stride) { return ((size >=2) && (size <= 4)) && (stride >=0) ; } -bool GLESvalidate::colorPointerParams(GLint size,GLsizei stride) { +bool GLEScmValidate::colorPointerParams(GLint size,GLsizei stride) { return ((size >=3) && (size <= 4)) && (stride >=0) ; } -bool GLESvalidate::texCoordPointerParams(GLint size,GLsizei stride) { +bool GLEScmValidate::texCoordPointerParams(GLint size,GLsizei stride) { return ((size >=1) && (size <= 4)) && (stride >=0) ; } -bool GLESvalidate::supportedArrays(GLenum arr) { +bool GLEScmValidate::supportedArrays(GLenum arr) { switch(arr) { case GL_COLOR_ARRAY: case GL_NORMAL_ARRAY: @@ -102,25 +70,8 @@ bool GLESvalidate::supportedArrays(GLenum arr) { return false; } -bool GLESvalidate::drawMode(GLenum mode) { - switch(mode) { - case GL_POINTS: - case GL_LINE_STRIP: - case GL_LINE_LOOP: - case GL_LINES: - case GL_TRIANGLE_STRIP: - case GL_TRIANGLE_FAN: - case GL_TRIANGLES: - return true; - } - return false; -} -bool GLESvalidate::drawType(GLenum mode) { - return mode == GL_UNSIGNED_BYTE || mode == GL_UNSIGNED_SHORT; -} - -bool GLESvalidate::hintTargetMode(GLenum target,GLenum mode) { +bool GLEScmValidate::hintTargetMode(GLenum target,GLenum mode) { switch(target) { case GL_FOG_HINT: case GL_GENERATE_MIPMAP_HINT: @@ -140,7 +91,7 @@ bool GLESvalidate::hintTargetMode(GLenum target,GLenum mode) { return true; } -bool GLESvalidate::texParams(GLenum target,GLenum pname) { +bool GLEScmValidate::texParams(GLenum target,GLenum pname) { switch(pname) { case GL_TEXTURE_MIN_FILTER: case GL_TEXTURE_MAG_FILTER: @@ -153,7 +104,7 @@ bool GLESvalidate::texParams(GLenum target,GLenum pname) { return target == GL_TEXTURE_2D; } -bool GLESvalidate::texEnv(GLenum target,GLenum pname) { +bool GLEScmValidate::texEnv(GLenum target,GLenum pname) { switch(pname) { case GL_TEXTURE_ENV_MODE: case GL_COMBINE_RGB: @@ -180,7 +131,7 @@ bool GLESvalidate::texEnv(GLenum target,GLenum pname) { return (target == GL_TEXTURE_ENV || target == GL_POINT_SPRITE_OES); } -bool GLESvalidate::capability(GLenum cap,int maxLights,int maxClipPlanes) { +bool GLEScmValidate::capability(GLenum cap,int maxLights,int maxClipPlanes) { switch(cap) { case GL_ALPHA_TEST: case GL_BLEND: @@ -211,33 +162,12 @@ bool GLESvalidate::capability(GLenum cap,int maxLights,int maxClipPlanes) { case GL_VERTEX_ARRAY: return true; } - return GLESvalidate::lightEnum(cap,maxLights) || GLESvalidate::clipPlaneEnum(cap,maxClipPlanes); + return GLEScmValidate::lightEnum(cap,maxLights) || GLEScmValidate::clipPlaneEnum(cap,maxClipPlanes); } -bool GLESvalidate::pixelType(GLenum type) { - switch(type) { - case GL_UNSIGNED_BYTE: - case GL_UNSIGNED_SHORT_5_6_5: - case GL_UNSIGNED_SHORT_4_4_4_4: - case GL_UNSIGNED_SHORT_5_5_5_1: - return true; - } - return false; -} -bool GLESvalidate::pixelFrmt(GLenum format) { - switch(format) { - case GL_ALPHA: - case GL_RGB: - case GL_RGBA: - case GL_LUMINANCE: - case GL_LUMINANCE_ALPHA: - return true; - } - return false; -} -bool GLESvalidate::texCompImgFrmt(GLenum format) { +bool GLEScmValidate::texCompImgFrmt(GLenum format) { switch(format) { case GL_PALETTE4_RGB8_OES: case GL_PALETTE4_RGBA8_OES: @@ -254,28 +184,42 @@ bool GLESvalidate::texCompImgFrmt(GLenum format) { return false; } -bool GLESvalidate::pixelOp(GLenum format,GLenum type) { - switch(type) { - case GL_UNSIGNED_SHORT_4_4_4_4: - case GL_UNSIGNED_SHORT_5_5_5_1: - return format == GL_RGBA; - case GL_UNSIGNED_SHORT_5_6_5: - return format == GL_RGB; - } - return true; -} -bool GLESvalidate::texImgDim(GLsizei width,GLsizei height,int maxTexSize) { +bool GLEScmValidate::texImgDim(GLsizei width,GLsizei height,int maxTexSize) { if( width < 0 || height < 0 || width > maxTexSize || height > maxTexSize) return false; return isPowerOf2(width) && isPowerOf2(height); } -bool GLESvalidate::bufferTarget(GLenum target) { - return target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER; + + +bool GLEScmValidate::blendSrc(GLenum s) { + switch(s) { + case GL_ZERO: + case GL_ONE: + case GL_DST_COLOR: + case GL_ONE_MINUS_DST_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + return true; + } + return false; } -bool GLESvalidate::bufferParam(GLenum param) { - return (param == GL_BUFFER_SIZE) || (param == GL_BUFFER_USAGE); +bool GLEScmValidate::blendDst(GLenum d) { + switch(d) { + case GL_ZERO: + case GL_ONE: + case GL_SRC_COLOR: + case GL_ONE_MINUS_SRC_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + return true; + } + return false; } diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESvalidate.h b/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmValidate.h similarity index 78% rename from tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESvalidate.h rename to tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmValidate.h index a4f785bf9..81e48c718 100644 --- a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESvalidate.h +++ b/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScmValidate.h @@ -13,38 +13,29 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef GLES_VALIDATE_H -#define GLES_VALIDATE_H +#ifndef GLES_CM_VALIDATE_H +#define GLES_CM_VALIDATE_H #include - -struct GLESvalidate +#include +struct GLEScmValidate : public GLESvalidate { - +static bool blendSrc(GLenum s); +static bool blendDst(GLenum d); static bool lightEnum(GLenum e,unsigned int maxLIghts); static bool clipPlaneEnum(GLenum e,unsigned int maxClipPlanes); static bool alphaFunc(GLenum f); -static bool blendSrc(GLenum s); -static bool blendDst(GLenum d); static bool vertexPointerParams(GLint size,GLsizei stride); static bool colorPointerParams(GLint size,GLsizei stride); static bool supportedArrays(GLenum arr); -static bool drawMode(GLenum mode); -static bool drawType(GLenum mode); static bool hintTargetMode(GLenum target,GLenum mode); static bool capability(GLenum cap,int maxLights,int maxClipPlanes); static bool texParams(GLenum target,GLenum pname); static bool texCoordPointerParams(GLint size,GLsizei stride); static bool textureTarget(GLenum target); -static bool textureEnum(GLenum e,unsigned int maxTex); static bool texEnv(GLenum target,GLenum pname); -static bool pixelFrmt(GLenum format); -static bool pixelType(GLenum type); -static bool pixelOp(GLenum format,GLenum type); static bool texCompImgFrmt(GLenum format); static bool texImgDim(GLsizei width,GLsizei height,int maxTexSize); -static bool bufferTarget(GLenum target); -static bool bufferParam(GLenum param); }; #endif diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_V2/Android.mk b/tools/emulator/opengl/host/libs/Translator/GLES_V2/Android.mk new file mode 100644 index 000000000..75c33b4af --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/GLES_V2/Android.mk @@ -0,0 +1,29 @@ +LOCAL_PATH := $(call my-dir) + +### GLES_CM host implementation (On top of OpenGL) ######################## +include $(CLEAR_VARS) + +translator_path := $(LOCAL_PATH)/.. +#exclude darwin builds +ifeq (, $(findstring $(HOST_OS), darwin)) + +LOCAL_SRC_FILES := \ + GLESv2Context.cpp \ + GLESv2Validate.cpp \ + GLESv2Imp.cpp + +LOCAL_C_INCLUDES += \ + $(translator_path)/include \ + + +LOCAL_SHARED_LIBRARIES := \ + libGLcommon + +LOCAL_CFLAGS := -g -O0 +LOCAL_MODULE_TAGS := debug +LOCAL_MODULE := libGLES_V2_translator + + +include $(BUILD_HOST_SHARED_LIBRARY) + +endif diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Context.cpp b/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Context.cpp new file mode 100644 index 000000000..4fd3b0ad8 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Context.cpp @@ -0,0 +1,55 @@ +/* +* 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 "GLESv2Context.h" +GLv2Support GLESv2Context::s_glSupport; + +void GLESv2Context::init() { + android::Mutex::Autolock mutex(s_lock); + if(!m_initialized) { + int maxTexUnits; + s_glDispatch.dispatchFuncs(GLES_2_0); + s_glDispatch.glGetIntegerv(GL_MAX_VERTEX_ATTRIBS,&s_glSupport.maxVertexAttribs); + s_glDispatch.glGetIntegerv(GL_MAX_TEXTURE_UNITS,&maxTexUnits); + s_glSupport.maxTexUnits = maxTexUnits < MAX_TEX_UNITS ? maxTexUnits:MAX_TEX_UNITS; + + for(int i=0; i < s_glSupport.maxVertexAttribs;i++){ + m_map[i] = new GLESpointer(); + } + } + + m_initialized = true; +} + +GLESv2Context::GLESv2Context():GLEScontext(){}; + +void GLESv2Context::convertArrs(GLESFloatArrays& fArrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices,bool direct) { + ArraysMap::iterator it; + unsigned int index = 0; + + //going over all clients arrays Pointers + for ( it=m_map.begin() ; it != m_map.end(); it++ ) { + GLenum array_id = (*it).first; + GLESpointer* p = (*it).second; + + chooseConvertMethod(fArrs,first,count,type,indices,direct,p,array_id,index); + } +} + +//sending data to server side +void GLESv2Context::sendArr(GLvoid* arr,GLenum arrayType,GLint size,GLsizei stride,int index) { + s_glDispatch.glVertexAttribPointer(arrayType,size,GL_FLOAT,GL_FALSE,stride,arr); +} diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Context.h b/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Context.h new file mode 100644 index 000000000..ddf882863 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Context.h @@ -0,0 +1,45 @@ +#ifndef GLES_V2_CONTEXT_H +#define GLES_V2_CONTEXT_H + +/* +* 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 +#include +#include +#include + + +struct GLv2Support { + GLv2Support():maxTexUnits(0),maxVertexAttribs(0){}; + int maxTexUnits; + int maxVertexAttribs; +}; + +class GLESv2Context : public GLEScontext{ +public: + void init(); + GLESv2Context(); + void convertArrs(GLESFloatArrays& fArrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices,bool direct); + static unsigned int getMaxTexUnits(){return s_glSupport.maxTexUnits;}; +private: + void sendArr(GLvoid* arr,GLenum arrayType,GLint size,GLsizei stride,int pointsIndex = -1); + + static GLv2Support s_glSupport; + +}; + +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Imp.cpp b/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Imp.cpp new file mode 100644 index 000000000..a8fb0782d --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Imp.cpp @@ -0,0 +1,1204 @@ +/* +* Copyright(C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0(the "License"){ GET_CTX();} +* 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. +*/ + +#ifdef _WIN32 +#undef GL_APICALL +#define GL_APICALL __declspec(dllexport) +#endif + +#include +#include +#include +#include +#include +#include "GLESv2Context.h" +#include "GLESv2Validate.h" + +extern "C" { + +//decleration +static void initContext(GLEScontext* ctx); +static void deleteGLESContext(GLEScontext* ctx); +static void setShareGroup(GLEScontext* ctx,ShareGroupPtr grp); +static GLEScontext* createGLESContext(); +static __translatorMustCastToProperFunctionPointerType getProcAddress(const char* procName); + +} + +static EGLiface* s_eglIface = NULL; +static GLESiface s_glesIface = { + createGLESContext:createGLESContext, + initContext :initContext, + deleteGLESContext:deleteGLESContext, + flush :(FUNCPTR)glFlush, + finish :(FUNCPTR)glFinish, + setShareGroup :setShareGroup, + getProcAddress :getProcAddress +}; + +#include + +extern "C" { + +static void initContext(GLEScontext* ctx) { + ctx->init(); +} +static GLEScontext* createGLESContext() { + return new GLESv2Context(); +} + +static void deleteGLESContext(GLEScontext* ctx) { + delete ctx; +} + +static void setShareGroup(GLEScontext* ctx,ShareGroupPtr grp) { + if(ctx) { + ctx->setShareGroup(grp); + } +} + +static __translatorMustCastToProperFunctionPointerType getProcAddress(const char* procName) { + return NULL; +} + +GL_APICALL GLESiface* __translator_getIfaces(EGLiface* eglIface){ + s_eglIface = eglIface; + return & s_glesIface; +} + +} + +GL_APICALL void GL_APIENTRY glActiveTexture(GLenum texture){ + GET_CTX_V2(); + SET_ERROR_IF (!GLESv2Validate::textureEnum(texture,ctx->getMaxTexUnits()),GL_INVALID_ENUM); + ctx->setActiveTexture(texture); + ctx->dispatcher().glActiveTexture(texture); +} + +GL_APICALL void GL_APIENTRY glAttachShader(GLuint program, GLuint shader){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalProgramName = thrd->shareGroup->getGlobalName(PROGRAM,program); + const GLuint globalShaderName = thrd->shareGroup->getGlobalName(SHADER,shader); + ctx->dispatcher().glAttachShader(globalProgramName,globalShaderName); + } +} + +GL_APICALL void GL_APIENTRY glBindAttribLocation(GLuint program, GLuint index, const GLchar* name){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalProgramName = thrd->shareGroup->getGlobalName(PROGRAM,program); + ctx->dispatcher().glBindAttribLocation(globalProgramName,index,name); + } +} + +GL_APICALL void GL_APIENTRY glBindBuffer(GLenum target, GLuint buffer){ + GET_CTX(); + SET_ERROR_IF(!GLESv2Validate::bufferTarget(target),GL_INVALID_ENUM); + //if buffer wasn't generated before,generate one + if(thrd->shareGroup.Ptr() && !thrd->shareGroup->isObject(VERTEXBUFFER,buffer)){ + thrd->shareGroup->genName(VERTEXBUFFER,buffer); + thrd->shareGroup->setObjectData(VERTEXBUFFER,buffer,ObjectDataPtr(new GLESbuffer())); + } + ctx->bindBuffer(target,buffer); + GLESbuffer* vbo = (GLESbuffer*)thrd->shareGroup->getObjectData(VERTEXBUFFER,buffer).Ptr(); + vbo->wasBinded(); +} + +GL_APICALL void GL_APIENTRY glBindFramebuffer(GLenum target, GLuint framebuffer){ + GET_CTX(); + SET_ERROR_IF(!GLESv2Validate::framebufferTarget(target),GL_INVALID_ENUM); + + GLuint globalFrameBufferName = framebuffer; + if(framebuffer && thrd->shareGroup.Ptr()){ + globalFrameBufferName = thrd->shareGroup->getGlobalName(FRAMEBUFFER,framebuffer); + //if framebuffer wasn't generated before,generate one + if(!globalFrameBufferName){ + thrd->shareGroup->genName(FRAMEBUFFER,framebuffer); + globalFrameBufferName = thrd->shareGroup->getGlobalName(FRAMEBUFFER,framebuffer); + } + } + ctx->dispatcher().glBindFramebuffer(target,globalFrameBufferName); +} + +GL_APICALL void GL_APIENTRY glBindRenderbuffer(GLenum target, GLuint renderbuffer){ + GET_CTX(); + SET_ERROR_IF(!GLESv2Validate::renderbufferTarget(target),GL_INVALID_ENUM); + + GLuint globalRenderBufferName = renderbuffer; + if(renderbuffer && thrd->shareGroup.Ptr()){ + globalRenderBufferName = thrd->shareGroup->getGlobalName(RENDERBUFFER,renderbuffer); + //if renderbuffer wasn't generated before,generate one + if(!globalRenderBufferName){ + thrd->shareGroup->genName(RENDERBUFFER,renderbuffer); + globalRenderBufferName = thrd->shareGroup->getGlobalName(RENDERBUFFER,renderbuffer); + } + } + ctx->dispatcher().glBindRenderbuffer(target,globalRenderBufferName); +} + +GL_APICALL void GL_APIENTRY glBindTexture(GLenum target, GLuint texture){ + GET_CTX(); + SET_ERROR_IF(!GLESv2Validate::textureTarget(target),GL_INVALID_ENUM) + + GLuint globalTextureName = texture; + if(texture && thrd->shareGroup.Ptr()){ + globalTextureName = thrd->shareGroup->getGlobalName(TEXTURE,texture); + //if texture wasn't generated before,generate one + if(!globalTextureName){ + thrd->shareGroup->genName(TEXTURE,texture); + globalTextureName = thrd->shareGroup->getGlobalName(TEXTURE,texture); + } + } + ctx->setBindedTexture(globalTextureName); + ctx->dispatcher().glBindTexture(target,globalTextureName); +} + +GL_APICALL void GL_APIENTRY glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha){ + GET_CTX(); + ctx->dispatcher().glBlendColor(red,green,blue,alpha); +} + +GL_APICALL void GL_APIENTRY glBlendEquation( GLenum mode ){ + GET_CTX(); + SET_ERROR_IF(!GLESv2Validate::blendEquationMode(mode),GL_INVALID_ENUM) + ctx->dispatcher().glBlendEquation(mode); +} + +GL_APICALL void GL_APIENTRY glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha){ + GET_CTX(); + SET_ERROR_IF(!(GLESv2Validate::blendEquationMode(modeRGB) && GLESv2Validate::blendEquationMode(modeAlpha)),GL_INVALID_ENUM); + ctx->dispatcher().glBlendEquationSeparate(modeRGB,modeAlpha); +} + +GL_APICALL void GL_APIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor){ + GET_CTX(); + SET_ERROR_IF(!GLESv2Validate::blendSrc(sfactor) || !GLESv2Validate::blendDst(dfactor),GL_INVALID_ENUM) + ctx->dispatcher().glBlendFunc(sfactor,dfactor); +} + +GL_APICALL void GL_APIENTRY glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha){ + GET_CTX(); + SET_ERROR_IF( +!(GLESv2Validate::blendSrc(srcRGB) && GLESv2Validate::blendDst(dstRGB) && GLESv2Validate::blendSrc(srcAlpha) && GLESv2Validate::blendDst(dstAlpha)),GL_INVALID_ENUM); + ctx->dispatcher().glBlendFuncSeparate(srcRGB,dstRGB,srcAlpha,dstAlpha); +} + +GL_APICALL void GL_APIENTRY glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage){ + GET_CTX(); + SET_ERROR_IF(!GLESv2Validate::bufferTarget(target),GL_INVALID_ENUM); + SET_ERROR_IF(!ctx->isBindedBuffer(target),GL_INVALID_OPERATION); + ctx->setBufferData(target,size,data,usage); +} + +GL_APICALL void GL_APIENTRY glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data){ + GET_CTX(); + SET_ERROR_IF(!ctx->isBindedBuffer(target),GL_INVALID_OPERATION); + SET_ERROR_IF(!GLESv2Validate::bufferTarget(target),GL_INVALID_ENUM); + SET_ERROR_IF(!ctx->setBufferSubData(target,offset,size,data),GL_INVALID_VALUE); +} + + +GL_APICALL GLenum GL_APIENTRY glCheckFramebufferStatus(GLenum target){ + GET_CTX_RET(GL_FRAMEBUFFER_COMPLETE); + RET_AND_SET_ERROR_IF(!GLESv2Validate::framebufferTarget(target),GL_INVALID_ENUM,GL_FRAMEBUFFER_COMPLETE); + return ctx->dispatcher().glCheckFramebufferStatus(target); +} + +GL_APICALL void GL_APIENTRY glClear(GLbitfield mask){ + GET_CTX(); + ctx->dispatcher().glClear(mask); +} +GL_APICALL void GL_APIENTRY glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha){ + GET_CTX(); + ctx->dispatcher().glClearColor(red,green,blue,alpha); +} +GL_APICALL void GL_APIENTRY glClearDepthf(GLclampf depth){ + GET_CTX(); + ctx->dispatcher().glClearDepth(depth); +} +GL_APICALL void GL_APIENTRY glClearStencil(GLint s){ + GET_CTX(); + ctx->dispatcher().glClearStencil(s); +} +GL_APICALL void GL_APIENTRY glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha){ + GET_CTX(); + ctx->dispatcher().glColorMask(red,green,blue,alpha); +} + +GL_APICALL void GL_APIENTRY glCompileShader(GLuint shader){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalShaderName = thrd->shareGroup->getGlobalName(SHADER,shader); + ctx->dispatcher().glCompileShader(globalShaderName); + } +} + +GL_APICALL void GL_APIENTRY glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data){ + GET_CTX(); + SET_ERROR_IF(!GLESv2Validate::textureTargetEx(target),GL_INVALID_ENUM); + SET_ERROR_IF(border != 0 , GL_INVALID_VALUE); + ctx->dispatcher().glCompressedTexImage2D(target,level,internalformat,width,height,border,imageSize,data); +} + +GL_APICALL void GL_APIENTRY glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data){ + GET_CTX(); + SET_ERROR_IF(!GLESv2Validate::textureTargetEx(target),GL_INVALID_ENUM); + ctx->dispatcher().glCompressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,imageSize,data); +} + +GL_APICALL void GL_APIENTRY glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border){ + GET_CTX(); + SET_ERROR_IF(!(GLESv2Validate::pixelFrmt(internalformat) && GLESv2Validate::textureTargetEx(target)),GL_INVALID_ENUM); + SET_ERROR_IF(border != 0,GL_INVALID_VALUE); + ctx->dispatcher().glCopyTexImage2D(target,level,internalformat,x,y,width,height,border); +} + +GL_APICALL void GL_APIENTRY glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height){ + GET_CTX(); + SET_ERROR_IF(!GLESv2Validate::textureTargetEx(target),GL_INVALID_ENUM); + ctx->dispatcher().glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height); +} + +GL_APICALL GLuint GL_APIENTRY glCreateProgram(void){ + GET_CTX_RET(0); + const GLuint globalProgramName = ctx->dispatcher().glCreateProgram(); + if(thrd->shareGroup.Ptr() && globalProgramName) { + const GLuint localProgramName = thrd->shareGroup->genName(PROGRAM); + thrd->shareGroup->replaceGlobalName(PROGRAM,localProgramName,globalProgramName); + return localProgramName; + } + if(globalProgramName){ + ctx->dispatcher().glDeleteProgram(globalProgramName); + } + return 0; +} + +GL_APICALL GLuint GL_APIENTRY glCreateShader(GLenum type){ + GET_CTX_RET(0); + const GLuint globalShaderName = ctx->dispatcher().glCreateShader(type); + if(thrd->shareGroup.Ptr() && globalShaderName) { + const GLuint localShaderName = thrd->shareGroup->genName(SHADER); + thrd->shareGroup->replaceGlobalName(SHADER,localShaderName,globalShaderName); + return localShaderName; + } + if(globalShaderName){ + ctx->dispatcher().glDeleteShader(globalShaderName); + } + return 0; +} + +GL_APICALL void GL_APIENTRY glCullFace(GLenum mode){ + GET_CTX(); + ctx->dispatcher().glCullFace(mode); +} + +GL_APICALL void GL_APIENTRY glDeleteBuffers(GLsizei n, const GLuint* buffers){ + GET_CTX(); + SET_ERROR_IF(n<0,GL_INVALID_VALUE); + if(thrd->shareGroup.Ptr()) { + for(int i=0; i < n; i++){ + thrd->shareGroup->deleteName(VERTEXBUFFER,buffers[i]); + } + } +} + +GL_APICALL void GL_APIENTRY glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers){ + GET_CTX(); + SET_ERROR_IF(n<0,GL_INVALID_VALUE); + if(thrd->shareGroup.Ptr()) { + for(int i=0; i < n; i++){ + const GLuint globalFrameBufferName = thrd->shareGroup->getGlobalName(FRAMEBUFFER,framebuffers[i]); + thrd->shareGroup->deleteName(FRAMEBUFFER,framebuffers[i]); + ctx->dispatcher().glDeleteFramebuffers(1,&globalFrameBufferName); + } + } +} + +GL_APICALL void GL_APIENTRY glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers){ + GET_CTX(); + SET_ERROR_IF(n<0,GL_INVALID_VALUE); + if(thrd->shareGroup.Ptr()) { + for(int i=0; i < n; i++){ + const GLuint globalRenderBufferName = thrd->shareGroup->getGlobalName(RENDERBUFFER,renderbuffers[i]); + thrd->shareGroup->deleteName(RENDERBUFFER,renderbuffers[i]); + ctx->dispatcher().glDeleteRenderbuffers(1,&globalRenderBufferName); + } + } +} + +GL_APICALL void GL_APIENTRY glDeleteTextures(GLsizei n, const GLuint* textures){ + GET_CTX(); + SET_ERROR_IF(n<0,GL_INVALID_VALUE); + if(thrd->shareGroup.Ptr()) { + for(int i=0; i < n; i++){ + const GLuint globalTextureName = thrd->shareGroup->getGlobalName(TEXTURE,textures[i]); + thrd->shareGroup->deleteName(TEXTURE,textures[i]); + ctx->dispatcher().glDeleteTextures(1,&globalTextureName); + } + } +} + +GL_APICALL void GL_APIENTRY glDeleteProgram(GLuint program){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalProgramName = thrd->shareGroup->getGlobalName(PROGRAM,program); + ctx->dispatcher().glDeleteProgram(program); + } +} + +GL_APICALL void GL_APIENTRY glDeleteShader(GLuint shader){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalShaderName = thrd->shareGroup->getGlobalName(SHADER,shader); + ctx->dispatcher().glDeleteShader(shader); + } +} + +GL_APICALL void GL_APIENTRY glDepthFunc(GLenum func){ + GET_CTX(); + ctx->dispatcher().glDepthFunc(func); +} +GL_APICALL void GL_APIENTRY glDepthMask(GLboolean flag){ + GET_CTX(); + ctx->dispatcher().glDepthMask(flag); +} +GL_APICALL void GL_APIENTRY glDepthRangef(GLclampf zNear, GLclampf zFar){ + GET_CTX(); + ctx->dispatcher().glDepthRange(zNear,zFar); +} + +GL_APICALL void GL_APIENTRY glDetachShader(GLuint program, GLuint shader){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalProgramName = thrd->shareGroup->getGlobalName(PROGRAM,program); + const GLuint globalShaderName = thrd->shareGroup->getGlobalName(SHADER,shader); + ctx->dispatcher().glDetachShader(globalProgramName,globalShaderName); + } +} + +GL_APICALL void GL_APIENTRY glDisable(GLenum cap){ + GET_CTX(); + ctx->dispatcher().glDisable(cap); +} + +GL_APICALL void GL_APIENTRY glDisableVertexAttribArray(GLuint index){ + GET_CTX(); + ctx->enableArr(index,false); + ctx->dispatcher().glDisableVertexAttribArray(index); +} + + +GL_APICALL void GL_APIENTRY glDrawArrays(GLenum mode, GLint first, GLsizei count){ + GET_CTX(); + SET_ERROR_IF(count < 0,GL_INVALID_VALUE) + SET_ERROR_IF(!GLESv2Validate::drawMode(mode),GL_INVALID_ENUM); + + //if no vertex are enabled no need to convert anything + if(!ctx->isArrEnabled(0)) return; + + GLESFloatArrays tmpArrs; + ctx->convertArrs(tmpArrs,first,count,0,NULL,true); + ctx->dispatcher().glDrawArrays(mode,first,count); +} + +GL_APICALL void GL_APIENTRY glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* elementsIndices){ + GET_CTX(); + SET_ERROR_IF(count < 0,GL_INVALID_VALUE) + SET_ERROR_IF(!(GLESv2Validate::drawMode(mode) && GLESv2Validate::drawType(type)),GL_INVALID_ENUM); + + const GLvoid* indices = elementsIndices; + if(ctx->isBindedBuffer(GL_ELEMENT_ARRAY_BUFFER)) { // if vbo is binded take the indices from the vbo + const unsigned char* buf = static_cast(ctx->getBindedBuffer(GL_ELEMENT_ARRAY_BUFFER)); + indices = buf+reinterpret_cast(elementsIndices); + } + + //if no vertex are enabled no need to convert anything + if(!ctx->isArrEnabled(0)) return; + + GLESFloatArrays tmpArrs; + ctx->convertArrs(tmpArrs,0,count,type,indices,false); + ctx->dispatcher().glDrawElements(mode,count,type,indices); +} + +GL_APICALL void GL_APIENTRY glEnable(GLenum cap){ + GET_CTX(); + ctx->dispatcher().glEnable(cap); +} + +GL_APICALL void GL_APIENTRY glEnableVertexAttribArray(GLuint index){ + GET_CTX(); + ctx->enableArr(index,true); + ctx->dispatcher().glEnableVertexAttribArray(index); +} + +GL_APICALL void GL_APIENTRY glFinish(void){ + GET_CTX(); + ctx->dispatcher().glFinish(); +} +GL_APICALL void GL_APIENTRY glFlush(void){ + GET_CTX(); + ctx->dispatcher().glFlush(); +} + + +GL_APICALL void GL_APIENTRY glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer){ + GET_CTX(); + SET_ERROR_IF(!(GLESv2Validate::framebufferTarget(target) && + GLESv2Validate::renderbufferTarget(renderbuffertarget) && + GLESv2Validate::framebufferAttachment(attachment)),GL_INVALID_ENUM); + + if(thrd->shareGroup.Ptr()) { + GLuint globalRenderbufferName = thrd->shareGroup->getGlobalName(RENDERBUFFER,renderbuffer); + ctx->dispatcher().glFramebufferRenderbuffer(target,attachment,renderbuffertarget,globalRenderbufferName); + } + +} + +GL_APICALL void GL_APIENTRY glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level){ + GET_CTX(); + SET_ERROR_IF(!(GLESv2Validate::framebufferTarget(target) && + GLESv2Validate::textureTargetEx(textarget) && + GLESv2Validate::framebufferAttachment(attachment)),GL_INVALID_ENUM); + SET_ERROR_IF(level != 0, GL_INVALID_VALUE); + + if(thrd->shareGroup.Ptr()) { + GLuint globalTextureName = thrd->shareGroup->getGlobalName(TEXTURE,texture); + ctx->dispatcher().glFramebufferTexture2D(target,attachment,textarget,texture,level); + } +} + + +GL_APICALL void GL_APIENTRY glFrontFace(GLenum mode){ + GET_CTX(); + ctx->dispatcher().glFrontFace(mode); +} + +GL_APICALL void GL_APIENTRY glGenBuffers(GLsizei n, GLuint* buffers){ + GET_CTX(); + SET_ERROR_IF(n<0,GL_INVALID_VALUE); + if(thrd->shareGroup.Ptr()) { + for(int i=0; ishareGroup->genName(VERTEXBUFFER); + //generating vbo object related to this buffer name + thrd->shareGroup->setObjectData(VERTEXBUFFER,buffers[i],ObjectDataPtr(new GLESbuffer())); + } + } +} + +GL_APICALL void GL_APIENTRY glGenerateMipmap(GLenum target){ + GET_CTX(); + SET_ERROR_IF(!GLESv2Validate::textureTarget(target),GL_INVALID_ENUM); + ctx->dispatcher().glGenerateMipmap(target); +} + +GL_APICALL void GL_APIENTRY glGenFramebuffers(GLsizei n, GLuint* framebuffers){ + GET_CTX(); + SET_ERROR_IF(n<0,GL_INVALID_VALUE); + if(thrd->shareGroup.Ptr()) { + for(int i=0; ishareGroup->genName(FRAMEBUFFER); + } + } +} + +GL_APICALL void GL_APIENTRY glGenRenderbuffers(GLsizei n, GLuint* renderbuffers){ + GET_CTX(); + SET_ERROR_IF(n<0,GL_INVALID_VALUE); + if(thrd->shareGroup.Ptr()) { + for(int i=0; ishareGroup->genName(RENDERBUFFER); + } + } +} + +GL_APICALL void GL_APIENTRY glGenTextures(GLsizei n, GLuint* textures){ + GET_CTX(); + SET_ERROR_IF(n<0,GL_INVALID_VALUE); + if(thrd->shareGroup.Ptr()) { + for(int i=0; ishareGroup->genName(TEXTURE); + } + } +} + +GL_APICALL void GL_APIENTRY glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalProgramName = thrd->shareGroup->getGlobalName(PROGRAM,program); + ctx->dispatcher().glGetActiveAttrib(globalProgramName,index,bufsize,length,size,type,name); + } +} + +GL_APICALL void GL_APIENTRY glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalProgramName = thrd->shareGroup->getGlobalName(PROGRAM,program); + ctx->dispatcher().glGetActiveUniform(globalProgramName,index,bufsize,length,size,type,name); + } +} + +GL_APICALL void GL_APIENTRY glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalProgramName = thrd->shareGroup->getGlobalName(PROGRAM,program); + ctx->dispatcher().glGetAttachedShaders(globalProgramName,maxcount,count,shaders); + for(int i=0 ; i < *count ;i++){ + shaders[i] = thrd->shareGroup->getLocalName(SHADER,shaders[i]); + } + } +} + +GL_APICALL int GL_APIENTRY glGetAttribLocation(GLuint program, const GLchar* name){ + GET_CTX_RET(-1); + if(thrd->shareGroup.Ptr()) { + const GLuint globalProgramName = thrd->shareGroup->getGlobalName(PROGRAM,program); + return ctx->dispatcher().glGetAttribLocation(globalProgramName,name); + } + return -1; +} + +GL_APICALL void GL_APIENTRY glGetBooleanv(GLenum pname, GLboolean* params){ + GET_CTX(); + ctx->dispatcher().glGetBooleanv(pname,params); +} + +GL_APICALL void GL_APIENTRY glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params){ + GET_CTX(); + SET_ERROR_IF(!(GLESv2Validate::bufferTarget(target) && GLESv2Validate::bufferParam(pname)),GL_INVALID_ENUM); + SET_ERROR_IF(!ctx->isBindedBuffer(target),GL_INVALID_OPERATION); + bool ret = true; + switch(pname) { + case GL_BUFFER_SIZE: + ctx->getBufferSize(target,params); + break; + case GL_BUFFER_USAGE: + ctx->getBufferUsage(target,params); + break; + } +} + + +GL_APICALL GLenum GL_APIENTRY glGetError(void){ + GET_CTX_RET(GL_NO_ERROR) + GLenum err = ctx->getGLerror(); + if(err != GL_NO_ERROR) { + ctx->setGLerror(GL_NO_ERROR); + return err; + } + return ctx->dispatcher().glGetError(); +} + +GL_APICALL void GL_APIENTRY glGetFloatv(GLenum pname, GLfloat* params){ + GET_CTX(); + ctx->dispatcher().glGetFloatv(pname,params); +} + +GL_APICALL void GL_APIENTRY glGetIntegerv(GLenum pname, GLint* params){ + GET_CTX(); + ctx->dispatcher().glGetIntegerv(pname,params); +} + +GL_APICALL void GL_APIENTRY glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params){ + GET_CTX(); + SET_ERROR_IF(!(GLESv2Validate::framebufferTarget(target) && + GLESv2Validate::framebufferAttachment(attachment) && + GLESv2Validate::framebufferAttachmentParams(pname)),GL_INVALID_ENUM); + ctx->dispatcher().glGetFramebufferAttachmentParameteriv(target,attachment,pname,params); +} + +GL_APICALL void GL_APIENTRY glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params){ + GET_CTX(); + SET_ERROR_IF(!(GLESv2Validate::renderbufferTarget(target) && GLESv2Validate::renderbufferParams(pname)),GL_INVALID_ENUM); + ctx->dispatcher().glGetRenderbufferParameteriv(target,pname,params); +} + + +GL_APICALL void GL_APIENTRY glGetProgramiv(GLuint program, GLenum pname, GLint* params){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalProgramName = thrd->shareGroup->getGlobalName(PROGRAM,program); + ctx->dispatcher().glGetProgramiv(globalProgramName,pname,params); + } +} + +GL_APICALL void GL_APIENTRY glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalProgramName = thrd->shareGroup->getGlobalName(PROGRAM,program); + ctx->dispatcher().glGetProgramInfoLog(globalProgramName,bufsize,length,infolog); + } +} + +GL_APICALL void GL_APIENTRY glGetShaderiv(GLuint shader, GLenum pname, GLint* params){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalShaderName = thrd->shareGroup->getGlobalName(SHADER,shader); + ctx->dispatcher().glGetShaderiv(globalShaderName,pname,params); + } +} + +GL_APICALL void GL_APIENTRY glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalShaderName = thrd->shareGroup->getGlobalName(SHADER,shader); + ctx->dispatcher().glGetShaderInfoLog(globalShaderName,bufsize,length,infolog); + } +} + +GL_APICALL void GL_APIENTRY glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision){ + GET_CTX(); + ctx->dispatcher().glGetShaderPrecisionFormat(shadertype,precisiontype,range,precision); +} + +//TODO: may need to convert the source to fit to gles 2.0 shadders +GL_APICALL void GL_APIENTRY glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalShaderName = thrd->shareGroup->getGlobalName(SHADER,shader); + ctx->dispatcher().glGetShaderSource(globalShaderName,bufsize,length,source); + //now need to convert it to match gles syntax + } +} + + +GL_APICALL const GLubyte* GL_APIENTRY glGetString(GLenum name){ + GET_CTX_RET(NULL) + static GLubyte VENDOR[] = "Google"; + static GLubyte RENDERER[] = "OpenGL ES 2.0"; + static GLubyte VERSION[] = "OpenGL ES 2.0"; + static GLubyte EXTENSIONS[] = ""; + static GLubyte SHADING[] = "OpenGL ES GLSL ES 1.0.17"; + switch(name) { + case GL_VENDOR: + return VENDOR; + case GL_RENDERER: + return RENDERER; + case GL_VERSION: + return VERSION; + case GL_SHADING_LANGUAGE_VERSION: + return SHADING; + case GL_EXTENSIONS: + return EXTENSIONS; + default: + RET_AND_SET_ERROR_IF(true,GL_INVALID_ENUM,NULL); + } +} + +GL_APICALL void GL_APIENTRY glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params){ + GET_CTX(); + SET_ERROR_IF(!(GLESv2Validate::textureTarget(target) && GLESv2Validate::textureParams(pname)),GL_INVALID_ENUM); + ctx->dispatcher().glGetTexParameterfv(target,pname,params); + +} +GL_APICALL void GL_APIENTRY glGetTexParameteriv(GLenum target, GLenum pname, GLint* params){ + GET_CTX(); + SET_ERROR_IF(!(GLESv2Validate::textureTarget(target) && GLESv2Validate::textureParams(pname)),GL_INVALID_ENUM); + ctx->dispatcher().glGetTexParameteriv(target,pname,params); +} + +GL_APICALL void GL_APIENTRY glGetUniformfv(GLuint program, GLint location, GLfloat* params){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalProgramName = thrd->shareGroup->getGlobalName(PROGRAM,program); + ctx->dispatcher().glGetUniformfv(globalProgramName,location,params); + } +} + +GL_APICALL void GL_APIENTRY glGetUniformiv(GLuint program, GLint location, GLint* params){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalProgramName = thrd->shareGroup->getGlobalName(PROGRAM,program); + ctx->dispatcher().glGetUniformiv(globalProgramName,location,params); + } +} + +GL_APICALL int GL_APIENTRY glGetUniformLocation(GLuint program, const GLchar* name){ + GET_CTX_RET(-1); + if(thrd->shareGroup.Ptr()) { + const GLuint globalProgramName = thrd->shareGroup->getGlobalName(PROGRAM,program); + return ctx->dispatcher().glGetUniformLocation(globalProgramName,name); + } + return -1; +} + + + +GL_APICALL void GL_APIENTRY glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params){ + GET_CTX(); + const GLESpointer* p = ctx->getPointer(pname); + if(p) { + switch(pname){ + case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: + *params = 0; + break; + case GL_VERTEX_ATTRIB_ARRAY_ENABLED: + *params = p->isEnable(); + break; + case GL_VERTEX_ATTRIB_ARRAY_SIZE: + *params = p->getSize(); + break; + case GL_VERTEX_ATTRIB_ARRAY_STRIDE: + *params = p->getStride(); + break; + case GL_VERTEX_ATTRIB_ARRAY_TYPE: + *params = p->getType(); + break; + case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED: + *params = p->isNormalize(); + break; + case GL_CURRENT_VERTEX_ATTRIB: + ctx->dispatcher().glGetVertexAttribfv(index,pname,params); + break; + default: + ctx->setGLerror(GL_INVALID_ENUM); + } + } else { + ctx->setGLerror(GL_INVALID_ENUM); + } +} + +GL_APICALL void GL_APIENTRY glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params){ + GET_CTX(); + const GLESpointer* p = ctx->getPointer(pname); + if(p) { + switch(pname){ + case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: + *params = 0; + break; + case GL_VERTEX_ATTRIB_ARRAY_ENABLED: + *params = p->isEnable(); + break; + case GL_VERTEX_ATTRIB_ARRAY_SIZE: + *params = p->getSize(); + break; + case GL_VERTEX_ATTRIB_ARRAY_STRIDE: + *params = p->getStride(); + break; + case GL_VERTEX_ATTRIB_ARRAY_TYPE: + *params = p->getType(); + break; + case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED: + *params = p->isNormalize(); + break; + case GL_CURRENT_VERTEX_ATTRIB: + ctx->dispatcher().glGetVertexAttribiv(index,pname,params); + break; + default: + ctx->setGLerror(GL_INVALID_ENUM); + } + } else { + ctx->setGLerror(GL_INVALID_ENUM); + } +} + +GL_APICALL void GL_APIENTRY glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer){ + GET_CTX(); + SET_ERROR_IF(pname != GL_VERTEX_ATTRIB_ARRAY_POINTER,GL_INVALID_ENUM); + + const GLESpointer* p = ctx->getPointer(pname); + if(p) { + *pointer = const_cast( p->getBufferData()); + } else { + ctx->setGLerror(GL_INVALID_ENUM); + } +} + +GL_APICALL void GL_APIENTRY glHint(GLenum target, GLenum mode){ + GET_CTX(); + SET_ERROR_IF(!GLESv2Validate::hintTargetMode(target,mode),GL_INVALID_ENUM); + ctx->dispatcher().glHint(target,mode); +} + +GL_APICALL GLboolean GL_APIENTRY glIsEnabled(GLenum cap){ + GET_CTX_RET(GL_FALSE); + RET_AND_SET_ERROR_IF(!GLESv2Validate::capability(cap),GL_INVALID_ENUM,GL_FALSE); + return ctx->dispatcher().glIsEnabled(cap); +} + +GL_APICALL GLboolean GL_APIENTRY glIsBuffer(GLuint buffer){ + GET_CTX_RET(GL_FALSE) + if(buffer && thrd->shareGroup.Ptr()) { + ObjectDataPtr objData = thrd->shareGroup->getObjectData(VERTEXBUFFER,buffer); + return objData.Ptr() ? ((GLESbuffer*)objData.Ptr())->wasBinded():GL_FALSE; + } + return GL_FALSE; +} + +GL_APICALL GLboolean GL_APIENTRY glIsFramebuffer(GLuint framebuffer){ + GET_CTX_RET(GL_FALSE) + if(framebuffer && thrd->shareGroup.Ptr()){ + return thrd->shareGroup->isObject(FRAMEBUFFER,framebuffer) ? GL_TRUE :GL_FALSE; + } + return GL_FALSE; +} + +GL_APICALL GLboolean GL_APIENTRY glIsRenderbuffer(GLuint renderbuffer){ + GET_CTX_RET(GL_FALSE) + if(renderbuffer && thrd->shareGroup.Ptr()){ + return thrd->shareGroup->isObject(RENDERBUFFER,renderbuffer) ? GL_TRUE :GL_FALSE; + } + return GL_FALSE; +} + +GL_APICALL GLboolean GL_APIENTRY glIsTexture(GLuint texture){ + GET_CTX_RET(GL_FALSE) + if(texture && thrd->shareGroup.Ptr()){ + return thrd->shareGroup->isObject(TEXTURE,texture) ? GL_TRUE :GL_FALSE; + } + return GL_FALSE; +} + +GL_APICALL GLboolean GL_APIENTRY glIsProgram(GLuint program){ + GET_CTX_RET(GL_FALSE) + if(program && thrd->shareGroup.Ptr()){ + return thrd->shareGroup->isObject(PROGRAM,program) ? GL_TRUE :GL_FALSE; + } + return GL_FALSE; +} + +GL_APICALL GLboolean GL_APIENTRY glIsShader(GLuint shader){ + GET_CTX_RET(GL_FALSE) + if(shader && thrd->shareGroup.Ptr()){ + return thrd->shareGroup->isObject(SHADER,shader) ? GL_TRUE :GL_FALSE; + } + return GL_FALSE; +} + +GL_APICALL void GL_APIENTRY glLineWidth(GLfloat width){ + GET_CTX(); + ctx->dispatcher().glLineWidth(width); +} + +GL_APICALL void GL_APIENTRY glLinkProgram(GLuint program){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalProgramName = thrd->shareGroup->getGlobalName(PROGRAM,program); + ctx->dispatcher().glLinkProgram(globalProgramName); + } +} + +GL_APICALL void GL_APIENTRY glPixelStorei(GLenum pname, GLint param){ + GET_CTX(); + SET_ERROR_IF(!GLESv2Validate::pixelStoreParam(pname),GL_INVALID_ENUM); + ctx->dispatcher().glPixelStorei(pname,param); +} + +GL_APICALL void GL_APIENTRY glPolygonOffset(GLfloat factor, GLfloat units){ + GET_CTX(); + ctx->dispatcher().glPolygonOffset(factor,units); +} + +GL_APICALL void GL_APIENTRY glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels){ + GET_CTX(); + SET_ERROR_IF(!(GLESv2Validate::readPixelFrmt(format) && GLESv2Validate::pixelType(type)),GL_INVALID_ENUM); + SET_ERROR_IF(!(GLESv2Validate::pixelOp(format,type)),GL_INVALID_OPERATION); + ctx->dispatcher().glReadPixels(x,y,width,height,format,type,pixels); +} + + +GL_APICALL void GL_APIENTRY glReleaseShaderCompiler(void){ + GET_CTX(); + ctx->dispatcher().glReleaseShaderCompiler(); +} + +GL_APICALL void GL_APIENTRY glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height){ + GET_CTX(); + ctx->dispatcher().glRenderbufferStorage(target,internalformat,width,height); +} + +GL_APICALL void GL_APIENTRY glSampleCoverage(GLclampf value, GLboolean invert){ + GET_CTX(); + ctx->dispatcher().glSampleCoverage(value,invert); +} + +GL_APICALL void GL_APIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height){ + GET_CTX(); + ctx->dispatcher().glScissor(x,y,width,height); +} + +GL_APICALL void GL_APIENTRY glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length){ + GET_CTX(); + if(thrd->shareGroup.Ptr()){ + for(int i=0; i < n ; i++){ + const GLuint globalShaderName = thrd->shareGroup->getGlobalName(SHADER,shaders[i]); + ctx->dispatcher().glShaderBinary(1,&shaders[i],binaryformat,binary,length); + } + } +} + +//TODO: may need to change the source to match to GL shaders format +GL_APICALL void GL_APIENTRY glShaderSource(GLuint shader, GLsizei count, const GLchar** string, const GLint* length){ + GET_CTX(); + if(thrd->shareGroup.Ptr()){ + const GLuint globalShaderName = thrd->shareGroup->getGlobalName(SHADER,shader); + ctx->dispatcher().glShaderSource(shader,count,string,length); + } +} + +GL_APICALL void GL_APIENTRY glStencilFunc(GLenum func, GLint ref, GLuint mask){ + GET_CTX(); + ctx->dispatcher().glStencilFunc(func,ref,mask); +} +GL_APICALL void GL_APIENTRY glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask){ + GET_CTX(); + ctx->dispatcher().glStencilFuncSeparate(face,func,ref,mask); +} +GL_APICALL void GL_APIENTRY glStencilMask(GLuint mask){ + GET_CTX(); + ctx->dispatcher().glStencilMask(mask); +} + +GL_APICALL void GL_APIENTRY glStencilMaskSeparate(GLenum face, GLuint mask){ + GET_CTX(); + ctx->dispatcher().glStencilMaskSeparate(face,mask); +} + +GL_APICALL void GL_APIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass){ + GET_CTX(); + ctx->dispatcher().glStencilOp(fail,zfail,zpass); +} + +GL_APICALL void GL_APIENTRY glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass){ + GET_CTX(); + ctx->dispatcher().glStencilOp(fail,zfail,zpass); +} + +static TextureData* getTextureData(){ + GET_CTX_RET(NULL); + unsigned int tex = ctx->getBindedTexture(); + TextureData *texData = NULL; + ObjectDataPtr objData = thrd->shareGroup->getObjectData(TEXTURE,tex); + if(!objData.Ptr()){ + texData = new TextureData(); + thrd->shareGroup->setObjectData(TEXTURE, tex, ObjectDataPtr(texData)); + } else { + texData = (TextureData*)objData.Ptr(); + } + return texData; +} + +GL_APICALL void GL_APIENTRY glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels){ + GET_CTX(); + SET_ERROR_IF(!(GLESv2Validate::textureTargetEx(target) && + GLESv2Validate::pixelFrmt(internalformat) && + GLESv2Validate::pixelFrmt(format)&& + GLESv2Validate::pixelType(type)),GL_INVALID_ENUM); + + SET_ERROR_IF(!(GLESv2Validate::pixelOp(format,type) && internalformat == ((GLint)format)),GL_INVALID_OPERATION); + SET_ERROR_IF(border != 0,GL_INVALID_VALUE); + + if (thrd->shareGroup.Ptr()){ + unsigned int tex = ctx->getBindedTexture(); + TextureData *texData = getTextureData(); + if(texData) { + texData->width = width; + texData->height = height; + texData->border = border; + texData->internalFormat = internalformat; + } + } + ctx->dispatcher().glTexImage2D(target,level,internalformat,width,height,border,format,type,pixels); +} + + +GL_APICALL void GL_APIENTRY glTexParameterf(GLenum target, GLenum pname, GLfloat param){ + GET_CTX(); + SET_ERROR_IF(!(GLESv2Validate::textureTarget(target) && GLESv2Validate::textureParams(pname)),GL_INVALID_ENUM); + ctx->dispatcher().glTexParameterf(target,pname,param); +} +GL_APICALL void GL_APIENTRY glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params){ + GET_CTX(); + SET_ERROR_IF(!(GLESv2Validate::textureTarget(target) && GLESv2Validate::textureParams(pname)),GL_INVALID_ENUM); + ctx->dispatcher().glTexParameterfv(target,pname,params); +} +GL_APICALL void GL_APIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param){ + GET_CTX(); + SET_ERROR_IF(!(GLESv2Validate::textureTarget(target) && GLESv2Validate::textureParams(pname)),GL_INVALID_ENUM); + ctx->dispatcher().glTexParameteri(target,pname,param); +} +GL_APICALL void GL_APIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint* params){ + GET_CTX(); + SET_ERROR_IF(!(GLESv2Validate::textureTarget(target) && GLESv2Validate::textureParams(pname)),GL_INVALID_ENUM); + ctx->dispatcher().glTexParameteriv(target,pname,params); +} + +GL_APICALL void GL_APIENTRY glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels){ + GET_CTX(); + SET_ERROR_IF(!(GLESv2Validate::textureTargetEx(target) && + GLESv2Validate::pixelFrmt(format)&& + GLESv2Validate::pixelType(type)),GL_INVALID_ENUM); + SET_ERROR_IF(!GLESv2Validate::pixelOp(format,type),GL_INVALID_OPERATION); + + ctx->dispatcher().glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels); + +} + +GL_APICALL void GL_APIENTRY glUniform1f(GLint location, GLfloat x){ + GET_CTX(); + ctx->dispatcher().glUniform1f(location,x); +} +GL_APICALL void GL_APIENTRY glUniform1fv(GLint location, GLsizei count, const GLfloat* v){ + GET_CTX(); + ctx->dispatcher().glUniform1fv(location,count,v); +} + +GL_APICALL void GL_APIENTRY glUniform1i(GLint location, GLint x){ + GET_CTX(); + ctx->dispatcher().glUniform1i(location,x); +} +GL_APICALL void GL_APIENTRY glUniform1iv(GLint location, GLsizei count, const GLint* v){ + GET_CTX(); + ctx->dispatcher().glUniform1iv(location,count,v); +} +GL_APICALL void GL_APIENTRY glUniform2f(GLint location, GLfloat x, GLfloat y){ + GET_CTX(); + ctx->dispatcher().glUniform2f(location,x,y); +} +GL_APICALL void GL_APIENTRY glUniform2fv(GLint location, GLsizei count, const GLfloat* v){ + GET_CTX(); + ctx->dispatcher().glUniform2fv(location,count,v); +} +GL_APICALL void GL_APIENTRY glUniform2i(GLint location, GLint x, GLint y){ + GET_CTX(); + ctx->dispatcher().glUniform2i(location,x,y); +} +GL_APICALL void GL_APIENTRY glUniform2iv(GLint location, GLsizei count, const GLint* v){ + GET_CTX(); + ctx->dispatcher().glUniform2iv(location,count,v); +} +GL_APICALL void GL_APIENTRY glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z){ + GET_CTX(); + ctx->dispatcher().glUniform3f(location,x,y,z); +} +GL_APICALL void GL_APIENTRY glUniform3fv(GLint location, GLsizei count, const GLfloat* v){ + GET_CTX(); + ctx->dispatcher().glUniform3fv(location,count,v); +} +GL_APICALL void GL_APIENTRY glUniform3i(GLint location, GLint x, GLint y, GLint z){ + GET_CTX(); + ctx->dispatcher().glUniform3i(location,x,y,z); +} + +GL_APICALL void GL_APIENTRY glUniform3iv(GLint location, GLsizei count, const GLint* v){ + GET_CTX(); + ctx->dispatcher().glUniform3iv(location,count,v); +} + +GL_APICALL void GL_APIENTRY glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w){ + GET_CTX(); + ctx->dispatcher().glUniform4f(location,x,y,z,w); +} + +GL_APICALL void GL_APIENTRY glUniform4fv(GLint location, GLsizei count, const GLfloat* v){ + GET_CTX(); + ctx->dispatcher().glUniform4fv(location,count,v); +} + +GL_APICALL void GL_APIENTRY glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w){ + GET_CTX(); + ctx->dispatcher().glUniform4i(location,x,y,z,w); +} + +GL_APICALL void GL_APIENTRY glUniform4iv(GLint location, GLsizei count, const GLint* v){ + GET_CTX(); + ctx->dispatcher().glUniform4iv(location,count,v); +} + +GL_APICALL void GL_APIENTRY glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value){ + GET_CTX(); + SET_ERROR_IF(transpose != GL_FALSE,GL_INVALID_VALUE); + ctx->dispatcher().glUniformMatrix2fv(location,count,transpose,value); +} + +GL_APICALL void GL_APIENTRY glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value){ + GET_CTX(); + SET_ERROR_IF(transpose != GL_FALSE,GL_INVALID_VALUE); + ctx->dispatcher().glUniformMatrix3fv(location,count,transpose,value); +} + +GL_APICALL void GL_APIENTRY glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value){ + GET_CTX(); + SET_ERROR_IF(transpose != GL_FALSE,GL_INVALID_VALUE); + ctx->dispatcher().glUniformMatrix4fv(location,count,transpose,value); +} + +GL_APICALL void GL_APIENTRY glUseProgram(GLuint program){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalProgramName = thrd->shareGroup->getGlobalName(PROGRAM,program); + ctx->dispatcher().glUseProgram(globalProgramName); + } +} + +GL_APICALL void GL_APIENTRY glValidateProgram(GLuint program){ + GET_CTX(); + if(thrd->shareGroup.Ptr()) { + const GLuint globalProgramName = thrd->shareGroup->getGlobalName(PROGRAM,program); + ctx->dispatcher().glValidateProgram(globalProgramName); + } +} + +GL_APICALL void GL_APIENTRY glVertexAttrib1f(GLuint indx, GLfloat x){ + GET_CTX(); + ctx->dispatcher().glVertexAttrib1f(indx,x); +} + +GL_APICALL void GL_APIENTRY glVertexAttrib1fv(GLuint indx, const GLfloat* values){ + GET_CTX(); + ctx->dispatcher().glVertexAttrib1fv(indx,values); +} + +GL_APICALL void GL_APIENTRY glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y){ + GET_CTX(); + ctx->dispatcher().glVertexAttrib2f(indx,x,y); +} + +GL_APICALL void GL_APIENTRY glVertexAttrib2fv(GLuint indx, const GLfloat* values){ + GET_CTX(); + ctx->dispatcher().glVertexAttrib2fv(indx,values); +} + +GL_APICALL void GL_APIENTRY glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z){ + GET_CTX(); + ctx->dispatcher().glVertexAttrib3f(indx,x,y,z); +} + +GL_APICALL void GL_APIENTRY glVertexAttrib3fv(GLuint indx, const GLfloat* values){ + GET_CTX(); + ctx->dispatcher().glVertexAttrib3fv(indx,values); +} + +GL_APICALL void GL_APIENTRY glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w){ + GET_CTX(); + ctx->dispatcher().glVertexAttrib4f(indx,x,y,z,w); +} + +GL_APICALL void GL_APIENTRY glVertexAttrib4fv(GLuint indx, const GLfloat* values){ + GET_CTX(); + ctx->dispatcher().glVertexAttrib4fv(indx,values); +} + +GL_APICALL void GL_APIENTRY glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr){ + GET_CTX(); + const GLvoid* data = ctx->setPointer(indx,size,type,stride,ptr); + if(type != GL_FIXED) ctx->dispatcher().glVertexAttribPointer(indx,size,type,normalized,stride,ptr); +} + +GL_APICALL void GL_APIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height){ + GET_CTX(); + ctx->dispatcher().glViewport(x,y,width,height); +} diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Validate.cpp b/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Validate.cpp new file mode 100644 index 000000000..57667a725 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Validate.cpp @@ -0,0 +1,184 @@ +/* +* 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 "GLESv2Validate.h" + +bool GLESv2Validate::blendEquationMode(GLenum mode){ + return mode == GL_FUNC_ADD || + mode == GL_FUNC_SUBTRACT || + mode == GL_FUNC_REVERSE_SUBTRACT; +} + +bool GLESv2Validate::blendSrc(GLenum s) { + switch(s) { + case GL_ZERO: + case GL_ONE: + case GL_SRC_COLOR: + case GL_ONE_MINUS_SRC_COLOR: + case GL_DST_COLOR: + case GL_ONE_MINUS_DST_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + case GL_CONSTANT_COLOR: + case GL_ONE_MINUS_CONSTANT_COLOR: + case GL_CONSTANT_ALPHA: + case GL_ONE_MINUS_CONSTANT_ALPHA: + case GL_SRC_ALPHA_SATURATE: + return true; + } + return false; +} + + +bool GLESv2Validate::blendDst(GLenum d) { + switch(d) { + case GL_ZERO: + case GL_ONE: + case GL_SRC_COLOR: + case GL_ONE_MINUS_SRC_COLOR: + case GL_DST_COLOR: + case GL_ONE_MINUS_DST_COLOR: + case GL_SRC_ALPHA: + case GL_ONE_MINUS_SRC_ALPHA: + case GL_DST_ALPHA: + case GL_ONE_MINUS_DST_ALPHA: + case GL_CONSTANT_COLOR: + case GL_ONE_MINUS_CONSTANT_COLOR: + case GL_CONSTANT_ALPHA: + case GL_ONE_MINUS_CONSTANT_ALPHA: + return true; + } + return false; +} + +bool GLESv2Validate::textureTarget(GLenum target){ + return target == GL_TEXTURE_2D || target == GL_TEXTURE_CUBE_MAP; +} + +bool GLESv2Validate::textureParams(GLenum param){ + switch(param) { + case GL_TEXTURE_MIN_FILTER: + case GL_TEXTURE_MAG_FILTER: + case GL_TEXTURE_WRAP_S: + case GL_TEXTURE_WRAP_T: + return true; + default: + return false; + } +} + +bool GLESv2Validate::hintTargetMode(GLenum target,GLenum mode){ + + switch(mode) { + case GL_FASTEST: + case GL_NICEST: + case GL_DONT_CARE: + break; + default: return false; + } + return target == GL_GENERATE_MIPMAP_HINT; +} + +bool GLESv2Validate::capability(GLenum cap){ + switch(cap){ + case GL_BLEND: + case GL_CULL_FACE: + case GL_DEPTH_TEST: + case GL_DITHER: + case GL_POLYGON_OFFSET_FILL: + case GL_SAMPLE_ALPHA_TO_COVERAGE: + case GL_SAMPLE_COVERAGE: + case GL_SCISSOR_TEST: + case GL_STENCIL_TEST: + return true; + } + return false; +} + +bool GLESv2Validate::pixelStoreParam(GLenum param){ + return param == GL_PACK_ALIGNMENT || param == GL_UNPACK_ALIGNMENT; +} + +bool GLESv2Validate::readPixelFrmt(GLenum format){ + switch(format) { + case GL_ALPHA: + case GL_RGB: + case GL_RGBA: + return true; + } + return false; +} + +bool GLESv2Validate::textureTargetEx(GLenum target){ + switch(target){ + case GL_TEXTURE_2D: + case GL_TEXTURE_CUBE_MAP_POSITIVE_X: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: + return true; + } + return false; +} + +bool GLESv2Validate::framebufferTarget(GLenum target){ + return target == GL_FRAMEBUFFER; +} + +bool GLESv2Validate::framebufferAttachment(GLenum attachment){ + switch(attachment){ + case GL_COLOR_ATTACHMENT0: + case GL_DEPTH_ATTACHMENT: + case GL_STENCIL_ATTACHMENT: + return true; + } + return false; +} + +bool GLESv2Validate::framebufferAttachmentParams(GLenum pname){ + switch(pname){ + case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: + case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: + case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: + case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: + return true; + } + return false; +} + +bool GLESv2Validate::renderbufferTarget(GLenum target){ + return target == GL_RENDERBUFFER; +} + +bool GLESv2Validate::renderbufferParams(GLenum pname){ + switch(pname){ + case GL_RENDERBUFFER_WIDTH: + case GL_RENDERBUFFER_HEIGHT: + case GL_RENDERBUFFER_INTERNAL_FORMAT: + case GL_RENDERBUFFER_RED_SIZE: + case GL_RENDERBUFFER_GREEN_SIZE: + case GL_RENDERBUFFER_BLUE_SIZE: + case GL_RENDERBUFFER_ALPHA_SIZE: + case GL_RENDERBUFFER_DEPTH_SIZE: + case GL_RENDERBUFFER_STENCIL_SIZE: + return true; + } + return false; +} + diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Validate.h b/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Validate.h new file mode 100644 index 000000000..85e774f7d --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Validate.h @@ -0,0 +1,42 @@ +#ifndef GLES_V2_VALIDATE_H +#define GLES_V2_VALIDATE_H + +/* +* 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 +#include + +struct GLESv2Validate:public GLESvalidate{ +static bool blendEquationMode(GLenum mode); +static bool blendSrc(GLenum s); +static bool blendDst(GLenum d); +static bool textureTarget(GLenum target); +static bool textureTargetEx(GLenum target); +static bool textureParams(GLenum param); +static bool hintTargetMode(GLenum target,GLenum mode); +static bool capability(GLenum cap); +static bool pixelStoreParam(GLenum param); +static bool readPixelFrmt(GLenum format); +static bool framebufferTarget(GLenum target); +static bool framebufferAttachment(GLenum attachment); +static bool framebufferAttachmentParams(GLenum pname); +static bool renderbufferTarget(GLenum target); +static bool renderbufferParams(GLenum pname); + +}; + +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/GLcommon/Android.mk b/tools/emulator/opengl/host/libs/Translator/GLcommon/Android.mk index d1869b59a..628a81cbb 100644 --- a/tools/emulator/opengl/host/libs/Translator/GLcommon/Android.mk +++ b/tools/emulator/opengl/host/libs/Translator/GLcommon/Android.mk @@ -7,14 +7,22 @@ include $(CLEAR_VARS) translator_path := $(LOCAL_PATH)/.. LOCAL_SRC_FILES := \ + GLDispatch.cpp \ GLutils.cpp \ + GLEScontext.cpp \ + GLESvalidate.cpp \ + GLESpointer.cpp \ + GLESbuffer.cpp \ + RangeManip.cpp \ objectNameManager.cpp LOCAL_C_INCLUDES += \ - $(translator_path)/include + $(translator_path)/include \ + $(translator_path)/../../../shared LOCAL_STATIC_LIBRARIES := \ + libOpenglOsUtils \ libutils \ libcutils @@ -23,6 +31,11 @@ LOCAL_MODULE_TAGS := debug LOCAL_MODULE := libGLcommon ifeq ($(HOST_OS),linux) LOCAL_LDFLAGS := -Wl,--whole-archive + LOCAL_LDLIBS := -lGL -ldl +endif + +ifeq ($(HOST_OS),windows) + LOCAL_LDLIBS := -lopengl32 -lgdi32 endif include $(BUILD_HOST_SHARED_LIBRARY) diff --git a/tools/emulator/opengl/host/libs/Translator/GLcommon/GLDispatch.cpp b/tools/emulator/opengl/host/libs/Translator/GLcommon/GLDispatch.cpp new file mode 100644 index 000000000..d4a3d051c --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/GLcommon/GLDispatch.cpp @@ -0,0 +1,479 @@ +/* +* 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 +#include +#include + +#ifdef __linux__ +#include +#elif defined(WIN32) +#include +#endif + +typedef void (*GL_FUNC_PTR)(); + +static GL_FUNC_PTR getGLFuncAddress(const char *funcName) { + GL_FUNC_PTR ret = NULL; +#ifdef __linux__ + static osUtils::dynLibrary* libGL = osUtils::dynLibrary::open("GL"); + ret = (GL_FUNC_PTR)glXGetProcAddress((const GLubyte*)funcName); +#elif defined(WIN32) + static osUtils::dynLibrary* libGL = osUtils::dynLibrary::open("opengl32"); + ret = (GL_FUNC_PTR)wglGetProcAddress(funcName); +#else //mac + static osUtils::dynLibrary* libGL = NULL; +#endif + + if(!ret && libGL){ + ret = libGL->findSymbol(funcName); + } + return ret; +} + +#define LOAD_GL_FUNC(name) { void * funcAddrs = NULL; \ + if(name == NULL){ \ + funcAddrs = (void *)getGLFuncAddress(#name); \ + if(funcAddrs) \ + *(void**)(&name) = funcAddrs; \ + else \ + fprintf(stderr,"could not load func %s\n",#name); \ + } \ + } + +/* initializing static GLDispatch members*/ + +android::Mutex GLDispatch::s_lock; +void (GLAPIENTRY *GLDispatch::glActiveTexture)(GLenum) = NULL; +void (GLAPIENTRY *GLDispatch::glBindBuffer)(GLenum,GLuint) = NULL; +void (GLAPIENTRY *GLDispatch::glBindTexture)(GLenum, GLuint) = NULL; +void (GLAPIENTRY *GLDispatch::glBlendFunc)(GLenum,GLenum) = NULL; +void (GLAPIENTRY *GLDispatch::glBufferData)(GLenum,GLsizeiptr,const GLvoid *,GLenum) = NULL; +void (GLAPIENTRY *GLDispatch::glBufferSubData)(GLenum,GLintptr,GLsizeiptr,const GLvoid *) = NULL; +void (GLAPIENTRY *GLDispatch::glClear)(GLbitfield) = NULL; +void (GLAPIENTRY *GLDispatch::glClearColor)(GLclampf,GLclampf,GLclampf,GLclampf) = NULL; +void (GLAPIENTRY *GLDispatch::glClearStencil)(GLint) = NULL; +void (GLAPIENTRY *GLDispatch::glColorMask)(GLboolean,GLboolean,GLboolean,GLboolean) = NULL; +void (GLAPIENTRY *GLDispatch::glCompressedTexImage2D)(GLenum,GLint,GLenum,GLsizei,GLsizei,GLint,GLsizei, const GLvoid *) = NULL; +void (GLAPIENTRY *GLDispatch::glCompressedTexSubImage2D)(GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLsizei,const GLvoid *) = NULL; +void (GLAPIENTRY *GLDispatch::glCopyTexImage2D)(GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLsizei,GLint) = NULL; +void (GLAPIENTRY *GLDispatch::glCopyTexSubImage2D)(GLenum,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei) = NULL; +void (GLAPIENTRY *GLDispatch::glCullFace)(GLenum) = NULL; +void (GLAPIENTRY *GLDispatch::glDeleteBuffers)(GLsizei,const GLuint *) = NULL; +void (GLAPIENTRY *GLDispatch::glDeleteTextures)(GLsizei,const GLuint *) = NULL; +void (GLAPIENTRY *GLDispatch::glDepthFunc)(GLenum) = NULL; +void (GLAPIENTRY *GLDispatch::glDepthMask)(GLboolean) = NULL; +void (GLAPIENTRY *GLDispatch::glDisable)(GLenum) = NULL; +void (GLAPIENTRY *GLDispatch::glDrawArrays)(GLenum,GLint,GLsizei) = NULL; +void (GLAPIENTRY *GLDispatch::glDrawElements)(GLenum,GLsizei,GLenum,const GLvoid *) = NULL; +void (GLAPIENTRY *GLDispatch::glEnable)(GLenum) = NULL; +void (GLAPIENTRY *GLDispatch::glFinish)() = NULL; +void (GLAPIENTRY *GLDispatch::glFlush)() = NULL; +void (GLAPIENTRY *GLDispatch::glFrontFace)(GLenum) = NULL; +void (GLAPIENTRY *GLDispatch::glGenBuffers)(GLsizei,GLuint *) = NULL; +void (GLAPIENTRY *GLDispatch::glGenTextures)(GLsizei,GLuint *) = NULL; +void (GLAPIENTRY *GLDispatch::glGetBooleanv)(GLenum,GLboolean *) = NULL; +void (GLAPIENTRY *GLDispatch::glGetBufferParameteriv)(GLenum, GLenum, GLint *) = NULL; +GLenum (GLAPIENTRY *GLDispatch::glGetError)() = NULL; +void (GLAPIENTRY *GLDispatch::glGetFloatv)(GLenum,GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glGetIntegerv)(GLenum,GLint *) = NULL; +const GLubyte * (GLAPIENTRY *GLDispatch::glGetString) (GLenum) = NULL; +void (GLAPIENTRY *GLDispatch::glGetTexParameterfv)(GLenum,GLenum,GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glGetTexParameteriv)(GLenum,GLenum,GLint *) = NULL; +void (GLAPIENTRY *GLDispatch::glHint)(GLenum,GLenum) = NULL; +GLboolean (GLAPIENTRY *GLDispatch::glIsBuffer)(GLuint) = NULL; +GLboolean (GLAPIENTRY *GLDispatch::glIsEnabled)(GLenum) = NULL; +GLboolean (GLAPIENTRY *GLDispatch::glIsTexture)(GLuint) = NULL; +void (GLAPIENTRY *GLDispatch::glLineWidth)(GLfloat) = NULL; +void (GLAPIENTRY *GLDispatch::glPolygonOffset)(GLfloat, GLfloat) = NULL; +void (GLAPIENTRY *GLDispatch::glPixelStorei)(GLenum,GLint) = NULL; +void (GLAPIENTRY *GLDispatch::glReadPixels)(GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,GLvoid *) = NULL; +void (GLAPIENTRY *GLDispatch::glSampleCoverage)(GLclampf,GLboolean) = NULL; +void (GLAPIENTRY *GLDispatch::glScissor)(GLint,GLint,GLsizei,GLsizei) = NULL; +void (GLAPIENTRY *GLDispatch::glStencilFunc)(GLenum,GLint,GLuint) = NULL; +void (GLAPIENTRY *GLDispatch::glStencilMask)(GLuint) = NULL; +void (GLAPIENTRY *GLDispatch::glStencilOp)(GLenum, GLenum,GLenum); +void (GLAPIENTRY *GLDispatch::glTexImage2D)(GLenum,GLint,GLint,GLsizei,GLsizei,GLint,GLenum,GLenum,const GLvoid *) = NULL; +void (GLAPIENTRY *GLDispatch::glTexParameteri)(GLenum,GLenum,GLint) = NULL; +void (GLAPIENTRY *GLDispatch::glTexParameteriv)(GLenum,GLenum,const GLint *) = NULL; +void (GLAPIENTRY *GLDispatch::glTexSubImage2D)(GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,const GLvoid *) = NULL; +void (GLAPIENTRY *GLDispatch::glViewport)(GLint,GLint,GLsizei,GLsizei) = NULL; + +/*GLES 1.1*/ +void (GLAPIENTRY *GLDispatch::glAlphaFunc)(GLenum,GLclampf) = NULL; +void (GLAPIENTRY *GLDispatch::glBegin)(GLenum) = NULL; +void (GLAPIENTRY *GLDispatch::glClearDepth)(GLclampd) = NULL; +void (GLAPIENTRY *GLDispatch::glClientActiveTexture)(GLenum) = NULL; +void (GLAPIENTRY *GLDispatch::glClipPlane)(GLenum,const GLdouble *) = NULL; +void (GLAPIENTRY *GLDispatch::glColor4d)(GLdouble,GLdouble,GLdouble,GLdouble) = NULL; +void (GLAPIENTRY *GLDispatch::glColor4f)(GLfloat,GLfloat,GLfloat,GLfloat) = NULL; +void (GLAPIENTRY *GLDispatch::glColor4fv)(const GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glColor4ub)(GLubyte,GLubyte,GLubyte,GLubyte) = NULL; +void (GLAPIENTRY *GLDispatch::glColor4ubv)(const GLubyte *) = NULL; +void (GLAPIENTRY *GLDispatch::glColorPointer)(GLint,GLenum,GLsizei,const GLvoid *) = NULL; +void (GLAPIENTRY *GLDispatch::glDepthRange)(GLclampd,GLclampd) = NULL; +void (GLAPIENTRY *GLDispatch::glDisableClientState)(GLenum) = NULL; +void (GLAPIENTRY *GLDispatch::glEnableClientState)(GLenum) = NULL; +void (GLAPIENTRY *GLDispatch::glEnd)() = NULL; +void (GLAPIENTRY *GLDispatch::glFogf)(GLenum, GLfloat) = NULL; +void (GLAPIENTRY *GLDispatch::glFogfv)(GLenum,const GLfloat *); +void (GLAPIENTRY *GLDispatch::glFrustum)(GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble) = NULL; +void (GLAPIENTRY *GLDispatch::glGetClipPlane)(GLenum,GLdouble *) = NULL; +void (GLAPIENTRY *GLDispatch::glGetDoublev)(GLenum,GLdouble *) = NULL; +void (GLAPIENTRY *GLDispatch::glGetLightfv)(GLenum,GLenum,GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glGetMaterialfv)(GLenum,GLenum,GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glGetPointerv)(GLenum,GLvoid**) = NULL; +void (GLAPIENTRY *GLDispatch::glGetTexEnvfv)(GLenum,GLenum,GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glGetTexEnviv)(GLenum,GLenum,GLint *)= NULL; +void (GLAPIENTRY *GLDispatch::glLightf)(GLenum,GLenum,GLfloat) = NULL; +void (GLAPIENTRY *GLDispatch::glLightfv)(GLenum,GLenum,const GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glLightModelf)(GLenum,GLfloat) = NULL; +void (GLAPIENTRY *GLDispatch::glLightModelfv)(GLenum,const GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glLoadIdentity)() = NULL; +void (GLAPIENTRY *GLDispatch::glLoadMatrixf)(const GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glLogicOp)(GLenum) = NULL; +void (GLAPIENTRY *GLDispatch::glMaterialf)(GLenum,GLenum,GLfloat) = NULL; +void (GLAPIENTRY *GLDispatch::glMaterialfv)(GLenum,GLenum,const GLfloat *); +void (GLAPIENTRY *GLDispatch::glMultiTexCoord2fv)(GLenum, const GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glMultiTexCoord2sv)(GLenum, const GLshort *) = NULL; +void (GLAPIENTRY *GLDispatch::glMultiTexCoord3fv)(GLenum, const GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glMultiTexCoord3sv)(GLenum,const GLshort *) = NULL; +void (GLAPIENTRY *GLDispatch::glMultiTexCoord4f)(GLenum,GLfloat,GLfloat,GLfloat,GLfloat) = NULL; +void (GLAPIENTRY *GLDispatch::glMultiTexCoord4fv)(GLenum,const GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glMultiTexCoord4sv)(GLenum,const GLshort *) = NULL; +void (GLAPIENTRY *GLDispatch::glMultMatrixf)(const GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glNormal3f)(GLfloat,GLfloat,GLfloat) = NULL; +void (GLAPIENTRY *GLDispatch::glNormal3fv)(const GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glNormal3sv)(const GLshort *) = NULL; +void (GLAPIENTRY *GLDispatch::glOrtho)(GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble) = NULL; +void (GLAPIENTRY *GLDispatch::glPointParameterf)(GLenum, GLfloat) = NULL; +void (GLAPIENTRY *GLDispatch::glPointParameterfv)(GLenum, const GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glPointSize)(GLfloat) = NULL; +void (GLAPIENTRY *GLDispatch::glRotatef)(GLfloat,GLfloat,GLfloat,GLfloat) = NULL; +void (GLAPIENTRY *GLDispatch::glScalef)(GLfloat,GLfloat,GLfloat) = NULL; +void (GLAPIENTRY *GLDispatch::glTexEnvf)(GLenum,GLenum,GLfloat) = NULL; +void (GLAPIENTRY *GLDispatch::glTexEnvfv)(GLenum,GLenum,const GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glTexParameterf)(GLenum,GLenum, GLfloat) = NULL; +void (GLAPIENTRY *GLDispatch::glTexParameterfv)(GLenum,GLenum,const GLfloat *) = NULL; +void (GLAPIENTRY *GLDispatch::glMatrixMode)(GLenum) = NULL; +void (GLAPIENTRY *GLDispatch::glNormalPointer)(GLenum,GLsizei,const GLvoid *) = NULL; +void (GLAPIENTRY *GLDispatch::glPopMatrix)() = NULL; +void (GLAPIENTRY *GLDispatch::glPushMatrix)() = NULL; +void (GLAPIENTRY *GLDispatch::glShadeModel)(GLenum) = NULL; +void (GLAPIENTRY *GLDispatch::glTexCoordPointer)(GLint,GLenum, GLsizei, const GLvoid*) = NULL; +void (GLAPIENTRY *GLDispatch::glTexEnvi)(GLenum ,GLenum,GLint) = NULL; +void (GLAPIENTRY *GLDispatch::glTexEnviv)(GLenum, GLenum, const GLint *) = NULL; +void (GLAPIENTRY *GLDispatch::glTranslatef)(GLfloat,GLfloat, GLfloat) = NULL; +void (GLAPIENTRY *GLDispatch::glVertexPointer)(GLint,GLenum,GLsizei, const GLvoid *) = NULL; + +/* GLES 2.0*/ +void (GL_APIENTRY *GLDispatch::glBlendColor)(GLclampf,GLclampf,GLclampf,GLclampf) = NULL; +void (GL_APIENTRY *GLDispatch::glBlendEquation)(GLenum) = NULL; +void (GL_APIENTRY *GLDispatch::glBlendEquationSeparate)(GLenum,GLenum) = NULL; +void (GL_APIENTRY *GLDispatch::glBlendFuncSeparate)(GLenum,GLenum,GLenum,GLenum) = NULL; +void (GL_APIENTRY *GLDispatch::glStencilFuncSeparate)(GLenum,GLenum,GLint,GLuint) = NULL; +void (GL_APIENTRY *GLDispatch::glStencilMaskSeparate)(GLenum,GLuint) = NULL; +void (GL_APIENTRY *GLDispatch::glGenerateMipmap)(GLenum) = NULL; +void (GL_APIENTRY *GLDispatch::glBindFramebuffer)(GLenum,GLuint) = NULL; +void (GL_APIENTRY *GLDispatch::glBindRenderbuffer)(GLenum,GLuint) = NULL; +void (GL_APIENTRY *GLDispatch::glDeleteFramebuffers)(GLsizei,const GLuint*) = NULL; +void (GL_APIENTRY *GLDispatch::glDeleteRenderbuffers)(GLsizei,const GLuint*) = NULL; +void (GL_APIENTRY *GLDispatch::glVertexAttrib1f)(GLuint,GLfloat) = NULL; +void (GL_APIENTRY *GLDispatch::glVertexAttrib1fv)(GLuint,const GLfloat*) = NULL; +void (GL_APIENTRY *GLDispatch::glVertexAttrib2f)(GLuint,GLfloat, GLfloat) = NULL; +void (GL_APIENTRY *GLDispatch::glVertexAttrib2fv)(GLuint,const GLfloat*) = NULL; +void (GL_APIENTRY *GLDispatch::glVertexAttrib3f)(GLuint,GLfloat, GLfloat,GLfloat) = NULL; +void (GL_APIENTRY *GLDispatch::glVertexAttrib3fv)(GLuint,const GLfloat*) = NULL; +void (GL_APIENTRY *GLDispatch::glVertexAttrib4f)(GLuint,GLfloat,GLfloat,GLfloat,GLfloat ) = NULL; +void (GL_APIENTRY *GLDispatch::glVertexAttrib4fv)(GLuint,const GLfloat*) = NULL; +void (GL_APIENTRY *GLDispatch::glVertexAttribPointer)(GLuint,GLint,GLenum,GLboolean,GLsizei,const GLvoid*) = NULL; +void (GL_APIENTRY *GLDispatch::glDisableVertexAttribArray)(GLuint) = NULL; +void (GL_APIENTRY *GLDispatch::glEnableVertexAttribArray)(GLuint) = NULL; +void (GL_APIENTRY *GLDispatch::glGetVertexAttribfv)(GLuint,GLenum,GLfloat*) = NULL; +void (GL_APIENTRY *GLDispatch::glGetVertexAttribiv)(GLuint,GLenum,GLint*) = NULL; +void (GL_APIENTRY *GLDispatch::glGetVertexAttribPointerv)(GLuint,GLenum,GLvoid**) = NULL; +void (GL_APIENTRY *GLDispatch::glUniform1f)(GLint,GLfloat) = NULL; +void (GL_APIENTRY *GLDispatch::glUniform1fv)(GLint,GLsizei,const GLfloat*) = NULL; +void (GL_APIENTRY *GLDispatch::glUniform1i)(GLint,GLint) = NULL; +void (GL_APIENTRY *GLDispatch::glUniform1iv)(GLint,GLsizei,const GLint*) = NULL; +void (GL_APIENTRY *GLDispatch::glUniform2f)(GLint,GLfloat,GLfloat) = NULL; +void (GL_APIENTRY *GLDispatch::glUniform2fv)(GLint,GLsizei,const GLfloat*) = NULL; +void (GL_APIENTRY *GLDispatch::glUniform2i)(GLint,GLint,GLint) = NULL; +void (GL_APIENTRY *GLDispatch::glUniform2iv)(GLint ,GLsizei,const GLint*) = NULL; +void (GL_APIENTRY *GLDispatch::glUniform3f)(GLint,GLfloat,GLfloat,GLfloat) = NULL; +void (GL_APIENTRY *GLDispatch::glUniform3fv)(GLint,GLsizei,const GLfloat*) = NULL; +void (GL_APIENTRY *GLDispatch::glUniform3i)(GLint,GLint,GLint,GLint) = NULL; +void (GL_APIENTRY *GLDispatch::glUniform3iv)(GLint,GLsizei,const GLint*) = NULL; +void (GL_APIENTRY *GLDispatch::glUniform4f)(GLint,GLfloat,GLfloat,GLfloat,GLfloat) = NULL; +void (GL_APIENTRY *GLDispatch::glUniform4fv)(GLint,GLsizei,const GLfloat*) = NULL; +void (GL_APIENTRY *GLDispatch::glUniform4i)(GLint,GLint,GLint,GLint,GLint) = NULL; +void (GL_APIENTRY *GLDispatch::glUniform4iv)(GLint,GLsizei,const GLint*) = NULL; +void (GL_APIENTRY *GLDispatch::glUniformMatrix2fv)(GLint,GLsizei,GLboolean,const GLfloat*) = NULL; +void (GL_APIENTRY *GLDispatch::glUniformMatrix3fv)(GLint,GLsizei,GLboolean,const GLfloat*) = NULL; +void (GL_APIENTRY *GLDispatch::glUniformMatrix4fv)(GLint,GLsizei,GLboolean,const GLfloat*) = NULL; +void (GL_APIENTRY *GLDispatch::glGetFramebufferAttachmentParameteriv)(GLenum,GLenum,GLenum,GLint*) = NULL; +void (GL_APIENTRY *GLDispatch::glGetRenderbufferParameteriv)(GLenum,GLenum,GLint*) = NULL; +GLboolean (GL_APIENTRY *GLDispatch::glIsFramebuffer)(GLuint) = NULL; +GLboolean (GL_APIENTRY *GLDispatch::glIsRenderbuffer)(GLuint) = NULL; +GLenum (GL_APIENTRY *GLDispatch::glCheckFramebufferStatus)(GLenum) = NULL; +void (GL_APIENTRY *GLDispatch::glAttachShader)(GLuint,GLuint) = NULL; +void (GL_APIENTRY *GLDispatch::glBindAttribLocation)(GLuint,GLuint,const GLchar*) = NULL; +void (GL_APIENTRY *GLDispatch::glCompileShader)(GLuint) = NULL; +GLuint (GL_APIENTRY *GLDispatch::glCreateProgram)() = NULL; +GLuint (GL_APIENTRY *GLDispatch::glCreateShader)(GLenum) = NULL; +void (GL_APIENTRY *GLDispatch::glDeleteProgram)(GLuint) = NULL; +void (GL_APIENTRY *GLDispatch::glDeleteShader)(GLuint) = NULL; +void (GL_APIENTRY *GLDispatch::glDetachShader)(GLuint,GLuint) = NULL; +void (GL_APIENTRY *GLDispatch::glLinkProgram)(GLuint) = NULL; +void (GL_APIENTRY *GLDispatch::glUseProgram)(GLuint) = NULL; +void (GL_APIENTRY *GLDispatch::glValidateProgram)(GLuint) = NULL; +void (GL_APIENTRY *GLDispatch::glGetActiveAttrib)(GLuint,GLuint,GLsizei,GLsizei*,GLint*,GLenum*,GLchar*) = NULL; +void (GL_APIENTRY *GLDispatch::glGetActiveUniform)(GLuint,GLuint,GLsizei,GLsizei*,GLint*,GLenum*,GLchar*) = NULL; +void (GL_APIENTRY *GLDispatch::glGetAttachedShaders)(GLuint,GLsizei,GLsizei*,GLuint*) = NULL; +int (GL_APIENTRY *GLDispatch::glGetAttribLocation)(GLuint,const GLchar*) = NULL; +void (GL_APIENTRY *GLDispatch::glGetProgramiv)(GLuint,GLenum,GLint*) = NULL; +void (GL_APIENTRY *GLDispatch::glGetProgramInfoLog)(GLuint,GLsizei,GLsizei*,GLchar*) = NULL; +void (GL_APIENTRY *GLDispatch::glGetShaderiv)(GLuint,GLenum,GLint*) = NULL; +void (GL_APIENTRY *GLDispatch::glGetShaderInfoLog)(GLuint,GLsizei,GLsizei*,GLchar*) = NULL; +void (GL_APIENTRY *GLDispatch::glGetShaderPrecisionFormat)(GLenum,GLenum,GLint*,GLint*) = NULL; +void (GL_APIENTRY *GLDispatch::glGetShaderSource)(GLuint,GLsizei,GLsizei*,GLchar*) = NULL; +void (GL_APIENTRY *GLDispatch::glGetUniformfv)(GLuint,GLint,GLfloat*) = NULL; +void (GL_APIENTRY *GLDispatch::glGetUniformiv)(GLuint,GLint,GLint*) = NULL; +int (GL_APIENTRY *GLDispatch::glGetUniformLocation)(GLuint,const GLchar*) = NULL; +void (GL_APIENTRY *GLDispatch::glReleaseShaderCompiler)() = NULL; +void (GL_APIENTRY *GLDispatch::glRenderbufferStorage)(GLenum,GLenum,GLsizei,GLsizei) = NULL; +void (GL_APIENTRY *GLDispatch::glShaderBinary)(GLsizei,const GLuint*,GLenum,const GLvoid*,GLsizei) = NULL; +void (GL_APIENTRY *GLDispatch::glShaderSource)(GLuint,GLsizei,const GLchar**,const GLint*) = NULL; +void (GL_APIENTRY *GLDispatch::glFramebufferRenderbuffer)(GLenum,GLenum,GLenum,GLuint) = NULL; +void (GL_APIENTRY *GLDispatch::glFramebufferTexture2D)(GLenum,GLenum,GLenum,GLuint,GLint) = NULL; + +GLDispatch::GLDispatch():m_isLoaded(false){}; + + +void GLDispatch::dispatchFuncs(GLESVersion version){ + android::Mutex::Autolock mutex(s_lock); + if(m_isLoaded) + return; + + /* Loading OpenGL functions which are needed for implementing BOTH GLES 1.1 & GLES 2.0*/ + LOAD_GL_FUNC(glActiveTexture); + LOAD_GL_FUNC(glBindBuffer); + LOAD_GL_FUNC(glBindTexture); + LOAD_GL_FUNC(glBlendFunc); + LOAD_GL_FUNC(glBufferData); + LOAD_GL_FUNC(glBufferSubData); + LOAD_GL_FUNC(glClear); + LOAD_GL_FUNC(glClearColor); + LOAD_GL_FUNC(glClearStencil); + LOAD_GL_FUNC(glColorMask); + LOAD_GL_FUNC(glCompressedTexImage2D); + LOAD_GL_FUNC(glCompressedTexSubImage2D); + LOAD_GL_FUNC(glCopyTexImage2D); + LOAD_GL_FUNC(glCopyTexSubImage2D); + LOAD_GL_FUNC(glCullFace); + LOAD_GL_FUNC(glDeleteBuffers); + LOAD_GL_FUNC(glDeleteTextures); + LOAD_GL_FUNC(glDepthFunc); + LOAD_GL_FUNC(glDepthMask); + LOAD_GL_FUNC(glDisable); + LOAD_GL_FUNC(glDrawArrays); + LOAD_GL_FUNC(glDrawElements); + LOAD_GL_FUNC(glEnable); + LOAD_GL_FUNC(glFinish); + LOAD_GL_FUNC(glFlush); + LOAD_GL_FUNC(glFrontFace); + LOAD_GL_FUNC(glGenBuffers); + LOAD_GL_FUNC(glGenTextures); + LOAD_GL_FUNC(glGetBooleanv); + LOAD_GL_FUNC(glGetBufferParameteriv); + LOAD_GL_FUNC(glGetError); + LOAD_GL_FUNC(glGetFloatv); + LOAD_GL_FUNC(glGetIntegerv); + LOAD_GL_FUNC(glGetString); + LOAD_GL_FUNC(glGetTexParameterfv); + LOAD_GL_FUNC(glGetTexParameteriv); + LOAD_GL_FUNC(glHint); + LOAD_GL_FUNC(glIsBuffer); + LOAD_GL_FUNC(glIsEnabled); + LOAD_GL_FUNC(glIsTexture); + LOAD_GL_FUNC(glLineWidth); + LOAD_GL_FUNC(glPolygonOffset); + LOAD_GL_FUNC(glPixelStorei); + LOAD_GL_FUNC(glReadPixels); + LOAD_GL_FUNC(glSampleCoverage); + LOAD_GL_FUNC(glScissor); + LOAD_GL_FUNC(glStencilFunc); + LOAD_GL_FUNC(glStencilMask); + LOAD_GL_FUNC(glStencilOp); + LOAD_GL_FUNC(glTexImage2D); + LOAD_GL_FUNC(glTexParameteri); + LOAD_GL_FUNC(glTexParameteriv); + LOAD_GL_FUNC(glTexSubImage2D); + LOAD_GL_FUNC(glViewport); + + /* Loading OpenGL functions which are needed ONLY for implementing GLES 1.1*/ + if(version == GLES_1_1){ + LOAD_GL_FUNC(glAlphaFunc); + LOAD_GL_FUNC(glBegin); + LOAD_GL_FUNC(glClearDepth); + LOAD_GL_FUNC(glClientActiveTexture); + LOAD_GL_FUNC(glClipPlane); + LOAD_GL_FUNC(glColor4d); + LOAD_GL_FUNC(glColor4f); + LOAD_GL_FUNC(glColor4fv); + LOAD_GL_FUNC(glColor4ub); + LOAD_GL_FUNC(glColor4ubv); + LOAD_GL_FUNC(glColorPointer); + LOAD_GL_FUNC(glDepthRange); + LOAD_GL_FUNC(glDisableClientState); + LOAD_GL_FUNC(glEnableClientState); + LOAD_GL_FUNC(glEnd); + LOAD_GL_FUNC(glFogf); + LOAD_GL_FUNC(glFogfv); + LOAD_GL_FUNC(glFrustum); + LOAD_GL_FUNC(glGetClipPlane); + LOAD_GL_FUNC(glGetDoublev); + LOAD_GL_FUNC(glGetLightfv); + LOAD_GL_FUNC(glGetMaterialfv); + LOAD_GL_FUNC(glGetPointerv); + LOAD_GL_FUNC(glGetTexEnvfv); + LOAD_GL_FUNC(glGetTexEnviv); + LOAD_GL_FUNC(glLightf); + LOAD_GL_FUNC(glLightfv); + LOAD_GL_FUNC(glLightModelf); + LOAD_GL_FUNC(glLightModelfv); + LOAD_GL_FUNC(glLoadIdentity); + LOAD_GL_FUNC(glLoadMatrixf); + LOAD_GL_FUNC(glLogicOp); + LOAD_GL_FUNC(glMaterialf); + LOAD_GL_FUNC(glMaterialfv); + LOAD_GL_FUNC(glMultiTexCoord2fv); + LOAD_GL_FUNC(glMultiTexCoord2sv); + LOAD_GL_FUNC(glMultiTexCoord3fv); + LOAD_GL_FUNC(glMultiTexCoord3sv); + LOAD_GL_FUNC(glMultiTexCoord4fv); + LOAD_GL_FUNC(glMultiTexCoord4sv); + LOAD_GL_FUNC(glMultiTexCoord4f); + LOAD_GL_FUNC(glMultMatrixf); + LOAD_GL_FUNC(glNormal3f); + LOAD_GL_FUNC(glNormal3fv); + LOAD_GL_FUNC(glNormal3sv); + LOAD_GL_FUNC(glOrtho); + LOAD_GL_FUNC(glPointParameterf); + LOAD_GL_FUNC(glPointParameterfv); + LOAD_GL_FUNC(glPointSize); + LOAD_GL_FUNC(glRotatef); + LOAD_GL_FUNC(glScalef); + LOAD_GL_FUNC(glTexEnvf); + LOAD_GL_FUNC(glTexEnvfv); + LOAD_GL_FUNC(glTexParameterf); + LOAD_GL_FUNC(glTexParameterfv); + LOAD_GL_FUNC(glMatrixMode); + LOAD_GL_FUNC(glNormalPointer); + LOAD_GL_FUNC(glPopMatrix); + LOAD_GL_FUNC(glPushMatrix); + LOAD_GL_FUNC(glShadeModel); + LOAD_GL_FUNC(glTexCoordPointer); + LOAD_GL_FUNC(glTexEnvi); + LOAD_GL_FUNC(glTexEnviv); + LOAD_GL_FUNC(glTranslatef); + LOAD_GL_FUNC(glVertexPointer); + } else if (version == GLES_2_0){ + + /* Loading OpenGL functions which are needed ONLY for implementing GLES 2.0*/ + + LOAD_GL_FUNC(glBlendColor); + LOAD_GL_FUNC(glBlendEquation); + LOAD_GL_FUNC(glBlendEquationSeparate); + LOAD_GL_FUNC(glBlendFuncSeparate); + LOAD_GL_FUNC(glBlendFuncSeparate); + LOAD_GL_FUNC(glStencilFuncSeparate); + LOAD_GL_FUNC(glGenerateMipmap); + LOAD_GL_FUNC(glBindFramebuffer); + LOAD_GL_FUNC(glBindRenderbuffer); + LOAD_GL_FUNC(glDeleteFramebuffers); + LOAD_GL_FUNC(glDeleteRenderbuffers); + LOAD_GL_FUNC(glVertexAttrib1f); + LOAD_GL_FUNC(glVertexAttrib1fv); + LOAD_GL_FUNC(glVertexAttrib2f); + LOAD_GL_FUNC(glVertexAttrib2fv); + LOAD_GL_FUNC(glVertexAttrib3f); + LOAD_GL_FUNC(glVertexAttrib3fv); + LOAD_GL_FUNC(glVertexAttrib4f); + LOAD_GL_FUNC(glVertexAttrib4fv); + LOAD_GL_FUNC(glVertexAttribPointer); + LOAD_GL_FUNC(glDisableVertexAttribArray); + LOAD_GL_FUNC(glEnableVertexAttribArray); + LOAD_GL_FUNC(glGetVertexAttribfv); + LOAD_GL_FUNC(glGetVertexAttribiv); + LOAD_GL_FUNC(glGetVertexAttribPointerv); + LOAD_GL_FUNC(glIsFramebuffer); + LOAD_GL_FUNC(glIsRenderbuffer); + LOAD_GL_FUNC(glUniform1f); + LOAD_GL_FUNC(glUniform1fv); + LOAD_GL_FUNC(glUniform1i); + LOAD_GL_FUNC(glUniform1iv); + LOAD_GL_FUNC(glUniform2f); + LOAD_GL_FUNC(glUniform2fv); + LOAD_GL_FUNC(glUniform2i); + LOAD_GL_FUNC(glUniform2iv); + LOAD_GL_FUNC(glUniform3f); + LOAD_GL_FUNC(glUniform3fv); + LOAD_GL_FUNC(glUniform3i); + LOAD_GL_FUNC(glUniform3iv); + LOAD_GL_FUNC(glUniform4f); + LOAD_GL_FUNC(glUniform4fv); + LOAD_GL_FUNC(glUniform4i); + LOAD_GL_FUNC(glUniform4iv); + LOAD_GL_FUNC(glUniformMatrix2fv); + LOAD_GL_FUNC(glUniformMatrix3fv); + LOAD_GL_FUNC(glUniformMatrix4fv); + LOAD_GL_FUNC(glCheckFramebufferStatus); + LOAD_GL_FUNC(glGetFramebufferAttachmentParameteriv); + LOAD_GL_FUNC(glGetRenderbufferParameteriv); + LOAD_GL_FUNC(glAttachShader); + LOAD_GL_FUNC(glBindAttribLocation); + LOAD_GL_FUNC(glCompileShader); + LOAD_GL_FUNC(glCreateProgram); + LOAD_GL_FUNC(glCreateShader); + LOAD_GL_FUNC(glDeleteProgram); + LOAD_GL_FUNC(glDeleteShader); + LOAD_GL_FUNC(glDetachShader); + LOAD_GL_FUNC(glLinkProgram); + LOAD_GL_FUNC(glUseProgram); + LOAD_GL_FUNC(glValidateProgram); + LOAD_GL_FUNC(glGetActiveAttrib); + LOAD_GL_FUNC(glGetActiveUniform); + LOAD_GL_FUNC(glGetAttachedShaders); + LOAD_GL_FUNC(glGetAttribLocation); + LOAD_GL_FUNC(glGetProgramiv); + LOAD_GL_FUNC(glGetProgramInfoLog); + LOAD_GL_FUNC(glGetShaderiv); + LOAD_GL_FUNC(glGetShaderInfoLog); + LOAD_GL_FUNC(glGetShaderPrecisionFormat); + LOAD_GL_FUNC(glGetShaderSource); + LOAD_GL_FUNC(glGetUniformfv); + LOAD_GL_FUNC(glGetUniformiv); + LOAD_GL_FUNC(glGetUniformLocation); + LOAD_GL_FUNC(glReleaseShaderCompiler); + LOAD_GL_FUNC(glRenderbufferStorage); + LOAD_GL_FUNC(glShaderBinary); + LOAD_GL_FUNC(glShaderSource); + LOAD_GL_FUNC(glFramebufferRenderbuffer); + LOAD_GL_FUNC(glFramebufferTexture2D); + } + m_isLoaded = true; +} diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESbuffer.cpp b/tools/emulator/opengl/host/libs/Translator/GLcommon/GLESbuffer.cpp similarity index 97% rename from tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESbuffer.cpp rename to tools/emulator/opengl/host/libs/Translator/GLcommon/GLESbuffer.cpp index 531e79d0f..b055cc7c0 100644 --- a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESbuffer.cpp +++ b/tools/emulator/opengl/host/libs/Translator/GLcommon/GLESbuffer.cpp @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "GLESbuffer.h" +#include #include bool GLESbuffer::setBuffer(GLuint size,GLuint usage,const GLvoid* data) { diff --git a/tools/emulator/opengl/host/libs/Translator/GLcommon/GLEScontext.cpp b/tools/emulator/opengl/host/libs/Translator/GLcommon/GLEScontext.cpp new file mode 100644 index 000000000..4e48e00d6 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/GLcommon/GLEScontext.cpp @@ -0,0 +1,317 @@ +#include +#include + +//decleration +static int findMaxIndex(GLsizei count,GLenum type,const GLvoid* indices); +static void convertDirectLoop(const char* dataIn,unsigned int strideIn,void* dataOut,unsigned int nBytes,unsigned int strideOut,int attribSize); +static void convertIndirectLoop(const char* dataIn,unsigned int strideIn,void* dataOut,GLsizei count,GLenum indices_type,const GLvoid* indices,unsigned int strideOut,int attribSize); + +GLESFloatArrays::~GLESFloatArrays() { + for(std::map::iterator it = arrays.begin(); it != arrays.end();it++) { + GLfloat* p = (*it).second; + if(p) { + delete[] p; + } + } +} + +GLDispatch GLEScontext::s_glDispatch; +android::Mutex GLEScontext::s_lock; + +GLEScontext::GLEScontext(): + m_initialized(false) , + m_activeTexture(0) , + m_glError(GL_NO_ERROR) , + m_arrayBuffer(0) , + m_elementBuffer(0){}; + + +GLenum GLEScontext::getGLerror() { + return m_glError; +} + +void GLEScontext::setGLerror(GLenum err) { + m_glError = err; +} + +void GLEScontext::setActiveTexture(GLenum tex) { + m_activeTexture = tex - GL_TEXTURE0; +} + +GLEScontext::~GLEScontext() { + for(ArraysMap::iterator it = m_map.begin(); it != m_map.end();it++) { + GLESpointer* p = (*it).second; + if(p) { + delete p; + } + } +} + +const GLvoid* GLEScontext::setPointer(GLenum arrType,GLint size,GLenum type,GLsizei stride,const GLvoid* data,bool normalize) { + GLuint bufferName = m_arrayBuffer; + if(bufferName) { + unsigned int offset = reinterpret_cast(data); + GLESbuffer* vbo = static_cast(m_shareGroup->getObjectData(VERTEXBUFFER,bufferName).Ptr()); + m_map[arrType]->setBuffer(size,type,stride,vbo,offset,normalize); + return static_cast(vbo->getData()) + offset; + } + m_map[arrType]->setArray(size,type,stride,data,normalize); + return data; +} + +void GLEScontext::enableArr(GLenum arr,bool enable) { + m_map[arr]->enable(enable); +} + +bool GLEScontext::isArrEnabled(GLenum arr) { + return m_map[arr]->isEnable(); +} + +const GLESpointer* GLEScontext::getPointer(GLenum arrType) { + if(m_map.find(arrType) != m_map.end()) return m_map[arrType]; + return NULL; +} + +static void convertDirectLoop(const char* dataIn,unsigned int strideIn,void* dataOut,unsigned int nBytes,unsigned int strideOut,int attribSize) { + + for(unsigned int i = 0; i < nBytes;i+=strideOut) { + const GLfixed* fixed_data = (const GLfixed *)dataIn; + //filling attrib + for(int j=0;j(&static_cast(dataOut)[i])[j] = X2F(fixed_data[j]); + } + dataIn += strideIn; + } +} + +static void convertIndirectLoop(const char* dataIn,unsigned int strideIn,void* dataOut,GLsizei count,GLenum indices_type,const GLvoid* indices,unsigned int strideOut,int attribSize) { + for(int i = 0 ;i < count ;i++) { + unsigned short index = indices_type == GL_UNSIGNED_BYTE? ((GLubyte *)indices)[i]: + ((GLushort *)indices)[i]; + const GLfixed* fixed_data = (GLfixed *)(dataIn + index*strideIn); + GLfloat* float_data = reinterpret_cast(static_cast(dataOut) + index*strideOut); + + for(int j=0;jgetSize()*4; //4 is the sizeof GLfixed or GLfloat in bytes + int stride = p->getStride()?p->getStride():attribSize; + int start = p->getBufferOffset()+first*attribSize; + if(!p->getStride()) { + list.addRange(Range(start,count*attribSize)); + } else { + for(int i = 0 ;i < count; i++,start+=stride) { + list.addRange(Range(start,attribSize)); + } + } +} + +static void indirectToBytesRanges(const GLvoid* indices,GLenum indices_type,GLsizei count,GLESpointer* p,RangeList& list) { + + int attribSize = p->getSize() * 4; //4 is the sizeof GLfixed or GLfloat in bytes + int stride = p->getStride()?p->getStride():attribSize; + int start = p->getBufferOffset(); + for(int i=0 ; i < count; i++) { + GLushort index = (indices_type == GL_UNSIGNED_SHORT? + static_cast(indices)[i]: + static_cast(indices)[i]); + list.addRange(Range(start+index*stride,attribSize)); + + } +} + +int bytesRangesToIndices(RangeList& ranges,GLESpointer* p,GLushort* indices) { + + int attribSize = p->getSize() * 4; //4 is the sizeof GLfixed or GLfloat in bytes + int stride = p->getStride()?p->getStride():attribSize; + int offset = p->getBufferOffset(); + + int n = 0; + for(int i=0;igetType(); + if(isArrEnabled(array_id) && type == GL_FIXED) { + int attribSize = p->getSize(); + unsigned int size = attribSize*count + first; + fArrs.arrays[index] = new GLfloat[size]; + int stride = p->getStride()?p->getStride():sizeof(GLfixed)*attribSize; + const char* data = (const char*)p->getArrayData() + (first*stride); + + convertDirectLoop(data,stride,fArrs.arrays[index],size*sizeof(GLfloat),attribSize*sizeof(GLfloat),attribSize); + sendArr(fArrs.arrays[index],array_id,attribSize,0,index); + index++; + } +} + +void GLEScontext::convertDirectVBO(GLint first,GLsizei count,GLenum array_id,GLESpointer* p) { + GLenum type = p->getType(); + if(isArrEnabled(array_id) && type == GL_FIXED) { + RangeList ranges; + RangeList conversions; + GLushort* indices = NULL; + int attribSize = p->getSize(); + int stride = p->getStride()?p->getStride():sizeof(GLfixed)*attribSize; + unsigned int size = p->getStride()?p->getStride()*count:attribSize*count*sizeof(GLfixed); + char* data = (char*)p->getBufferData() + (first*stride); + + if(p->bufferNeedConversion()) { + directToBytesRanges(first,count,p,ranges); //converting indices range to buffer bytes ranges by offset + p->getBufferConversions(ranges,conversions); // getting from the buffer the relevant ranges that still needs to be converted + + if(conversions.size()) { // there are some elements to convert + indices = new GLushort[count]; + int nIndices = bytesRangesToIndices(conversions,p,indices); //converting bytes ranges by offset to indices in this array + convertIndirectLoop(data,stride,data,nIndices,GL_UNSIGNED_SHORT,indices,stride,attribSize); + } + } + + sendArr(data,array_id,attribSize,p->getStride()); + if(indices) delete[] indices; + } +} + +static int findMaxIndex(GLsizei count,GLenum type,const GLvoid* indices) { + //finding max index + int max = 0; + if(type == GL_UNSIGNED_BYTE) { + GLubyte* b_indices =(GLubyte *)indices; + for(int i=0;i max) max = b_indices[i]; + } + } else { + GLushort* us_indices =(GLushort *)indices; + for(int i=0;i max) max = us_indices[i]; + } + } + return max; +} + +void GLEScontext::convertIndirect(GLESFloatArrays& fArrs,GLsizei count,GLenum indices_type,const GLvoid* indices,GLenum array_id,GLESpointer* p,unsigned int& index_out) { + GLenum type = p->getType(); + int maxElements = findMaxIndex(count,type,indices) + 1; + + if(isArrEnabled(array_id) && type == GL_FIXED) { + int attribSize = p->getSize(); + int size = attribSize * maxElements; + fArrs.arrays[index_out] = new GLfloat[size]; + int stride = p->getStride()?p->getStride():sizeof(GLfixed)*attribSize; + + const char* data = (const char*)p->getArrayData(); + convertIndirectLoop(data,stride,fArrs.arrays[index_out],count,indices_type,indices,attribSize*sizeof(GLfloat),attribSize); + sendArr(fArrs.arrays[index_out],array_id,attribSize,0,index_out); + index_out++; + } +} + +void GLEScontext::convertIndirectVBO(GLsizei count,GLenum indices_type,const GLvoid* indices,GLenum array_id,GLESpointer* p) { + GLenum type = p->getType(); + + if(isArrEnabled(array_id) && type == GL_FIXED) { + RangeList ranges; + RangeList conversions; + GLushort* conversionIndices = NULL; + int attribSize = p->getSize(); + int stride = p->getStride()?p->getStride():sizeof(GLfixed)*attribSize; + char* data = static_cast(p->getBufferData()); + if(p->bufferNeedConversion()) { + indirectToBytesRanges(indices,indices_type,count,p,ranges); //converting indices range to buffer bytes ranges by offset + p->getBufferConversions(ranges,conversions); // getting from the buffer the relevant ranges that still needs to be converted + if(conversions.size()) { // there are some elements to convert + conversionIndices = new GLushort[count]; + int nIndices = bytesRangesToIndices(conversions,p,conversionIndices); //converting bytes ranges by offset to indices in this array + convertIndirectLoop(data,stride,data,nIndices,GL_UNSIGNED_SHORT,conversionIndices,stride,attribSize); + } + } + sendArr(data,array_id,attribSize,p->getStride()); + if(conversionIndices) delete[] conversionIndices; + } +} + +void GLEScontext::chooseConvertMethod(GLESFloatArrays& fArrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices,bool direct,GLESpointer* p,GLenum array_id, unsigned int& index) { + + bool vertexVBO = m_arrayBuffer!= 0; + if(direct) { + if(vertexVBO) { + convertDirectVBO(first,count,array_id,p); + } else { + convertDirect(fArrs,first,count,array_id,p,index); + } + } else { + if(vertexVBO) { + convertIndirectVBO(count,type,indices,array_id,p); + } else { + convertIndirect(fArrs,count,type,indices,array_id,p,index); + } + } +} + + +void GLEScontext::bindBuffer(GLenum target,GLuint buffer) { + if(target == GL_ARRAY_BUFFER) { + m_arrayBuffer = buffer; + } else { + m_elementBuffer = buffer; + } +} + +//checks if any buffer is binded to target +bool GLEScontext::isBindedBuffer(GLenum target) { + if(target == GL_ARRAY_BUFFER) { + return m_arrayBuffer != 0; + } else { + return m_elementBuffer != 0; + } +} + +GLuint GLEScontext::getBuffer(GLenum target) { + return target == GL_ARRAY_BUFFER ? m_arrayBuffer:m_elementBuffer; +} + +GLvoid* GLEScontext::getBindedBuffer(GLenum target) { + GLuint bufferName = getBuffer(target); + if(!bufferName) return NULL; + + GLESbuffer* vbo = static_cast(m_shareGroup->getObjectData(VERTEXBUFFER,bufferName).Ptr()); + return vbo->getData(); +} + +void GLEScontext::getBufferSize(GLenum target,GLint* param) { + GLuint bufferName = getBuffer(target); + GLESbuffer* vbo = static_cast(m_shareGroup->getObjectData(VERTEXBUFFER,bufferName).Ptr()); + *param = vbo->getSize(); +} + +void GLEScontext::getBufferUsage(GLenum target,GLint* param) { + GLuint bufferName = getBuffer(target); + GLESbuffer* vbo = static_cast(m_shareGroup->getObjectData(VERTEXBUFFER,bufferName).Ptr()); + *param = vbo->getUsage(); +} + +bool GLEScontext::setBufferData(GLenum target,GLsizeiptr size,const GLvoid* data,GLenum usage) { + GLuint bufferName = getBuffer(target); + if(!bufferName) return false; + GLESbuffer* vbo = static_cast(m_shareGroup->getObjectData(VERTEXBUFFER,bufferName).Ptr()); + return vbo->setBuffer(size,usage,data); +} + +bool GLEScontext::setBufferSubData(GLenum target,GLintptr offset,GLsizeiptr size,const GLvoid* data) { + + GLuint bufferName = getBuffer(target); + if(!bufferName) return false; + GLESbuffer* vbo = static_cast(m_shareGroup->getObjectData(VERTEXBUFFER,bufferName).Ptr()); + return vbo->setSubBuffer(offset,size,data); +} diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESpointer.cpp b/tools/emulator/opengl/host/libs/Translator/GLcommon/GLESpointer.cpp similarity index 74% rename from tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESpointer.cpp rename to tools/emulator/opengl/host/libs/Translator/GLcommon/GLESpointer.cpp index 55b4dcdfa..d297a7cb2 100644 --- a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESpointer.cpp +++ b/tools/emulator/opengl/host/libs/Translator/GLcommon/GLESpointer.cpp @@ -13,10 +13,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "GLESpointer.h" +#include #include -GLESpointer::GLESpointer():m_size(0),m_type(0),m_stride(0),m_enabled(false),m_data(NULL),m_buffer(NULL),m_buffOffset(0){}; +GLESpointer::GLESpointer():m_size(0), + m_type(0), + m_stride(0), + m_enabled(false), + m_normalize(false), + m_data(NULL), + m_buffer(NULL), + m_buffOffset(0){}; GLenum GLESpointer:: getType() const { @@ -49,25 +56,31 @@ bool GLESpointer::isEnable() const { return m_enabled; } +bool GLESpointer::isNormalize() const { + return m_normalize; +} + void GLESpointer::enable(bool b) { m_enabled = b; } -void GLESpointer::setArray(GLint size,GLenum type,GLsizei stride,const GLvoid* data) { +void GLESpointer::setArray(GLint size,GLenum type,GLsizei stride,const GLvoid* data,bool normalize) { m_size = size; m_type = type; m_stride = stride; m_data = data; m_buffer = NULL; + m_normalize = normalize; } -void GLESpointer::setBuffer(GLint size,GLenum type,GLsizei stride,GLESbuffer* buf,int offset) { +void GLESpointer::setBuffer(GLint size,GLenum type,GLsizei stride,GLESbuffer* buf,int offset,bool normalize) { m_size = size; m_type = type; m_stride = stride; m_data = NULL; m_buffer = buf; m_buffOffset = offset; + m_normalize = normalize; } void GLESpointer::getBufferConversions(const RangeList& rl,RangeList& rlOut) { diff --git a/tools/emulator/opengl/host/libs/Translator/GLcommon/GLESvalidate.cpp b/tools/emulator/opengl/host/libs/Translator/GLcommon/GLESvalidate.cpp new file mode 100644 index 000000000..cfb5b4dd7 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/GLcommon/GLESvalidate.cpp @@ -0,0 +1,66 @@ +#include + + +bool GLESvalidate::textureEnum(GLenum e,unsigned int maxTex) { + return e >= GL_TEXTURE0 && e <= (GL_TEXTURE0 + maxTex); +} + +bool GLESvalidate::pixelType(GLenum type) { + switch(type) { + case GL_UNSIGNED_BYTE: + case GL_UNSIGNED_SHORT_5_6_5: + case GL_UNSIGNED_SHORT_4_4_4_4: + case GL_UNSIGNED_SHORT_5_5_5_1: + return true; + } + return false; +} + +bool GLESvalidate::pixelOp(GLenum format,GLenum type) { + switch(type) { + case GL_UNSIGNED_SHORT_4_4_4_4: + case GL_UNSIGNED_SHORT_5_5_5_1: + return format == GL_RGBA; + case GL_UNSIGNED_SHORT_5_6_5: + return format == GL_RGB; + } + return true; +} + +bool GLESvalidate::pixelFrmt(GLenum format) { + switch(format) { + case GL_ALPHA: + case GL_RGB: + case GL_RGBA: + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + return true; + } + return false; +} + +bool GLESvalidate::bufferTarget(GLenum target) { + return target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER; +} + +bool GLESvalidate::bufferParam(GLenum param) { + return (param == GL_BUFFER_SIZE) || (param == GL_BUFFER_USAGE); +} + +bool GLESvalidate::drawMode(GLenum mode) { + switch(mode) { + case GL_POINTS: + case GL_LINE_STRIP: + case GL_LINE_LOOP: + case GL_LINES: + case GL_TRIANGLE_STRIP: + case GL_TRIANGLE_FAN: + case GL_TRIANGLES: + return true; + } + return false; +} + +bool GLESvalidate::drawType(GLenum mode) { + return mode == GL_UNSIGNED_BYTE || mode == GL_UNSIGNED_SHORT; +} diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_CM/RangeManip.cpp b/tools/emulator/opengl/host/libs/Translator/GLcommon/RangeManip.cpp similarity index 99% rename from tools/emulator/opengl/host/libs/Translator/GLES_CM/RangeManip.cpp rename to tools/emulator/opengl/host/libs/Translator/GLcommon/RangeManip.cpp index 6c41e6f0e..96e0970e9 100644 --- a/tools/emulator/opengl/host/libs/Translator/GLES_CM/RangeManip.cpp +++ b/tools/emulator/opengl/host/libs/Translator/GLcommon/RangeManip.cpp @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "RangeManip.h" +#include bool Range::rangeIntersection(const Range& r,Range& rOut) const { diff --git a/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLDispatch.h b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLDispatch.h new file mode 100644 index 000000000..7c2ef0ef0 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLDispatch.h @@ -0,0 +1,248 @@ +/* +* 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 GLDISPATCHH +#define GLDISPATCHH + +#include +#include +#include +#include "GLutils.h" + +#define GLAPIENTRY GL_APIENTRY + +typedef double GLclampd; /* double precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ + +typedef void(*FUNCPTR)(); + + +class GLDispatch +{ +public: + + GLDispatch(); + void dispatchFuncs(GLESVersion version); + + /* OpenGL functions which are needed for implementing BOTH GLES 1.1 & GLES 2.0*/ + static void (GLAPIENTRY *glActiveTexture) ( GLenum texture ); + static void (GLAPIENTRY *glBindBuffer) (GLenum target, GLuint buffer); + static void (GLAPIENTRY *glBindTexture) (GLenum target, GLuint texture); + static void (GLAPIENTRY *glBlendFunc) (GLenum sfactor, GLenum dfactor); + static void (GLAPIENTRY *glBufferData) (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage); + static void (GLAPIENTRY *glBufferSubData) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data); + static void (GLAPIENTRY *glClear) (GLbitfield mask); + static void (GLAPIENTRY *glClearColor) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); + static void (GLAPIENTRY *glClearStencil) (GLint s); + static void (GLAPIENTRY *glColorMask) (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); + static void (GLAPIENTRY *glCompressedTexImage2D) ( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data ); + static void (GLAPIENTRY *glCompressedTexSubImage2D) ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data ); + static void (GLAPIENTRY *glCopyTexImage2D) (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); + static void (GLAPIENTRY *glCopyTexSubImage2D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); + static void (GLAPIENTRY *glCullFace) (GLenum mode); + static void (GLAPIENTRY *glDeleteBuffers) (GLsizei n, const GLuint *buffers); + static void (GLAPIENTRY *glDeleteTextures) (GLsizei n, const GLuint *textures); + static void (GLAPIENTRY *glDepthFunc) (GLenum func); + static void (GLAPIENTRY *glDepthMask) (GLboolean flag); + static void (GLAPIENTRY *glDisable) (GLenum cap); + static void (GLAPIENTRY *glDrawArrays) (GLenum mode, GLint first, GLsizei count); + static void (GLAPIENTRY *glDrawElements) (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices); + static void (GLAPIENTRY *glEnable) (GLenum cap); + static void (GLAPIENTRY *glFinish) (void); + static void (GLAPIENTRY *glFlush) (void); + static void (GLAPIENTRY *glFrontFace) (GLenum mode); + static void (GLAPIENTRY *glGenBuffers) (GLsizei n, GLuint *buffers); + static void (GLAPIENTRY *glGenTextures) (GLsizei n, GLuint *textures); + static void (GLAPIENTRY *glGetBooleanv) (GLenum pname, GLboolean *params); + static void (GLAPIENTRY *glGetBufferParameteriv) (GLenum, GLenum, GLint *); + static GLenum (GLAPIENTRY *glGetError) (void); + static void (GLAPIENTRY *glGetFloatv) (GLenum pname, GLfloat *params); + static void (GLAPIENTRY *glGetIntegerv) (GLenum pname, GLint *params); + static const GLubyte * (GLAPIENTRY *glGetString) (GLenum name); + static void (GLAPIENTRY *glGetTexParameterfv) (GLenum target, GLenum pname, GLfloat *params); + static void (GLAPIENTRY *glGetTexParameteriv) (GLenum target, GLenum pname, GLint *params); + static void (GLAPIENTRY *glHint) (GLenum target, GLenum mode); + static GLboolean (GLAPIENTRY *glIsBuffer) (GLuint); + static GLboolean (GLAPIENTRY *glIsEnabled) (GLenum cap); + static GLboolean (GLAPIENTRY *glIsTexture) (GLuint texture); + static void (GLAPIENTRY *glLineWidth) (GLfloat width); + static void (GLAPIENTRY *glPolygonOffset) (GLfloat factor, GLfloat units); + static void (GLAPIENTRY *glPixelStorei) (GLenum pname, GLint param); + static void (GLAPIENTRY *glReadPixels) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels); + static void (GLAPIENTRY *glSampleCoverage) ( GLclampf value, GLboolean invert ); + static void (GLAPIENTRY *glScissor) (GLint x, GLint y, GLsizei width, GLsizei height); + static void (GLAPIENTRY *glStencilFunc) (GLenum func, GLint ref, GLuint mask); + static void (GLAPIENTRY *glStencilMask) (GLuint mask); + static void (GLAPIENTRY *glStencilOp) (GLenum fail, GLenum zfail, GLenum zpass); + static void (GLAPIENTRY *glTexImage2D) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels); + static void (GLAPIENTRY *glTexParameteri) (GLenum target, GLenum pname, GLint param); + static void (GLAPIENTRY *glTexParameteriv) (GLenum target, GLenum pname, const GLint *params); + static void (GLAPIENTRY *glTexSubImage2D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); + static void (GLAPIENTRY *glViewport) (GLint x, GLint y, GLsizei width, GLsizei height); + + /* OpenGL functions which are needed ONLY for implementing GLES 1.1*/ + static void (GLAPIENTRY *glAlphaFunc) (GLenum func, GLclampf ref); + static void (GLAPIENTRY *glBegin)( GLenum mode ); + static void (GLAPIENTRY *glClearDepth) (GLclampd depth); + static void (GLAPIENTRY *glClientActiveTexture) ( GLenum texture ); + static void (GLAPIENTRY *glClipPlane) (GLenum plane, const GLdouble *equation); + static void (GLAPIENTRY *glColor4d) (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); + static void (GLAPIENTRY *glColor4f) (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + static void (GLAPIENTRY *glColor4fv) ( const GLfloat *v ); + static void (GLAPIENTRY *glColor4ub) (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); + static void (GLAPIENTRY *glColor4ubv) ( const GLubyte *v ); + static void (GLAPIENTRY *glColorPointer) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); + static void (GLAPIENTRY *glDepthRange) (GLclampd zNear, GLclampd zFar); + static void (GLAPIENTRY *glDisableClientState) (GLenum array); + static void (GLAPIENTRY *glEnableClientState) (GLenum array); + static void (GLAPIENTRY *glEnd) (void); + static void (GLAPIENTRY *glFogf) (GLenum pname, GLfloat param); + static void (GLAPIENTRY *glFogfv) (GLenum pname, const GLfloat *params); + static void (GLAPIENTRY *glFrustum) (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); + static void (GLAPIENTRY *glGetClipPlane) (GLenum plane, GLdouble *equation); + static void (GLAPIENTRY *glGetDoublev) ( GLenum pname, GLdouble *params ); + static void (GLAPIENTRY *glGetLightfv) (GLenum light, GLenum pname, GLfloat *params); + static void (GLAPIENTRY *glGetMaterialfv) (GLenum face, GLenum pname, GLfloat *params); + static void (GLAPIENTRY *glGetPointerv) (GLenum pname, GLvoid* *params); + static void (GLAPIENTRY *glGetTexEnvfv) (GLenum target, GLenum pname, GLfloat *params); + static void (GLAPIENTRY *glGetTexEnviv) (GLenum target, GLenum pname, GLint *params); + static void (GLAPIENTRY *glLightf) (GLenum light, GLenum pname, GLfloat param); + static void (GLAPIENTRY *glLightfv) (GLenum light, GLenum pname, const GLfloat *params); + static void (GLAPIENTRY *glLightModelf) (GLenum pname, GLfloat param); + static void (GLAPIENTRY *glLightModelfv) (GLenum pname, const GLfloat *params); + static void (GLAPIENTRY *glLoadIdentity) (void); + static void (GLAPIENTRY *glLoadMatrixf) (const GLfloat *m); + static void (GLAPIENTRY *glLogicOp) (GLenum opcode); + static void (GLAPIENTRY *glMaterialf) (GLenum face, GLenum pname, GLfloat param); + static void (GLAPIENTRY *glMaterialfv) (GLenum face, GLenum pname, const GLfloat *params); + static void (GLAPIENTRY *glMultiTexCoord2fv) ( GLenum target, const GLfloat *v ); + static void (GLAPIENTRY *glMultiTexCoord2sv) ( GLenum target, const GLshort *v ); + static void (GLAPIENTRY *glMultiTexCoord3fv) ( GLenum target, const GLfloat *v ); + static void (GLAPIENTRY *glMultiTexCoord3sv) ( GLenum target, const GLshort *v ); + static void (GLAPIENTRY *glMultiTexCoord4f) ( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ); + static void (GLAPIENTRY *glMultiTexCoord4fv) ( GLenum target, const GLfloat *v ); + static void (GLAPIENTRY *glMultiTexCoord4sv) ( GLenum target, const GLshort *v ); + static void (GLAPIENTRY *glMultMatrixf) (const GLfloat *m); + static void (GLAPIENTRY *glNormal3f) (GLfloat nx, GLfloat ny, GLfloat nz); + static void (GLAPIENTRY *glNormal3fv) ( const GLfloat *v ); + static void (GLAPIENTRY *glNormal3sv) ( const GLshort *v ); + static void (GLAPIENTRY *glOrtho) (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); + static void (GLAPIENTRY *glPointParameterf) (GLenum, GLfloat); + static void (GLAPIENTRY *glPointParameterfv) (GLenum, const GLfloat *); + static void (GLAPIENTRY *glPointSize) (GLfloat size); + static void (GLAPIENTRY *glRotatef) (GLfloat angle, GLfloat x, GLfloat y, GLfloat z); + static void (GLAPIENTRY *glScalef) (GLfloat x, GLfloat y, GLfloat z); + static void (GLAPIENTRY *glTexEnvf) (GLenum target, GLenum pname, GLfloat param); + static void (GLAPIENTRY *glTexEnvfv) (GLenum target, GLenum pname, const GLfloat *params); + static void (GLAPIENTRY *glTexParameterf) (GLenum target, GLenum pname, GLfloat param); + static void (GLAPIENTRY *glTexParameterfv) (GLenum target, GLenum pname, const GLfloat *params); + static void (GLAPIENTRY *glMatrixMode) (GLenum mode); + static void (GLAPIENTRY *glNormalPointer) (GLenum type, GLsizei stride, const GLvoid *pointer); + static void (GLAPIENTRY *glPopMatrix) (void); + static void (GLAPIENTRY *glPushMatrix) (void); + static void (GLAPIENTRY *glShadeModel) (GLenum mode); + static void (GLAPIENTRY *glTexCoordPointer) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); + static void (GLAPIENTRY *glTexEnvi) (GLenum target, GLenum pname, GLint param); + static void (GLAPIENTRY *glTexEnviv) (GLenum target, GLenum pname, const GLint *params); + static void (GLAPIENTRY *glTranslatef) (GLfloat x, GLfloat y, GLfloat z); + static void (GLAPIENTRY *glVertexPointer) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); + + /* Loading OpenGL functions which are needed ONLY for implementing GLES 2.0*/ + static void (GL_APIENTRY *glBlendColor) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); + static void (GL_APIENTRY *glBlendEquation)( GLenum mode ); + static void (GL_APIENTRY *glBlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha); + static void (GL_APIENTRY *glBlendFuncSeparate)(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); + static void (GL_APIENTRY *glStencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask); + static void (GL_APIENTRY *glStencilMaskSeparate)(GLenum face, GLuint mask); + static void (GL_APIENTRY *glGenerateMipmap)(GLenum target); + static void (GL_APIENTRY *glBindFramebuffer)(GLenum target, GLuint framebuffer); + static void (GL_APIENTRY *glBindRenderbuffer)(GLenum target, GLuint renderbuffer); + static void (GL_APIENTRY *glDeleteFramebuffers)(GLsizei n, const GLuint* framebuffers); + static void (GL_APIENTRY *glDeleteRenderbuffers)(GLsizei n, const GLuint* renderbuffers); + static void (GL_APIENTRY *glVertexAttrib1f)(GLuint indx, GLfloat x); + static void (GL_APIENTRY *glVertexAttrib1fv)(GLuint indx, const GLfloat* values); + static void (GL_APIENTRY *glVertexAttrib2f)(GLuint indx, GLfloat x, GLfloat y); + static void (GL_APIENTRY *glVertexAttrib2fv)(GLuint indx, const GLfloat* values); + static void (GL_APIENTRY *glVertexAttrib3f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z); + static void (GL_APIENTRY *glVertexAttrib3fv)(GLuint indx, const GLfloat* values); + static void (GL_APIENTRY *glVertexAttrib4f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + static void (GL_APIENTRY *glVertexAttrib4fv)(GLuint indx, const GLfloat* values); + static void (GL_APIENTRY *glVertexAttribPointer)(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr); + static void (GL_APIENTRY *glDisableVertexAttribArray)(GLuint index); + static void (GL_APIENTRY *glEnableVertexAttribArray)(GLuint index); + static void (GL_APIENTRY *glGetVertexAttribfv)(GLuint index, GLenum pname, GLfloat* params); + static void (GL_APIENTRY *glGetVertexAttribiv)(GLuint index, GLenum pname, GLint* params); + static void (GL_APIENTRY *glGetVertexAttribPointerv)(GLuint index, GLenum pname, GLvoid** pointer); + static void (GL_APIENTRY *glUniform1f)(GLint location, GLfloat x); + static void (GL_APIENTRY *glUniform1fv)(GLint location, GLsizei count, const GLfloat* v); + static void (GL_APIENTRY *glUniform1i)(GLint location, GLint x); + static void (GL_APIENTRY *glUniform1iv)(GLint location, GLsizei count, const GLint* v); + static void (GL_APIENTRY *glUniform2f)(GLint location, GLfloat x, GLfloat y); + static void (GL_APIENTRY *glUniform2fv)(GLint location, GLsizei count, const GLfloat* v); + static void (GL_APIENTRY *glUniform2i)(GLint location, GLint x, GLint y); + static void (GL_APIENTRY *glUniform2iv)(GLint location, GLsizei count, const GLint* v); + static void (GL_APIENTRY *glUniform3f)(GLint location, GLfloat x, GLfloat y, GLfloat z); + static void (GL_APIENTRY *glUniform3fv)(GLint location, GLsizei count, const GLfloat* v); + static void (GL_APIENTRY *glUniform3i)(GLint location, GLint x, GLint y, GLint z); + static void (GL_APIENTRY *glUniform3iv)(GLint location, GLsizei count, const GLint* v); + static void (GL_APIENTRY *glUniform4f)(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + static void (GL_APIENTRY *glUniform4fv)(GLint location, GLsizei count, const GLfloat* v); + static void (GL_APIENTRY *glUniform4i)(GLint location, GLint x, GLint y, GLint z, GLint w); + static void (GL_APIENTRY *glUniform4iv)(GLint location, GLsizei count, const GLint* v); + static void (GL_APIENTRY *glUniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); + static void (GL_APIENTRY *glUniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); + static void (GL_APIENTRY *glUniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); + static void (GL_APIENTRY *glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint* params); + static void (GL_APIENTRY *glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint* params); + static GLboolean (GL_APIENTRY *glIsFramebuffer)(GLuint framebuffer); + static GLboolean (GL_APIENTRY *glIsRenderbuffer)(GLuint renderbuffer); + static GLenum (GL_APIENTRY *glCheckFramebufferStatus)(GLenum target); + static void (GL_APIENTRY *glAttachShader)(GLuint program, GLuint shader); + static void (GL_APIENTRY *glBindAttribLocation)(GLuint program, GLuint index, const GLchar* name); + static void (GL_APIENTRY *glCompileShader)(GLuint shader); + static GLuint (GL_APIENTRY *glCreateProgram)(void); + static GLuint (GL_APIENTRY *glCreateShader)(GLenum type); + static void (GL_APIENTRY *glDeleteProgram)(GLuint program); + static void (GL_APIENTRY *glDeleteShader)(GLuint shader); + static void (GL_APIENTRY *glDetachShader)(GLuint program, GLuint shader); + static void (GL_APIENTRY *glLinkProgram)(GLuint program); + static void (GL_APIENTRY *glUseProgram)(GLuint program); + static void (GL_APIENTRY *glValidateProgram)(GLuint program); + static void (GL_APIENTRY *glGetActiveAttrib)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name); + static void (GL_APIENTRY *glGetActiveUniform)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name); + static void (GL_APIENTRY *glGetAttachedShaders)(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders); + static int (GL_APIENTRY *glGetAttribLocation)(GLuint program, const GLchar* name); + static void (GL_APIENTRY *glGetProgramiv)(GLuint program, GLenum pname, GLint* params); + static void (GL_APIENTRY *glGetProgramInfoLog)(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog); + static void (GL_APIENTRY *glGetShaderiv)(GLuint shader, GLenum pname, GLint* params); + static void (GL_APIENTRY *glGetShaderInfoLog)(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog); + static void (GL_APIENTRY *glGetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision); + static void (GL_APIENTRY *glGetShaderSource)(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source); + static void (GL_APIENTRY *glGetUniformfv)(GLuint program, GLint location, GLfloat* params); + static void (GL_APIENTRY *glGetUniformiv)(GLuint program, GLint location, GLint* params); + static int (GL_APIENTRY *glGetUniformLocation)(GLuint program, const GLchar* name); + static void (GL_APIENTRY *glReleaseShaderCompiler)(void); + static void (GL_APIENTRY *glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); + static void (GL_APIENTRY *glShaderBinary)(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length); + static void (GL_APIENTRY *glShaderSource)(GLuint shader, GLsizei count, const GLchar** string, const GLint* length); + static void (GL_APIENTRY *glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); + static void (GL_APIENTRY *glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); + +private: + bool m_isLoaded; + static android::Mutex s_lock; +}; + +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESbuffer.h b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLESbuffer.h similarity index 97% rename from tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESbuffer.h rename to tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLESbuffer.h index 5c4ce7878..f4dcc7a8f 100644 --- a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESbuffer.h +++ b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLESbuffer.h @@ -19,7 +19,7 @@ #include #include #include -#include "RangeManip.h" +#include class GLESbuffer: public ObjectData { public: diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScontext.h b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLEScontext.h similarity index 52% rename from tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScontext.h rename to tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLEScontext.h index 5291a523f..ee873fab1 100644 --- a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLEScontext.h +++ b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLEScontext.h @@ -1,32 +1,14 @@ -/* -* 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 GLES_CONTEX_H -#define GLES_CONTEX_H +#ifndef GLES_CONTEXT_H +#define GLES_CONTEXT_H #include "GLDispatch.h" #include "GLESpointer.h" -#include "GLESbuffer.h" -#include -#include +#include "objectNameManager.h" #include #define MAX_TEX_UNITS 8 typedef std::map ArraysMap; -typedef std::map > PointSizeIndices; struct GLESFloatArrays { @@ -35,35 +17,22 @@ struct GLESFloatArrays std::map arrays; }; - -struct GLsupport { - GLsupport():maxLights(0),maxClipPlane(0),maxTexUnits(0),maxTexSize(0){}; - int maxLights; - int maxClipPlane; - int maxTexUnits; - int maxTexSize; -}; - -class GLEScontext -{ +class GLEScontext{ public: - void init(); + virtual void init() = 0; GLEScontext(); GLenum getGLerror(); + void setGLerror(GLenum err); + void setShareGroup(ShareGroupPtr grp){m_shareGroup = grp;}; + virtual void setActiveTexture(GLenum tex); + unsigned int getBindedTexture(){return m_tex2DBind[m_activeTexture];}; + void setBindedTexture(unsigned int tex){ m_tex2DBind[m_activeTexture] = tex;}; bool isArrEnabled(GLenum); void enableArr(GLenum arr,bool enable); - void setGLerror(GLenum err); - void setActiveTexture(GLenum tex); - const GLvoid* setPointer(GLenum arrType,GLint size,GLenum type,GLsizei stride,const GLvoid* data); - unsigned int getBindedTexture(){return m_tex2DBind[m_activeTexture];}; - void setBindedTexture(unsigned int tex){ m_tex2DBind[m_activeTexture] = tex;}; + const GLvoid* setPointer(GLenum arrType,GLint size,GLenum type,GLsizei stride,const GLvoid* data,bool normalize = false); const GLESpointer* getPointer(GLenum arrType); - - void convertArrs(GLESFloatArrays& fArrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices,bool direct); - void drawPointsArrs(GLESFloatArrays& arrs,GLint first,GLsizei count); - void drawPointsElems(GLESFloatArrays& arrs,GLsizei count,GLenum type,const GLvoid* indices); - + virtual void convertArrs(GLESFloatArrays& fArrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices,bool direct) = 0; void bindBuffer(GLenum target,GLuint buffer); bool isBuffer(GLuint buffer); bool isBindedBuffer(GLenum target); @@ -72,43 +41,34 @@ public: void getBufferUsage(GLenum target,GLint* param); bool setBufferData(GLenum target,GLsizeiptr size,const GLvoid* data,GLenum usage); bool setBufferSubData(GLenum target,GLintptr offset,GLsizeiptr size,const GLvoid* data); - void setShareGroup(ShareGroupPtr grp){m_shareGroup = grp;}; - static GLDispatch& dispatcher(); - static int getMaxLights(){return s_glSupport.maxLights;} - static int getMaxClipPlanes(){return s_glSupport.maxClipPlane;} - static int getMaxTexUnits(){return s_glSupport.maxTexUnits;} - static int getMaxTexSize(){return s_glSupport.maxTexSize;} + virtual ~GLEScontext(); + static GLDispatch& dispatcher(){return s_glDispatch;}; + +protected: + void chooseConvertMethod(GLESFloatArrays& fArrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices,bool direct,GLESpointer* p,GLenum array_id,unsigned int& index); + + static android::Mutex s_lock; + static GLDispatch s_glDispatch; + bool m_initialized; + unsigned int m_activeTexture; + ArraysMap m_map; - ~GLEScontext(); private: + virtual void sendArr(GLvoid* arr,GLenum arrayType,GLint size,GLsizei stride,int pointsIndex = -1) = 0 ; GLuint getBuffer(GLenum target); - void sendArr(GLvoid* arr,GLenum arrayType,GLint size,GLsizei stride,int pointsIndex = -1); - void drawPoints(PointSizeIndices* points); - void drawPointsData(GLESFloatArrays& arrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices_in,bool isElemsDraw); - - void chooseConvertMethod(GLESFloatArrays& fArrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices,bool direct,GLESpointer* p,GLenum array_id,unsigned int& index); void convertDirect(GLESFloatArrays& fArrs,GLint first,GLsizei count,GLenum array_id,GLESpointer* p,unsigned int& index); void convertDirectVBO(GLint first,GLsizei count,GLenum array_id,GLESpointer* p); void convertIndirect(GLESFloatArrays& fArrs,GLsizei count,GLenum type,const GLvoid* indices,GLenum array_id,GLESpointer* p,unsigned int& index); void convertIndirectVBO(GLsizei count,GLenum indices_type,const GLvoid* indices,GLenum array_id,GLESpointer* p); - static GLDispatch s_glDispatch; - static GLsupport s_glSupport; - static android::Mutex s_lock; - - ArraysMap m_map; - GLESpointer* m_texCoords; + ShareGroupPtr m_shareGroup; GLenum m_glError; - unsigned int m_activeTexture; unsigned int m_tex2DBind[MAX_TEX_UNITS]; unsigned int m_arrayBuffer; unsigned int m_elementBuffer; - int m_pointsIndex; - bool m_initialized; - ShareGroupPtr m_shareGroup; }; #endif diff --git a/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLESmacros.h b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLESmacros.h new file mode 100644 index 000000000..08b1a0738 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLESmacros.h @@ -0,0 +1,61 @@ +#ifndef GLES_MACROS_H +#define GLES_MACROS_H + +#define GET_THREAD() \ + ThreadInfo* thrd = NULL; \ + if(s_eglIface) { \ + thrd = s_eglIface->getThreadInfo(); \ + } else { \ + fprintf(stderr,"Context wasn't initialized yet \n"); \ + } + + +#define GET_CTX() \ + GET_THREAD(); \ + if(!thrd) return; \ + GLEScontext *ctx = static_cast(thrd->glesContext); \ + if(!ctx) return; + +#define GET_CTX_CM() \ + GET_THREAD(); \ + if(!thrd) return; \ + GLEScmContext *ctx = static_cast(thrd->glesContext); \ + if(!ctx) return; + +#define GET_CTX_V2() \ + GET_THREAD(); \ + if(!thrd) return; \ + GLESv2Context *ctx = static_cast(thrd->glesContext); \ + if(!ctx) return; + +#define GET_CTX_RET(failure_ret) \ + GET_THREAD(); \ + if(!thrd) return failure_ret; \ + GLEScontext *ctx = static_cast(thrd->glesContext); \ + if(!ctx) return failure_ret; + +#define GET_CTX_CM_RET(failure_ret) \ + GET_THREAD(); \ + if(!thrd) return failure_ret; \ + GLEScmContext *ctx = static_cast(thrd->glesContext); \ + if(!ctx) return failure_ret; + +#define GET_CTX_V2_RET(failure_ret) \ + GET_THREAD(); \ + if(!thrd) return failure_ret; \ + GLESv2Context *ctx = static_cast(thrd->glesContext); \ + if(!ctx) return failure_ret; + + +#define SET_ERROR_IF(condition,err) if((condition)) { \ + ctx->setGLerror(err); \ + return; \ + } + + +#define RET_AND_SET_ERROR_IF(condition,err,ret) if((condition)) { \ + ctx->setGLerror(err); \ + return ret; \ + } + +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESpointer.h b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLESpointer.h similarity index 90% rename from tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESpointer.h rename to tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLESpointer.h index 9d897e427..c17be74a1 100644 --- a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLESpointer.h +++ b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLESpointer.h @@ -32,9 +32,10 @@ public: unsigned int getBufferOffset() const; void getBufferConversions(const RangeList& rl,RangeList& rlOut); bool bufferNeedConversion(){ return !m_buffer->fullyConverted();} - void setArray (GLint size,GLenum type,GLsizei stride,const GLvoid* data); - void setBuffer(GLint size,GLenum type,GLsizei stride,GLESbuffer* buf,int offset); + void setArray (GLint size,GLenum type,GLsizei stride,const GLvoid* data,bool normalize = false); + void setBuffer(GLint size,GLenum type,GLsizei stride,GLESbuffer* buf,int offset,bool normalize = false); bool isEnable() const; + bool isNormalize() const; void enable(bool b); private: @@ -42,6 +43,7 @@ private: GLenum m_type; GLsizei m_stride; bool m_enabled; + bool m_normalize; const GLvoid* m_data; GLESbuffer* m_buffer; unsigned int m_buffOffset; diff --git a/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLESvalidate.h b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLESvalidate.h new file mode 100644 index 000000000..4ca6a68b3 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLESvalidate.h @@ -0,0 +1,33 @@ +/* +* 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 GLES_VALIDATE_H +#define GLES_VALIDATE_H + +#include + +struct GLESvalidate +{ +static bool textureEnum(GLenum e,unsigned int maxTex); +static bool pixelType(GLenum type); +static bool pixelOp(GLenum format,GLenum type); +static bool pixelFrmt(GLenum format); +static bool bufferTarget(GLenum target); +static bool bufferParam(GLenum param); +static bool drawMode(GLenum mode); +static bool drawType(GLenum mode); +}; + +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_CM/GLfixed_ops.h b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLfixed_ops.h similarity index 100% rename from tools/emulator/opengl/host/libs/Translator/GLES_CM/GLfixed_ops.h rename to tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLfixed_ops.h diff --git a/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLutils.h b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLutils.h index 2da321ab9..7e2a03835 100644 --- a/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLutils.h +++ b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLutils.h @@ -16,6 +16,12 @@ #ifndef GL_UTILS_H #define GL_UTILS_H +typedef enum{ + GLES_1_1 = 1, + GLES_2_0 = 2, + MAX_GLES_VERSION //Must be last + }GLESVersion; + template void swap(T& x,T& y) { T temp; diff --git a/tools/emulator/opengl/host/libs/Translator/GLES_CM/RangeManip.h b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/RangeManip.h similarity index 100% rename from tools/emulator/opengl/host/libs/Translator/GLES_CM/RangeManip.h rename to tools/emulator/opengl/host/libs/Translator/include/GLcommon/RangeManip.h diff --git a/tools/emulator/opengl/tests/translator_tests/GLES_CM/Android.mk b/tools/emulator/opengl/tests/translator_tests/GLES_CM/Android.mk new file mode 100644 index 000000000..7890161db --- /dev/null +++ b/tools/emulator/opengl/tests/translator_tests/GLES_CM/Android.mk @@ -0,0 +1,30 @@ +ifneq ($(HOST_OS),darwin) +LOCAL_PATH:= $(call my-dir) + +include $(CLEAR_VARS) + +# +# This is built on linux host only !!! +# +PREBUILT := $(HOST_PREBUILT_TAG) +SDL_CONFIG ?= prebuilt/$(PREBUILT)/sdl/bin/sdl-config +SDL_CFLAGS := $(shell $(SDL_CONFIG) --cflags) +SDL_LDLIBS := $(filter-out %.a %.lib,$(shell $(SDL_CONFIG) --static-libs)) + +LOCAL_SRC_FILES:= \ + triangleCM.cpp + +LOCAL_SHARED_LIBRARIES := \ + libGLcommon \ + libEGL_translator \ + libGLES_CM_translator + +LOCAL_CFLAGS += $(SDL_CFLAGS) -g -O0 +LOCAL_LDLIBS += $(SDL_LDLIBS) + +LOCAL_MODULE:= triangleCM +LOCAL_MODULE_TAGS := debug +LOCAL_STATIC_LIBRARIES += libSDL libSDLmain + +include $(BUILD_HOST_EXECUTABLE) +endif diff --git a/tools/emulator/opengl/tests/translator_tests/GLES_CM/triangleCM.cpp b/tools/emulator/opengl/tests/translator_tests/GLES_CM/triangleCM.cpp new file mode 100644 index 000000000..af8cc9544 --- /dev/null +++ b/tools/emulator/opengl/tests/translator_tests/GLES_CM/triangleCM.cpp @@ -0,0 +1,385 @@ +#include +#include +#include +#include + +//#define GL_API +//#define GL_APIENTRY + +#undef ANDROID +#include +#include + +#undef HAVE_MALLOC_H +#include +#include + + +#define WINDOW_WIDTH 500 +#define WINDOW_HEIGHT 500 + +#define TEX_WIDTH 256 +#define TEX_HEIGHT 256 + + +#define F_to_X(d) ((d) > 32767.65535 ? 32767 * 65536 + 65535 : \ + (d) < -32768.65535 ? -32768 * 65536 + 65535 : \ + ((GLfixed) ((d) * 65536))) +#define X_to_F(x) ((float)(x))/65536.0f + +static EGLint const attribute_list[] = { + EGL_RED_SIZE, 1, + EGL_GREEN_SIZE, 1, + EGL_BLUE_SIZE, 1, + EGL_NONE +}; + +unsigned char *genTexture(int width, int height, int comp) +{ + unsigned char *img = new unsigned char[width * height * comp]; + unsigned char *ptr = img; + for (int i = 0; i < height; i++) { + for (int j = 0; j < width; j++) { + unsigned char col = ((i / 8 + j / 8) % 2) * 255 ; + for (int c = 0; c < comp; c++) { + *ptr = col; ptr++; + } + } + } + return img; +} + +unsigned char *genRedTexture(int width, int height, int comp) +{ + unsigned char *img = new unsigned char[width * height * comp]; + memset(img,0,width*height*comp); + unsigned char *ptr = img; + for (int i = 0; i < height; i++) { + for (int j = 0; j < width; j++) { + unsigned char col = ((i / 8 + j / 8) % 2) * 255 ; + *ptr = col; + ptr+=comp; + } + } + return img; +} + +//mip 0; +unsigned char *genPalette4_rgb8(int width, int height,int color) +{ + int size = width*height/2 + 16*3/*palette size*/; + unsigned char *img = new unsigned char[size]; + + memset(img,0,size); + img[0] = 255; img[1] = 0; img[2] = 0; // red + img[3] = 0; img[4] = 0; img[5] = 255; //blue + img[7] = 128; img[8] = 0; img[9] = 128; //fucsia + //rest of the palette is empty + + unsigned char *ptr = img+(16*3); + for (int i = 0; i < (height*width/2); i++) { + ptr[i] = (i%2)?0x0|color:0x11|color; + } + return img; +} + +void usage(const char *progname) +{ + fprintf(stderr, "usage: %s [-n -i -h]\n", progname); + fprintf(stderr, "\t-h: this message\n"); + fprintf(stderr, "\t-i: immidate mode\n"); + fprintf(stderr, "\t-n nframes: generate nframes\n"); + fprintf(stderr, "\t-e: use index arrays\n"); + fprintf(stderr, "\t-t: use texture\n"); + fprintf(stderr, "\t-f: use fixed points\n"); + fprintf(stderr, "\t-p: use point size OES extention\n"); +} + +#ifdef _WIN32 +int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd) +#else +int main(int argc, char **argv) +#endif +{ + GLuint ui32Vbo = 0; // Vertex buffer object handle + GLuint ui32IndexVbo; + GLuint ui32Texture; + + int nframes = 100; + bool immidateMode = true; + bool useIndices = false; + bool useTexture = false; + bool useCompTexture = false; + bool useFixed = false; + bool usePoints = true; + bool useCopy = false; + bool useSubCopy = false; + + int c; + extern char *optarg; + + #ifdef _WIN32 + HWND windowId = NULL; + #else + Window windowId = NULL; + #endif + + // // Inialize SDL window + // + if (SDL_Init(SDL_INIT_NOPARACHUTE | SDL_INIT_VIDEO)) { + fprintf(stderr,"SDL init failed: %s\n", SDL_GetError()); + return -1; + } + + SDL_Surface *surface = SDL_SetVideoMode(WINDOW_WIDTH,WINDOW_HEIGHT, 32, SDL_HWSURFACE); + if (surface == NULL) { + fprintf(stderr,"Failed to set video mode: %s\n", SDL_GetError()); + return -1; + } + + SDL_SysWMinfo wminfo; + memset(&wminfo, 0, sizeof(wminfo)); + SDL_GetWMInfo(&wminfo); + #ifdef _WIN32 + windowId = wminfo.window; + #else + windowId = wminfo.info.x11.window; + #endif + + int major,minor,num_config; + EGLConfig configs[150]; + EGLSurface egl_surface; + EGLContext ctx; + EGLDisplay d = eglGetDisplay(EGL_DEFAULT_DISPLAY); + eglInitialize(d,&major,&minor); + printf("DISPLAY == %p major =%d minor = %d\n",d,major,minor); + eglChooseConfig(d, attribute_list, configs, 150, &num_config); + printf("config returned %d\n",num_config); + egl_surface = eglCreateWindowSurface(d,configs[0],windowId,NULL); + ctx = eglCreateContext(d,configs[0],EGL_NO_CONTEXT,NULL); + printf("SURFACE == %p CONTEXT == %p\n",egl_surface,ctx); + if(eglMakeCurrent(d,egl_surface,egl_surface,ctx)!= EGL_TRUE){ + printf("make current failed\n"); + return false; + } + printf("after make current\n"); + + GLenum err = glGetError(); + if(err != GL_NO_ERROR) { + printf("error before drawing ->>> %d \n",err); + } else { + printf("no error before drawing\n"); + } + + if (useTexture) { + + glEnable(GL_TEXTURE_2D); + ui32Texture = 1; + glBindTexture(GL_TEXTURE_2D, ui32Texture); + GLenum err = glGetError(); + + unsigned char *pixels = NULL; + if(useCompTexture) { + pixels = genPalette4_rgb8(TEX_WIDTH,TEX_HEIGHT,3); + glCompressedTexImage2D(GL_TEXTURE_2D,0,GL_PALETTE4_RGB8_OES,TEX_WIDTH,TEX_HEIGHT,0,3*16+TEX_WIDTH*TEX_HEIGHT/2,pixels); + + } else { + pixels = genTexture(TEX_WIDTH, TEX_HEIGHT, 4); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEX_WIDTH, TEX_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels); + } + + delete pixels; + + err = glGetError(); + if(err != GL_NO_ERROR) + printf("error %d after image \n",err); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + err = glGetError(); + if(err != GL_NO_ERROR) + printf("error after min filter \n"); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + err = glGetError(); + if(err != GL_NO_ERROR) + printf("error after mag filter \n"); + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); + err = glGetError(); + if(err != GL_NO_ERROR) + printf("error after env mode \n"); + + if(useCompTexture) { + pixels = genPalette4_rgb8(TEX_WIDTH,TEX_HEIGHT,1); + glCompressedTexSubImage2D(GL_TEXTURE_2D,0,TEX_WIDTH/4,TEX_HEIGHT/4,TEX_WIDTH/8,TEX_HEIGHT/8,GL_PALETTE4_RGB8_OES,3*16+(TEX_WIDTH*TEX_HEIGHT/128),pixels); + } else { + pixels = genRedTexture(TEX_WIDTH/8, TEX_HEIGHT/8, 4); + glTexSubImage2D(GL_TEXTURE_2D,0,TEX_WIDTH/4,TEX_HEIGHT/4,TEX_WIDTH/8,TEX_HEIGHT/8,GL_RGBA,GL_UNSIGNED_BYTE,pixels); + } + err = glGetError(); + if(err != GL_NO_ERROR) + printf("error %d after subimage \n",err); + delete pixels; + + } + + glClearColor(0.6f, 0.8f, 1.0f, 1.0f); // clear blue + + float afVertices[] = { -0.4f,-0.4f,0.0f, // Position + 1.0f,0.0f,0.0f,1.0f, // Color + 0.0f, 0.0f, // texture + 12.f, //point size + + 0.4f,-0.4f,0.0f, + 0.0f,1.0f,0.0f,1.0f, + 1.0f, 0.0f, + 47.0f, + + 0.0f,0.4f,0.0f, + 0.0f,0.0f,1.0f,1.0f, + 0.5f, 1.0f, + 14.0f + }; + + GLfixed fixedVertices[] = { F_to_X(-0.4f),F_to_X(-0.4f),F_to_X(0.0f), // Position + F_to_X(1.0f),F_to_X(0.0f),F_to_X(0.0f),F_to_X(1.0f), // Color + F_to_X(0.0f),F_to_X(0.0f), // texture + F_to_X(12.0f),//points size + + F_to_X(0.4f),F_to_X(-0.4f),F_to_X(0.0f), + F_to_X(0.0f),F_to_X(1.0f),F_to_X(0.0f),F_to_X(1.0f), + F_to_X(1.0f),F_to_X( 0.0f), + F_to_X(30.0f), + + F_to_X(0.0f),F_to_X(0.4f),F_to_X(0.0f), + F_to_X(0.0f),F_to_X(0.0f),F_to_X(1.0f),F_to_X(1.0f), + F_to_X(0.5f), F_to_X(1.0f), + F_to_X(30.0) + }; + + unsigned short indices[] = { 2, 1, 0 }; + + if (!immidateMode) { + glGenBuffers(1, &ui32Vbo); + ui32Vbo = 1; + printf("ui32Vbo = %d\n", ui32Vbo); + + glBindBuffer(GL_ARRAY_BUFFER, ui32Vbo); + unsigned int uiSize = 3 * (sizeof(float) * 10); + glBufferData(GL_ARRAY_BUFFER, uiSize, useFixed?(void *)fixedVertices:(void*)afVertices, GL_STATIC_DRAW); + + ui32IndexVbo = 2; + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ui32IndexVbo); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); + } + + // Draws a triangle for 800 frames + float angle = 0.0; + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + GLvoid* arr = NULL; + GLenum type; + GLenum drawType; + int size_of; + + if(useFixed) + { + arr = fixedVertices; + type = GL_FIXED; + size_of = sizeof(GLfixed); + } + else + { + arr = afVertices; + type = GL_FLOAT; + size_of = sizeof(float); + } + + if(usePoints) + { + drawType = GL_POINTS; + } + else + drawType = GL_TRIANGLES; + + for (int i = 0; i < 10000; i++) { + + glClear(GL_COLOR_BUFFER_BIT); + glPushMatrix(); + glRotatef(angle, 0.0, 0.0, 1.0); + angle += 360.0 / nframes; + // Enable vertex arrays + glEnableClientState(GL_VERTEX_ARRAY); + if (immidateMode) { + glVertexPointer(3,type, size_of * 10, arr); + } else { + glVertexPointer(3,type, size_of * 10, 0); + } + + // Set color data in the same way + glEnableClientState(GL_COLOR_ARRAY); + if (immidateMode) { + glColorPointer(4, type, size_of * 10, useFixed?(GLvoid*)(fixedVertices+3):(GLvoid*)(afVertices+3)); + } else { + glColorPointer(4,type,size_of * 10, (GLvoid*) (size_of * 3) ); + } + if (useTexture) { + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + if (immidateMode) { + glTexCoordPointer(2, type, size_of * 10, useFixed?(GLvoid*)(fixedVertices + 7):(GLvoid*)(afVertices+7)); + } else { + glTexCoordPointer(2, type, size_of * 10, (GLvoid*)(size_of * 7)); + } + } + if(usePoints) + { + glEnableClientState(GL_POINT_SIZE_ARRAY_OES); + if (immidateMode) { + glPointSizePointerOES(type,size_of * 10,useFixed?(GLvoid*)(fixedVertices + 9):(GLvoid*)(afVertices+9)); + } else { + glPointSizePointerOES(type,size_of * 10,(GLvoid*)(size_of * 9)); + } + } + + if (useIndices) { + if (immidateMode) { + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + glDrawElements(drawType, 3, GL_UNSIGNED_SHORT, indices); + } else { + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ui32IndexVbo); + glDrawElements(drawType, 3, GL_UNSIGNED_SHORT, 0); + } + } else { + glDrawArrays(drawType, 0, 3); + } + + GLenum err = glGetError(); + if(err != GL_NO_ERROR) + printf(" error %d has occured while drawing\n",err); + + + glPopMatrix(); + eglSwapBuffers(d,egl_surface); + + if(useTexture && useCopy) + glCopyTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,0,0,256,256,0); + else if(useTexture && useSubCopy) + glCopyTexSubImage2D(GL_TEXTURE_2D,0,100,100,WINDOW_WIDTH/2,WINDOW_HEIGHT/2,50,50); + } + err = glGetError(); + if(err != GL_NO_ERROR) + printf("error ->>> %d \n",err); + eglDestroySurface(d,egl_surface); + eglDestroyContext(d,ctx); + +// Just wait until the window is closed + SDL_Event ev; + while( SDL_WaitEvent(&ev) ) { + if (ev.type == SDL_QUIT) { + break; + } + } + return 0; +} + + diff --git a/tools/emulator/opengl/tests/translator_tests/GLES_V2/Android.mk b/tools/emulator/opengl/tests/translator_tests/GLES_V2/Android.mk new file mode 100644 index 000000000..5e12f43b7 --- /dev/null +++ b/tools/emulator/opengl/tests/translator_tests/GLES_V2/Android.mk @@ -0,0 +1,29 @@ +ifneq ($(HOST_OS),darwin) +LOCAL_PATH:= $(call my-dir) +include $(CLEAR_VARS) + +# +# This is built on linux host only !!! +# +PREBUILT := $(HOST_PREBUILT_TAG) +SDL_CONFIG ?= prebuilt/$(PREBUILT)/sdl/bin/sdl-config +SDL_CFLAGS := $(shell $(SDL_CONFIG) --cflags) +SDL_LDLIBS := $(filter-out %.a %.lib,$(shell $(SDL_CONFIG) --static-libs)) + +LOCAL_SRC_FILES:= \ + triangleV2.cpp + +LOCAL_SHARED_LIBRARIES := \ + libGLcommon \ + libEGL_translator \ + libGLES_V2_translator + +LOCAL_CFLAGS += $(SDL_CFLAGS) -g -O0 +LOCAL_LDLIBS += $(SDL_LDLIBS) + +LOCAL_MODULE:= triangleV2 +LOCAL_MODULE_TAGS := debug +LOCAL_STATIC_LIBRARIES += libSDL libSDLmain + +include $(BUILD_HOST_EXECUTABLE) +endif diff --git a/tools/emulator/opengl/tests/translator_tests/GLES_V2/triangleV2.cpp b/tools/emulator/opengl/tests/translator_tests/GLES_V2/triangleV2.cpp new file mode 100644 index 000000000..f5cace25f --- /dev/null +++ b/tools/emulator/opengl/tests/translator_tests/GLES_V2/triangleV2.cpp @@ -0,0 +1,315 @@ +#include +#include +#include +#include + +//#define GL_API +//#define GL_APIENTRY + +#undef ANDROID +#include +#include + +#undef HAVE_MALLOC_H +#include +#include + + +#define WINDOW_WIDTH 500 +#define WINDOW_HEIGHT 500 + +#define TEX_WIDTH 256 +#define TEX_HEIGHT 256 + + +#define F_to_X(d) ((d) > 32767.65535 ? 32767 * 65536 + 65535 : \ + (d) < -32768.65535 ? -32768 * 65536 + 65535 : \ + ((GLfixed) ((d) * 65536))) +#define X_to_F(x) ((float)(x))/65536.0f + +//#define __FIXED__ + +static EGLint const attribute_list[] = { + EGL_RED_SIZE, 1, + EGL_GREEN_SIZE, 1, + EGL_BLUE_SIZE, 1, + EGL_NONE +}; + +unsigned char *genTexture(int width, int height, int comp) +{ + unsigned char *img = new unsigned char[width * height * comp]; + unsigned char *ptr = img; + for (int i = 0; i < height; i++) { + for (int j = 0; j < width; j++) { + unsigned char col = ((i / 8 + j / 8) % 2) * 255 ; + for (int c = 0; c < comp; c++) { + *ptr = col; ptr++; + } + } + } + return img; +} + +unsigned char *genRedTexture(int width, int height, int comp) +{ + unsigned char *img = new unsigned char[width * height * comp]; + memset(img,0,width*height*comp); + unsigned char *ptr = img; + for (int i = 0; i < height; i++) { + for (int j = 0; j < width; j++) { + unsigned char col = ((i / 8 + j / 8) % 2) * 255 ; + *ptr = col; + ptr+=comp; + } + } + return img; +} + + +void usage(const char *progname) +{ + fprintf(stderr, "usage: %s [-n -i -h]\n", progname); + fprintf(stderr, "\t-h: this message\n"); + fprintf(stderr, "\t-i: immidate mode\n"); + fprintf(stderr, "\t-n nframes: generate nframes\n"); + fprintf(stderr, "\t-e: use index arrays\n"); + fprintf(stderr, "\t-t: use texture\n"); + fprintf(stderr, "\t-f: use fixed points\n"); + fprintf(stderr, "\t-p: use point size OES extention\n"); +} + + + +GLuint LoadShader(GLenum type,const char *shaderSrc) +{ + GLuint shader; + GLint compiled; + // Create the shader object + shader = glCreateShader(type); + if(shader == 0) + return 0; + // Load the shader source + glShaderSource(shader, 1, &shaderSrc, NULL); + // Compile the shader + glCompileShader(shader); + // Check the compile status + glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled); + if(!compiled) + { + GLint infoLen = 0; + glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen); + if(infoLen > 1) + { + char* infoLog = (char*)malloc(sizeof(char) * infoLen); + glGetShaderInfoLog(shader, infoLen, NULL, infoLog); + printf("Error compiling shader:\n%s\n", infoLog); + free(infoLog); + } + glDeleteShader(shader); + return 0; + } + return shader; +} +/// +// Initialize the shader and program object +// +int Init() +{ + char vShaderStr[] = + "attribute vec4 vPosition; \n" + "void main() \n" + "{ \n" + " gl_Position = vPosition; \n" + "} \n"; + char fShaderStr[] = + "precision mediump float; \n" + "void main() \n" + "{ \n" +#ifndef __FIXED__ + " gl_FragColor = vec4(0.2, 0.5, 0.1, 1.0); \n" +#else + " gl_FragColor = vec4(0.4, 0.3, 0.7, 1.0); \n" +#endif + "} \n"; + GLuint vertexShader; + GLuint fragmentShader; + GLuint programObject; + GLint linked; + // Load the vertex/fragment shaders + vertexShader = LoadShader(GL_VERTEX_SHADER, vShaderStr); + fragmentShader = LoadShader(GL_FRAGMENT_SHADER, fShaderStr); + // Create the program object + programObject = glCreateProgram(); + if(programObject == 0) + return -1; + glAttachShader(programObject, vertexShader); + glAttachShader(programObject, fragmentShader); + // Bind vPosition to attribute 0 + glBindAttribLocation(programObject, 0, "vPosition"); + // Link the program + glLinkProgram(programObject); + // Check the link status + glGetProgramiv(programObject, GL_LINK_STATUS, &linked); + if(!linked) + { + GLint infoLen = 0; + glGetProgramiv(programObject, GL_INFO_LOG_LENGTH, &infoLen); + if(infoLen > 1) + { + char* infoLog = (char*)malloc(sizeof(char) * infoLen); + glGetProgramInfoLog(programObject, infoLen, NULL, infoLog); + printf("Error linking program:\n%s\n", infoLog); + free(infoLog); + } + glDeleteProgram(programObject); + return -1; + } + // Store the program object +#ifndef __FIXED__ + glClearColor(0.0f, 0.0f, 1.0f, 1.0f); +#else + glClearColor(1.0f, 0.0f, 0.0f, 1.0f); +#endif + return programObject; +} + + +/// +// Draw a triangle using the shader pair created in Init() +// +void Draw(EGLDisplay display,EGLSurface surface,int width,int height,GLuint program) +{ +#ifndef __FIXED__ + GLfloat vVertices[] = {0.0f, 0.5f, 0.0f, + -0.5f, -0.5f, 0.0f, + 0.5f, -0.5f, 0.0f}; +#else + + GLfixed vVertices[] = {F_to_X(0.0f), F_to_X(0.5f),F_to_X(0.0f), + F_to_X(-0.5f),F_to_X(-0.5f), F_to_X(0.0f), + F_to_X(0.5f),F_to_X(-0.5f),F_to_X(0.0f)}; +#endif + + // Set the viewport + glViewport(0, 0,width,height); + // Clear the color buffer + glClear(GL_COLOR_BUFFER_BIT); + // Use the program object + glUseProgram(program); + // Load the vertex data +#ifndef __FIXED__ + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices); +#else + glVertexAttribPointer(0, 3, GL_FIXED, GL_FALSE, 0, vVertices); +#endif + glEnableVertexAttribArray(0); + glDrawArrays(GL_TRIANGLES, 0, 3); + eglSwapBuffers(display,surface); +} + +#ifdef _WIN32 +int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd) +#else +int main(int argc, char **argv) +#endif +{ + GLuint ui32Vbo = 0; // Vertex buffer object handle + GLuint ui32IndexVbo; + GLuint ui32Texture; + + int nframes = 100; + bool immidateMode = false; + bool useIndices = false; + bool useTexture = true; + bool useCompTexture = false; + bool useFixed = true; + bool usePoints = false; + bool useCopy = false; + bool useSubCopy = false; + + int c; + extern char *optarg; + + #ifdef _WIN32 + HWND windowId = NULL; + #else + Window windowId = NULL; + #endif + + // // Inialize SDL window + // + if (SDL_Init(SDL_INIT_NOPARACHUTE | SDL_INIT_VIDEO)) { + fprintf(stderr,"SDL init failed: %s\n", SDL_GetError()); + return -1; + } + + SDL_Surface *surface = SDL_SetVideoMode(WINDOW_WIDTH,WINDOW_HEIGHT, 32, SDL_HWSURFACE); + if (surface == NULL) { + fprintf(stderr,"Failed to set video mode: %s\n", SDL_GetError()); + return -1; + } + + SDL_SysWMinfo wminfo; + memset(&wminfo, 0, sizeof(wminfo)); + SDL_GetWMInfo(&wminfo); + #ifdef _WIN32 + windowId = wminfo.window; + #else + windowId = wminfo.info.x11.window; + #endif + + int major,minor,num_config; + int attrib_list[] ={ + EGL_CONTEXT_CLIENT_VERSION, 2, + EGL_NONE + }; + EGLConfig configs[150]; + EGLSurface egl_surface; + EGLContext ctx; + EGLDisplay d = eglGetDisplay(EGL_DEFAULT_DISPLAY); + eglInitialize(d,&major,&minor); + printf("DISPLAY == %p major =%d minor = %d\n",d,major,minor); + eglChooseConfig(d, attribute_list, configs, 150, &num_config); + printf("config returned %d\n",num_config); + egl_surface = eglCreateWindowSurface(d,configs[0],windowId,NULL); + ctx = eglCreateContext(d,configs[0],EGL_NO_CONTEXT,attrib_list); + printf("SURFACE == %p CONTEXT == %p\n",egl_surface,ctx); + if(eglMakeCurrent(d,egl_surface,egl_surface,ctx)!= EGL_TRUE){ + printf("make current failed\n"); + return false; + } + printf("after make current\n"); + + GLenum err = glGetError(); + if(err != GL_NO_ERROR) { + printf("error before drawing ->>> %d \n",err); + } else { + printf("no error before drawing\n"); + } + + int program = Init(); + if(program < 0){ + printf("failed init shaders\n"); + return false; + } + + Draw(d,egl_surface,WINDOW_WIDTH,WINDOW_HEIGHT,program); + + err = glGetError(); + if(err != GL_NO_ERROR) + printf("error ->>> %d \n",err); + eglDestroySurface(d,egl_surface); + eglDestroyContext(d,ctx); + +// Just wait until the window is closed + SDL_Event ev; + while( SDL_WaitEvent(&ev) ) { + if (ev.type == SDL_QUIT) { + break; + } + } + return 0; +} + +