diff -r da7c1a80df0d -r d2d6724aef32 holdingarea/serialization/Graphics/KhronosAPIWrapper/src/opengles11apiwrapper.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/holdingarea/serialization/Graphics/KhronosAPIWrapper/src/opengles11apiwrapper.cpp	Thu Sep 16 09:43:14 2010 +0100
@@ -0,0 +1,2580 @@
+// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// 
+
+#ifdef WIN32
+#define WIN32_LEAN_AND_MEAN                       // Exclude rarely-used stuff from Windows headers
+#include <windows.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <GLES/gl.h>
+#include "opengles11apiwrapper.h"
+#include "serializedfunctioncall.h"
+#include "remotefunctioncall.h"
+#include "khronosapiwrapperdefs.h"
+
+#include "openvgrfc.h"
+
+
+OGLES11Wrapper::OGLES11Wrapper(RemoteFunctionCallData& currentFunctionCallData,
+            APIWrapperStack* stack,
+            void* result,
+            MGraphicsVHWCallback* serviceIf):
+APIWrapper(currentFunctionCallData, stack, result, serviceIf),
+m_currentFunctionCall(m_currentFunctionCallData)
+{
+}
+
+int OGLES11Wrapper::DispatchRequest(unsigned long aCode)
+{
+    int ret(0);
+    TRACE("OpenGLES11APIWrapper: OpenGL ES Op command received: %u\n", aCode);
+
+    switch ( aCode )
+    {
+    case OpenGlES11RFC::EglActiveTexture:
+        ret = glActiveTexture();
+        break;
+    case OpenGlES11RFC::EglAlphaFunc:
+        ret = glAlphaFunc();
+        break;
+    case OpenGlES11RFC::EglAlphaFuncx:
+        ret = glAlphaFuncx();
+        break;
+    case OpenGlES11RFC::EglBindBuffer:
+        ret = glBindBuffer();
+        break;
+    case OpenGlES11RFC::EglBindTexture:
+        ret = glBindTexture();
+        break;
+    case OpenGlES11RFC::EglBlendFunc:
+        ret = glBlendFunc();
+        break;
+    case OpenGlES11RFC::EglBufferData:
+        ret = glBufferData();
+        break;
+    case OpenGlES11RFC::EglBufferSubData:
+        ret = glBufferSubData();
+        break;
+    case OpenGlES11RFC::EglClear:
+        ret = glClear();
+        break;
+    case OpenGlES11RFC::EglClearColor:
+        ret = glClearColor();
+        break;
+    case OpenGlES11RFC::EglClearColorx:
+        ret = glClearColorx();
+        break;
+    case OpenGlES11RFC::EglClearDepthf:
+        ret = glClearDepthf();
+        break;
+    case OpenGlES11RFC::EglClearDepthx:
+        ret = glClearDepthx();
+        break;
+    case OpenGlES11RFC::EglClearStencil:
+        ret = glClearStencil();
+        break;
+    case OpenGlES11RFC::EglClientActiveTexture:
+        ret = glClientActiveTexture();
+        break;
+    case OpenGlES11RFC::EglClipPlanef:
+        ret = glClipPlanef();
+        break;
+    case OpenGlES11RFC::EglClipPlanex:
+        ret = glClipPlanex();
+        break;
+    case OpenGlES11RFC::EglColor4f:
+        ret = glColor4f();
+        break;
+    case OpenGlES11RFC::EglColor4ub:
+        ret = glColor4ub();
+        break;
+    case OpenGlES11RFC::EglColor4x:
+        ret = glColor4x();
+        break;
+    case OpenGlES11RFC::EglColorMask:
+        ret = glColorMask();
+        break;
+    case OpenGlES11RFC::EglCompressedTexImage2D:
+        ret = glCompressedTexImage2D();
+        break;
+    case OpenGlES11RFC::EglCompressedTexSubImage2D:
+        ret = glCompressedTexSubImage2D();
+        break;
+    case OpenGlES11RFC::EglCopyTexImage2D:
+        ret = glCopyTexImage2D();
+        break;
+    case OpenGlES11RFC::EglCopyTexSubImage2D:
+        ret = glCopyTexSubImage2D();
+        break;
+    case OpenGlES11RFC::EglCullFace:
+        ret = glCullFace();
+        break;
+    case OpenGlES11RFC::EglDeleteBuffers:
+        ret = glDeleteBuffers();
+        break;
+    case OpenGlES11RFC::EglDeleteTextures:
+        ret = glDeleteTextures();
+        break;
+    case OpenGlES11RFC::EglDepthFunc:
+        ret = glDepthFunc();
+        break;
+    case OpenGlES11RFC::EglDepthMask:
+        ret = glDepthMask();
+        break;
+    case OpenGlES11RFC::EglDepthRangef:
+        ret = glDepthRangef();
+        break;
+    case OpenGlES11RFC::EglDepthRangex:
+        ret = glDepthRangex();
+        break;
+    case OpenGlES11RFC::EglDisable:
+        ret = glDisable();
+        break;
+    case OpenGlES11RFC::EglDisableClientState:
+        ret = glDisableClientState();
+        break;
+    case OpenGlES11RFC::EglDrawArrays:
+        ret = glDrawArrays();
+        break;
+    case OpenGlES11RFC::EglDrawElements:
+        ret = glDrawElements();
+        break;
+    case OpenGlES11RFC::EglEnable:
+        ret = glEnable();
+        break;
+    case OpenGlES11RFC::EglEnableClientState:
+        ret = glEnableClientState();
+        break;
+    case OpenGlES11RFC::EglFinish:
+        ret = glFinish();
+        break;
+    case OpenGlES11RFC::EglFlush:
+        ret = glFlush();
+        break;
+    case OpenGlES11RFC::EglFogf:
+        ret = glFogf();
+        break;
+    case OpenGlES11RFC::EglFogfv:
+        ret = glFogfv();
+        break;
+    case OpenGlES11RFC::EglFogx:
+        ret = glFogx();
+        break;
+    case OpenGlES11RFC::EglFogxv:
+        ret = glFogxv();
+        break;
+    case OpenGlES11RFC::EglFrontFace:
+        ret = glFrontFace();
+        break;
+    case OpenGlES11RFC::EglFrustumf:
+        ret = glFrustumf();
+        break;
+    case OpenGlES11RFC::EglFrustumx:
+        ret = glFrustumx();
+        break;
+    case OpenGlES11RFC::EglGenBuffers:
+        ret = glGenBuffers();
+        break;
+    case OpenGlES11RFC::EglGenTextures:
+        ret = glGenTextures();
+        break;
+    case OpenGlES11RFC::EglGetBooleanv:
+        ret = glGetBooleanv();
+        break;
+    case OpenGlES11RFC::EglGetBufferParameteriv:
+        ret = glGetBufferParameteriv();
+        break;
+    case OpenGlES11RFC::EglGetClipPlanef:
+        ret = glGetClipPlanef();
+        break;
+    case OpenGlES11RFC::EglGetClipPlanex:
+        ret = glGetClipPlanex();
+        break;
+    case OpenGlES11RFC::EglGetError:
+        ret = glGetError();
+        break;
+    case OpenGlES11RFC::EglGetFixedv:
+        ret = glGetFixedv();
+        break;
+    case OpenGlES11RFC::EglGetFloatv:
+        ret = glGetFloatv();
+        break;
+    case OpenGlES11RFC::EglGetIntegerv:
+        ret = glGetIntegerv();
+        break;
+    case OpenGlES11RFC::EglGetLightfv:
+        ret = glGetLightfv();
+        break;
+    case OpenGlES11RFC::EglGetLightxv:
+        ret = glGetLightxv();
+        break;
+    case OpenGlES11RFC::EglGetMaterialfv:
+        ret = glGetMaterialfv();
+        break;
+    case OpenGlES11RFC::EglGetMaterialxv:
+        ret = glGetMaterialxv();
+        break;
+    case OpenGlES11RFC::EglGetPointerv:
+        ret = glGetPointerv();
+        break;
+//  case OpenGlES11RFC::EglGetString:
+//      ret = glGetString();
+//      break;
+    case OpenGlES11RFC::EglGetTexEnvfv:
+        ret = glGetTexEnvfv();
+        break;
+    case OpenGlES11RFC::EglGetTexEnviv:
+        ret = glGetTexEnviv();
+        break;
+    case OpenGlES11RFC::EglGetTexEnvxv:
+        ret = glGetTexEnvxv();
+        break;
+    case OpenGlES11RFC::EglGetTexParameterfv:
+        ret = glGetTexParameterfv();
+        break;
+    case OpenGlES11RFC::EglGetTexParameteriv:
+        ret = glGetTexParameteriv();
+        break;
+    case OpenGlES11RFC::EglGetTexParameterxv:
+        ret = glGetTexParameterxv();
+        break;
+    case OpenGlES11RFC::EglHint:
+        ret = glHint();
+        break;
+    case OpenGlES11RFC::EglIsBuffer:
+        ret = glIsBuffer();
+        break;
+    case OpenGlES11RFC::EglIsEnabled:
+        ret = glIsEnabled();
+        break;
+    case OpenGlES11RFC::EglIsTexture:
+        ret = glIsTexture();
+        break;
+    case OpenGlES11RFC::EglLightModelf:
+        ret = glLightModelf();
+        break;
+    case OpenGlES11RFC::EglLightModelfv:
+        ret = glLightModelfv();
+        break;
+    case OpenGlES11RFC::EglLightModelx:
+        ret = glLightModelx();
+        break;
+    case OpenGlES11RFC::EglLightModelxv:
+        ret = glLightModelxv();
+        break;
+    case OpenGlES11RFC::EglLightf:
+        ret = glLightf();
+        break;
+    case OpenGlES11RFC::EglLightfv:
+        ret = glLightfv();
+        break;
+    case OpenGlES11RFC::EglLightx:
+        ret = glLightx();
+        break;
+    case OpenGlES11RFC::EglLightxv:
+        ret = glLightxv();
+        break;
+    case OpenGlES11RFC::EglLineWidth:
+        ret = glLineWidth();
+        break;
+    case OpenGlES11RFC::EglLineWidthx:
+        ret = glLineWidthx();
+        break;
+    case OpenGlES11RFC::EglLoadIdentity:
+        ret = glLoadIdentity();
+        break;
+    case OpenGlES11RFC::EglLoadMatrixf:
+        ret = glLoadMatrixf();
+        break;
+    case OpenGlES11RFC::EglLoadMatrixx:
+        ret = glLoadMatrixx();
+        break;
+    case OpenGlES11RFC::EglLogicOp:
+        ret = glLogicOp();
+        break;
+    case OpenGlES11RFC::EglMaterialf:
+        ret = glMaterialf();
+        break;
+    case OpenGlES11RFC::EglMaterialfv:
+        ret = glMaterialfv();
+        break;
+    case OpenGlES11RFC::EglMaterialx:
+        ret = glMaterialx();
+        break;
+    case OpenGlES11RFC::EglMaterialxv:
+        ret = glMaterialxv();
+        break;
+    case OpenGlES11RFC::EglMatrixMode:
+        ret = glMatrixMode();
+        break;
+    case OpenGlES11RFC::EglMultMatrixf:
+        ret = glMultMatrixf();
+        break;
+    case OpenGlES11RFC::EglMultMatrixx:
+        ret = glMultMatrixx();
+        break;
+    case OpenGlES11RFC::EglMultiTexCoord4f:
+        ret = glMultiTexCoord4f();
+        break;
+    case OpenGlES11RFC::EglMultiTexCoord4x:
+        ret = glMultiTexCoord4x();
+        break;
+    case OpenGlES11RFC::EglNormal3f:
+        ret = glNormal3f();
+        break;
+    case OpenGlES11RFC::EglNormal3x:
+        ret = glNormal3x();
+        break;
+    case OpenGlES11RFC::EglOrthof:
+        ret = glOrthof();
+        break;
+    case OpenGlES11RFC::EglOrthox:
+        ret = glOrthox();
+        break;
+    case OpenGlES11RFC::EglPixelStorei:
+        ret = glPixelStorei();
+        break;
+    case OpenGlES11RFC::EglPointParameterf:
+        ret = glPointParameterf();
+        break;
+    case OpenGlES11RFC::EglPointParameterfv:
+        ret = glPointParameterfv();
+        break;
+    case OpenGlES11RFC::EglPointParameterx:
+        ret = glPointParameterx();
+        break;
+    case OpenGlES11RFC::EglPointParameterxv:
+        ret = glPointParameterxv();
+        break;
+    case OpenGlES11RFC::EglPointSize:
+        ret = glPointSize();
+        break;
+    case OpenGlES11RFC::EglPointSizex:
+        ret = glPointSizex();
+        break;
+    case OpenGlES11RFC::EglPolygonOffset:
+        ret = glPolygonOffset();
+        break;
+    case OpenGlES11RFC::EglPolygonOffsetx:
+        ret = glPolygonOffsetx();
+        break;
+    case OpenGlES11RFC::EglPopMatrix:
+        ret = glPopMatrix();
+        break;
+    case OpenGlES11RFC::EglPushMatrix:
+        ret = glPushMatrix();
+        break;
+    case OpenGlES11RFC::EglReadPixels:
+        ret = glReadPixels();
+        break;
+    case OpenGlES11RFC::EglRotatef:
+        ret = glRotatef();
+        break;
+    case OpenGlES11RFC::EglRotatex:
+        ret = glRotatex();
+        break;
+    case OpenGlES11RFC::EglSampleCoverage:
+        ret = glSampleCoverage();
+        break;
+    case OpenGlES11RFC::EglSampleCoveragex:
+        ret = glSampleCoveragex();
+        break;
+    case OpenGlES11RFC::EglScalef:
+        ret = glScalef();
+        break;
+    case OpenGlES11RFC::EglScalex:
+        ret = glScalex();
+        break;
+    case OpenGlES11RFC::EglScissor:
+        ret = glScissor();
+        break;
+    case OpenGlES11RFC::EglShadeModel:
+        ret = glShadeModel();
+        break;
+    case OpenGlES11RFC::EglStencilFunc:
+        ret = glStencilFunc();
+        break;
+    case OpenGlES11RFC::EglStencilMask:
+        ret = glStencilMask();
+        break;
+    case OpenGlES11RFC::EglStencilOp:
+        ret = glStencilOp();
+        break;
+    case OpenGlES11RFC::EglTexEnvf:
+        ret = glTexEnvf();
+        break;
+    case OpenGlES11RFC::EglTexEnvfv:
+        ret = glTexEnvfv();
+        break;
+    case OpenGlES11RFC::EglTexEnvi:
+        ret = glTexEnvi();
+        break;
+    case OpenGlES11RFC::EglTexEnviv:
+        ret = glTexEnviv();
+        break;
+    case OpenGlES11RFC::EglTexEnvx:
+        ret = glTexEnvx();
+        break;
+    case OpenGlES11RFC::EglTexEnvxv:
+        ret = glTexEnvxv();
+        break;
+    case OpenGlES11RFC::EglTexImage2D:
+        ret = glTexImage2D();
+        break;
+    case OpenGlES11RFC::EglTexParameterf:
+        ret = glTexParameterf();
+        break;
+    case OpenGlES11RFC::EglTexParameterfv:
+        ret = glTexParameterfv();
+        break;
+    case OpenGlES11RFC::EglTexParameteri:
+        ret = glTexParameteri();
+        break;
+    case OpenGlES11RFC::EglTexParameteriv:
+        ret = glTexParameteriv();
+        break;
+    case OpenGlES11RFC::EglTexParameterx:
+        ret = glTexParameterx();
+        break;
+    case OpenGlES11RFC::EglTexParameterxv:
+        ret = glTexParameterxv();
+        break;
+    case OpenGlES11RFC::EglTexSubImage2D:
+        ret = glTexSubImage2D();
+        break;
+    case OpenGlES11RFC::EglTranslatef:
+        ret = glTranslatef();
+        break;
+    case OpenGlES11RFC::EglTranslatex:
+        ret = glTranslatex();
+        break;
+    case OpenGlES11RFC::EglViewport:
+        ret = glViewport();
+        break;
+
+    // from Eglextplatform.h
+    case OpenGlES11RFC::EglCurrentPaletteMatrixOES:
+        ret = glCurrentPaletteMatrixOES();
+        break;
+    case OpenGlES11RFC::EglDrawTexfOES:
+        ret = glDrawTexfOES();
+        break;
+    case OpenGlES11RFC::EglDrawTexfvOES:
+        ret = glDrawTexfvOES();
+        break;
+    case OpenGlES11RFC::EglDrawTexiOES:
+        ret = glDrawTexiOES();
+        break;
+    case OpenGlES11RFC::EglDrawTexivOES:
+        ret = glDrawTexivOES();
+        break;
+    case OpenGlES11RFC::EglDrawTexsOES:
+        ret = glDrawTexsOES();
+        break;
+    case OpenGlES11RFC::EglDrawTexsvOES:
+        ret = glDrawTexsvOES();
+        break;
+    case OpenGlES11RFC::EglDrawTexxOES:
+        ret = glDrawTexxOES();
+        break;
+    case OpenGlES11RFC::EglDrawTexxvOES:
+        ret = glDrawTexxvOES();
+        break;
+    case OpenGlES11RFC::EglLoadPaletteFromModelViewMatrixOES:
+        ret = glLoadPaletteFromModelViewMatrixOES();
+        break;
+    case OpenGlES11RFC::EglQueryMatrixxOES:
+        ret = glQueryMatrixxOES();
+        break;
+
+    case OpenGlES11RFC::EglColorPointer:
+    case OpenGlES11RFC::EglNormalPointer:
+    case OpenGlES11RFC::EglTexCoordPointer:
+    case OpenGlES11RFC::EglVertexPointer:
+    case OpenGlES11RFC::EglMatrixIndexPointerOES:
+    case OpenGlES11RFC::EglWeightPointerOES:    
+        TRACE("OpenGLES11APIWrapper: ERROR! Vertex pointer functions are not handled directly, should not be here\n");
+        break;
+        
+    // client shutdown
+    case OpenGlES11RFC::EClientShutdown:
+        TRACE("OpenGLES11APIWrapper: Client shutdown unimplemented\n");
+        break;
+
+    default:
+        TRACE("OpenGLES11APIWrapper: Unimplemented OpenGL ES Op code %u\n",aCode);
+        break;
+    }
+    TRACE("OpenGLES11APIWrapper: OpenGL ES 1.1 command processed\n");
+    return ret;
+}
+
+int OGLES11Wrapper::WriteReply()
+{
+#ifdef LOG_ERROR
+    int operationid = (int)m_currentFunctionCall.Data().Header().iOpCode;
+    
+    int glerror = ::glGetError();
+    if ( m_lastGlError != glerror )
+    {
+        if ( GL_NO_ERROR != glerror )
+        {
+            TRACE("OpenGLES11APIWrapper: OpenGL error 0x%X, for request %d\n", glerror, operationid );
+        }
+        m_lastGlError = glerror;
+    }
+#endif
+    return APIWrapper::WriteReply();
+}
+
+// ///////////////////////////////////////////////////
+// Here follows the functions that map to the GL calls
+
+
+int OGLES11Wrapper::glActiveTexture()
+{
+    GLenum texture;
+    m_currentFunctionCall.GetParamValue(texture, 0);
+    ::glActiveTexture(texture);
+    return WriteReply();
+}
+int OGLES11Wrapper::glAlphaFunc()
+{
+    GLenum func;
+    m_currentFunctionCall.GetParamValue(func, 0);
+    GLclampf ref;
+    m_currentFunctionCall.GetParamValue(ref, 1);
+    ::glAlphaFunc(func, ref);
+    return WriteReply();
+}
+int OGLES11Wrapper::glAlphaFuncx()
+{
+    GLenum func;
+    m_currentFunctionCall.GetParamValue(func, 0);
+    GLclampx ref;
+    m_currentFunctionCall.GetParamValue(ref, 1);
+    ::glAlphaFuncx(func, ref);
+    return WriteReply();
+}
+int OGLES11Wrapper::glBindBuffer()
+{
+    GLenum target;
+    m_currentFunctionCall.GetParamValue(target, 0);    
+    GLuint buffer;
+    m_currentFunctionCall.GetParamValue(buffer, 1);
+    ::glBindBuffer(target, buffer);
+    return WriteReply();
+}
+int OGLES11Wrapper::glBindTexture()
+{
+    GLenum target;
+    m_currentFunctionCall.GetParamValue(target, 0);    
+    GLuint texIndex;
+    m_currentFunctionCall.GetParamValue(texIndex, 1);
+    ::glBindTexture(target, texIndex);
+    return WriteReply();
+}
+int OGLES11Wrapper::glBlendFunc()
+{
+    GLenum src;
+    m_currentFunctionCall.GetParamValue(src, 0);
+    GLenum dst;
+    m_currentFunctionCall.GetParamValue(dst, 1);
+    ::glBlendFunc(src, dst);
+    return WriteReply();
+}
+int OGLES11Wrapper::glBufferData()
+{
+    GLenum target;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    //GLsizeiptr size;    
+    GLint size;
+    m_currentFunctionCall.GetParamValue(size, 1);
+    
+    void* data;
+    //GLsizeiptr size2;
+    GLint size2;
+    m_currentFunctionCall.GetVectorData(data, size2, 2); //is this correct??
+    //size == size2 ?
+    
+    GLenum usage;
+    m_currentFunctionCall.GetParamValue(usage, 3);
+    ::glBufferData(target, size, data, usage);
+    return WriteReply();
+}
+int OGLES11Wrapper::glBufferSubData()
+{
+    GLenum target;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    //GLintptr offset;
+    GLint offset;
+    m_currentFunctionCall.GetParamValue(offset, 1);
+    //GLsizeiptr size;
+    GLint size;
+    m_currentFunctionCall.GetParamValue(size, 2);
+    void* data;
+    //GLsizeiptr size2;
+    GLint size2;
+    m_currentFunctionCall.GetVectorData(data, size2, 3); //is this correct??
+    ::glBufferSubData(target,offset,size,data);
+    return WriteReply();
+}
+int OGLES11Wrapper::glClear()
+{
+    GLbitfield buf;
+    m_currentFunctionCall.GetParamValue(buf, 0);
+    ::glClear(buf);
+    return WriteReply();
+}
+int OGLES11Wrapper::glClearColor()
+{
+    GLclampf r;
+    m_currentFunctionCall.GetParamValue(r, 0);
+    GLclampf g;
+    m_currentFunctionCall.GetParamValue(g, 1);
+    GLclampf b;
+    m_currentFunctionCall.GetParamValue(b, 2);
+    GLclampf a;
+    m_currentFunctionCall.GetParamValue(a, 3);
+    ::glClearColor(r,g,b,a);
+    return WriteReply();
+}
+int OGLES11Wrapper::glClearColorx()
+{
+    GLclampx r;
+    m_currentFunctionCall.GetParamValue(r, 0);
+    GLclampx g;
+    m_currentFunctionCall.GetParamValue(g, 1);
+    GLclampx b;
+    m_currentFunctionCall.GetParamValue(b, 2);
+    GLclampx a;
+    m_currentFunctionCall.GetParamValue(a, 3);
+    ::glClearColorx(r,g,b,a);
+    return WriteReply();
+}
+int OGLES11Wrapper::glClearDepthf()
+{
+    GLclampf d;
+    m_currentFunctionCall.GetParamValue(d, 0);
+    ::glClearDepthf(d);
+    return WriteReply();
+}
+int OGLES11Wrapper::glClearDepthx()
+{
+    GLfixed d;
+    m_currentFunctionCall.GetParamValue(d, 0);
+    ::glClearDepthx(d);    
+    return WriteReply();
+}
+int OGLES11Wrapper::glClearStencil()
+{
+    GLint s;
+    m_currentFunctionCall.GetParamValue(s, 0);
+    ::glClearStencil(s);     
+    return WriteReply();
+}
+int OGLES11Wrapper::glClientActiveTexture()
+{
+    GLenum texture;
+    m_currentFunctionCall.GetParamValue(texture, 0);
+    ::glClientActiveTexture(texture);     
+    return WriteReply();
+}
+int OGLES11Wrapper::glClipPlanef()
+{
+    GLenum plane;
+    GLfloat* equation;
+    m_currentFunctionCall.GetParamValue(plane, 0);
+    //GLsizeiptr size;
+    GLint size;
+    m_currentFunctionCall.GetVectorData(equation, size, 1);
+    ::glClipPlanef(plane,equation);
+    return WriteReply();
+}
+int OGLES11Wrapper::glClipPlanex()
+{
+    GLenum plane;
+    GLfixed* equation;
+    //GLsizeiptr size;
+    GLint size;
+    m_currentFunctionCall.GetParamValue(plane, 0);
+    m_currentFunctionCall.GetVectorData(equation, size, 1);
+    ::glClipPlanex(plane,equation);
+    return WriteReply();
+}
+int OGLES11Wrapper::glColor4f()
+{
+    GLfloat r,g,b,a;
+    m_currentFunctionCall.GetParamValue(r, 0);
+    m_currentFunctionCall.GetParamValue(g, 1);
+    m_currentFunctionCall.GetParamValue(b, 2);
+    m_currentFunctionCall.GetParamValue(a, 3);
+    ::glColor4f(r,g,b,a);    
+    return WriteReply();
+}
+int OGLES11Wrapper::glColor4ub()
+{
+    GLubyte r,g,b,a;
+    m_currentFunctionCall.GetParamValue(r, 0);
+    m_currentFunctionCall.GetParamValue(g, 1);
+    m_currentFunctionCall.GetParamValue(b, 2);
+    m_currentFunctionCall.GetParamValue(a, 3);
+    ::glColor4ub(r,g,b,a);  
+    return WriteReply();
+}
+int OGLES11Wrapper::glColor4x()
+{
+    GLfixed r,g,b,a;
+    m_currentFunctionCall.GetParamValue(r, 0);
+    m_currentFunctionCall.GetParamValue(g, 1);
+    m_currentFunctionCall.GetParamValue(b, 2);
+    m_currentFunctionCall.GetParamValue(a, 3);
+    ::glColor4x(r,g,b,a);
+    return WriteReply();
+}
+int OGLES11Wrapper::glColorMask()
+{
+    GLboolean r,g,b,a;
+    m_currentFunctionCall.GetParamValue(r, 0);
+    m_currentFunctionCall.GetParamValue(g, 1);
+    m_currentFunctionCall.GetParamValue(b, 2);
+    m_currentFunctionCall.GetParamValue(a, 3);
+    ::glColorMask(r,g,b,a);
+    return WriteReply();
+}
+
+int OGLES11Wrapper::glCompressedTexImage2D()
+{
+    GLenum target;
+    GLint level;
+    GLenum internalFormat;
+    GLsizei width;
+    GLsizei height;
+    GLint border;
+    GLsizei imageSize;
+    GLvoid* data;
+    //GLsizeiptr size;
+    GLint size;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(level, 1);
+    m_currentFunctionCall.GetParamValue(internalFormat, 2);
+    m_currentFunctionCall.GetParamValue(width, 3);
+    m_currentFunctionCall.GetParamValue(height, 4);
+    m_currentFunctionCall.GetParamValue(border, 5);
+    m_currentFunctionCall.GetParamValue(imageSize, 6);
+    m_currentFunctionCall.GetVectorData(data, size, 7);
+    ::glCompressedTexImage2D(target,level,internalFormat,width,height,border,imageSize,data);
+    return WriteReply();
+}
+int OGLES11Wrapper::glCompressedTexSubImage2D()
+{
+    GLenum target;
+    GLint level;
+    GLint xoffset;
+    GLint yoffset;
+    GLsizei width;
+    GLsizei height;
+    GLenum format;
+    GLsizei imageSize;
+    GLvoid*   data;
+    //GLsizeiptr size;
+    GLint size;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(level, 1);
+    m_currentFunctionCall.GetParamValue(xoffset, 2);
+    m_currentFunctionCall.GetParamValue(yoffset, 3);
+    m_currentFunctionCall.GetParamValue(width, 4);
+    m_currentFunctionCall.GetParamValue(height, 5);
+    m_currentFunctionCall.GetParamValue(format, 6);
+    m_currentFunctionCall.GetParamValue(imageSize, 7);
+    m_currentFunctionCall.GetVectorData(data, size, 8);
+    ::glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    return WriteReply();
+}
+int OGLES11Wrapper::glCopyTexImage2D()
+{
+    GLenum target;    
+    GLint level;
+    GLenum internalFormat;
+    GLint x;
+    GLint y;
+    GLsizei width;
+    GLsizei height;
+    GLint border;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(level, 1);
+    m_currentFunctionCall.GetParamValue(internalFormat, 2);
+    m_currentFunctionCall.GetParamValue(x, 3);
+    m_currentFunctionCall.GetParamValue(y, 4);    
+    m_currentFunctionCall.GetParamValue(width, 5);    
+    m_currentFunctionCall.GetParamValue(height, 6);    
+    m_currentFunctionCall.GetParamValue(border, 7);
+    ::glCopyTexImage2D(target,level,internalFormat,x,y,width,height,border);
+    return WriteReply();
+}
+int OGLES11Wrapper::glCopyTexSubImage2D()
+{
+    GLenum  target;
+    GLint   level;
+    GLint   xoffset;
+    GLint   yoffset;
+    GLint   x;
+    GLint   y;
+    GLsizei width;
+    GLsizei height;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(level, 1);
+    m_currentFunctionCall.GetParamValue(xoffset, 2);
+    m_currentFunctionCall.GetParamValue(yoffset, 3);
+    m_currentFunctionCall.GetParamValue(x, 4);
+    m_currentFunctionCall.GetParamValue(y, 5);
+    m_currentFunctionCall.GetParamValue(width, 6);
+    m_currentFunctionCall.GetParamValue(height, 7);    
+    ::glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height);
+    return WriteReply();
+}
+int OGLES11Wrapper::glCullFace()
+{
+    GLenum mode;
+
+    m_currentFunctionCall.GetParamValue(mode, 0);
+
+    ::glCullFace(mode);
+    return WriteReply();
+}
+int OGLES11Wrapper::glDeleteBuffers()
+{
+    GLsizei n;
+    GLuint *buffers;
+
+    m_currentFunctionCall.GetParamValue(n, 0);
+    TInt size1;
+    m_currentFunctionCall.GetVectorData(buffers, size1, 1);
+
+    ::glDeleteBuffers(n, buffers);
+    return WriteReply();
+}
+int OGLES11Wrapper::glDeleteTextures()
+{
+    GLsizei n;
+    GLuint *textures;
+
+    m_currentFunctionCall.GetParamValue(n, 0);
+    TInt size1;
+    m_currentFunctionCall.GetVectorData(textures, size1, 1);
+
+    ::glDeleteTextures(n, textures);
+    return WriteReply();
+}
+int OGLES11Wrapper::glDepthFunc()
+{
+    GLenum func;
+
+    m_currentFunctionCall.GetParamValue(func, 0);
+
+    ::glDepthFunc(func);
+    return WriteReply();
+}
+int OGLES11Wrapper::glDepthMask()
+{
+    GLboolean flag;
+
+    m_currentFunctionCall.GetParamValue(flag, 0);
+
+    ::glDepthMask(flag);
+    return WriteReply();
+}
+int OGLES11Wrapper::glDepthRangef()
+{
+    GLclampf zNear;
+    GLclampf zFar;
+
+    m_currentFunctionCall.GetParamValue(zNear, 0);
+    m_currentFunctionCall.GetParamValue(zFar, 1);
+
+    ::glDepthRangef(zNear, zFar);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glDepthRangex()
+{
+    GLclampx zNear;
+    GLclampx zFar;
+
+    m_currentFunctionCall.GetParamValue(zNear, 0);
+    m_currentFunctionCall.GetParamValue(zFar, 1);
+
+    ::glDepthRangex(zNear, zFar);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glDisable()
+{
+    GLenum cap;
+
+    m_currentFunctionCall.GetParamValue(cap, 0);
+
+    ::glDisable(cap);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glDisableClientState()
+{
+    GLenum array;
+
+    m_currentFunctionCall.GetParamValue(array, 0);
+
+    ::glDisableClientState(array);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glDrawArrays()
+{
+    GLenum mode;
+    GLint first;
+    GLsizei count;
+
+    m_currentFunctionCall.GetParamValue(mode, 0);
+    m_currentFunctionCall.GetParamValue(first, 1);
+    m_currentFunctionCall.GetParamValue(count, 2);
+
+    // Get the data arrays themselves -- note that this is additional data
+    TInt arrayCount, arrayEnabled;
+    m_currentFunctionCall.GetParamValue(arrayCount, 3);
+    m_currentFunctionCall.GetParamValue(arrayEnabled, 4);
+
+    vertexArrayInfo *vertexArrays;
+    vertexArrays = (vertexArrayInfo *) malloc(arrayCount * sizeof(vertexArrayInfo));
+
+    for (int i=0; i<arrayCount; i++)
+    {
+        m_currentFunctionCall.GetParamValue(vertexArrays[i].size, 5 + 4*i);
+        m_currentFunctionCall.GetParamValue(vertexArrays[i].type, 6 + 4*i);
+        m_currentFunctionCall.GetParamValue(vertexArrays[i].stride, 7 + 4*i);
+        TInt size;
+        m_currentFunctionCall.GetVectorData(vertexArrays[i].pointer, size, 8 + 4*i);
+    }
+    
+    int x = 0; //position in the vertexArrays, 'i' in the loop above
+    for(int i=0; i<NUM_ARRAYS; i++) 
+    {
+        switch( i )
+        {
+            case COLOR_ARRAY:
+                if (arrayEnabled & (1<<6))
+                {
+                    ::glColorPointer(vertexArrays[x].size, vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);
+                    x++;
+                }
+                break;
+            case NORMAL_ARRAY:
+                if (arrayEnabled & (1<<5))
+                {
+                    ::glNormalPointer(vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);
+                    x++;
+                }
+                break;
+            case POINT_SIZE_ARRAY:
+                if (arrayEnabled & (1<<4))
+                {
+                    ::glPointSizePointerOES(vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);
+                    x++;
+                }
+                break;
+            case TEX_COORD_ARRAY:
+                if (arrayEnabled & (1<<3))
+                {
+                    ::glTexCoordPointer(vertexArrays[x].size, vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);
+                    x++;
+                }
+                break;
+            case VERTEX_ARRAY:
+                if (arrayEnabled & (1<<2)){
+                    ::glVertexPointer(vertexArrays[x].size, vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);
+                    x++;
+                }
+                break;
+            case MATRIX_INDEX_ARRAY:
+                break;
+            case WEIGHT_ARRAY:
+                break;
+            default:
+                // Do nothing
+                break;
+        }   
+    }
+
+    ::glDrawArrays(mode, first, count);
+    return WriteReply();
+}
+int OGLES11Wrapper::glDrawElements()
+{
+    GLenum mode;
+    GLsizei count;
+    GLenum type;
+    GLvoid *indices;
+
+    m_currentFunctionCall.GetParamValue(mode, 0);
+    m_currentFunctionCall.GetParamValue(count, 1);
+    m_currentFunctionCall.GetParamValue(type, 2);
+    TInt size3;
+    m_currentFunctionCall.GetVectorData(indices, size3, 3);
+
+    // Get the data arrays themselves -- note that this is additional data
+    TInt arrayCount, arrayEnabled;
+    m_currentFunctionCall.GetParamValue(arrayCount, 4);
+    m_currentFunctionCall.GetParamValue(arrayEnabled, 5);
+
+    vertexArrayInfo *vertexArrays;
+    vertexArrays = (vertexArrayInfo *) malloc(arrayCount * sizeof(vertexArrayInfo));
+
+    for (int i=0; i<arrayCount; i++)
+    {
+        m_currentFunctionCall.GetParamValue(vertexArrays[i].size, 6 + 4*i);
+        m_currentFunctionCall.GetParamValue(vertexArrays[i].type, 7 + 4*i);
+        m_currentFunctionCall.GetParamValue(vertexArrays[i].stride, 8 + 4*i);
+        TInt size;
+        m_currentFunctionCall.GetVectorData(vertexArrays[i].pointer, size, 9 + 4*i);
+    }
+    
+    int x = 0; //position in the vertexArrays, 'i' in the loop above
+    for(int i=0; i<NUM_ARRAYS; i++) 
+    {
+        switch( i )
+        {
+            case COLOR_ARRAY:
+                if (arrayEnabled & (1<<6))
+                {
+                    ::glColorPointer(vertexArrays[x].size, vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);
+                    x++;
+                }
+                break;
+            case NORMAL_ARRAY:
+                if (arrayEnabled & (1<<5))
+                {
+                    ::glNormalPointer(vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);
+                    x++;
+                }
+                break;
+            case POINT_SIZE_ARRAY:
+                if (arrayEnabled & (1<<4))
+                {
+                    ::glPointSizePointerOES(vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);
+                    x++;
+                }
+                break;
+            case TEX_COORD_ARRAY:
+                if (arrayEnabled & (1<<3))
+                {
+                    ::glTexCoordPointer(vertexArrays[x].size, vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);
+                    x++;
+                }
+                break;
+            case VERTEX_ARRAY:
+                if (arrayEnabled & (1<<2)){
+                    ::glVertexPointer(vertexArrays[x].size, vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);
+                    x++;
+                }
+                break;
+            case MATRIX_INDEX_ARRAY:
+                break;
+            case WEIGHT_ARRAY:
+                break;
+            default:
+                // Do nothing
+                break;
+        }   
+    }
+
+
+    ::glDrawElements(mode, count, type, indices);
+    return WriteReply();
+}
+int OGLES11Wrapper::glEnable()
+{
+    GLenum cap;
+
+    m_currentFunctionCall.GetParamValue(cap, 0);
+
+    ::glEnable(cap);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glEnableClientState()
+{
+    GLenum array;
+
+    m_currentFunctionCall.GetParamValue(array, 0);
+
+    ::glEnableClientState(array);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glFinish()
+{
+    ::glFinish();
+    return WriteReply();
+}
+int OGLES11Wrapper::glFlush()
+{
+    ::glFlush();
+    return WriteReply();
+}
+int OGLES11Wrapper::glFogf()
+{
+    GLenum pname;
+    GLfloat param;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    m_currentFunctionCall.GetParamValue(param, 1);
+
+    ::glFogf(pname, param);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glFogfv()
+{
+    GLenum pname;
+    GLfloat *params;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    TInt size1;
+    m_currentFunctionCall.GetVectorData(params, size1, 1);
+
+    ::glFogfv(pname, params);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glFogx()
+{
+    GLenum pname;
+    GLfixed param;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    m_currentFunctionCall.GetParamValue(param, 1);
+
+    ::glFogx(pname, param);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glFogxv()
+{
+    GLenum pname;
+    GLfixed *params;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    TInt size1;
+    m_currentFunctionCall.GetVectorData(params, size1, 1);
+
+    ::glFogxv(pname, params);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glFrontFace()
+{
+    GLenum mode;
+
+    m_currentFunctionCall.GetParamValue(mode, 0);
+
+    ::glFrontFace(mode);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glFrustumf()
+{
+    GLfloat left;
+    GLfloat right;
+    GLfloat bottom;
+    GLfloat top;
+    GLfloat zNear;
+    GLfloat zFar;
+
+    m_currentFunctionCall.GetParamValue(left, 0);
+    m_currentFunctionCall.GetParamValue(right, 1);
+    m_currentFunctionCall.GetParamValue(bottom, 2);
+    m_currentFunctionCall.GetParamValue(top, 3);
+    m_currentFunctionCall.GetParamValue(zNear, 4);
+    m_currentFunctionCall.GetParamValue(zFar, 5);
+
+    ::glFrustumf(left, right, bottom, top, zNear, zFar);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glFrustumx()
+{
+    GLfixed left;
+    GLfixed right;
+    GLfixed bottom;
+    GLfixed top;
+    GLfixed zNear;
+    GLfixed zFar;
+
+    m_currentFunctionCall.GetParamValue(left, 0);
+    m_currentFunctionCall.GetParamValue(right, 1);
+    m_currentFunctionCall.GetParamValue(bottom, 2);
+    m_currentFunctionCall.GetParamValue(top, 3);
+    m_currentFunctionCall.GetParamValue(zNear, 4);
+    m_currentFunctionCall.GetParamValue(zFar, 5);
+
+    ::glFrustumx(left, right, bottom, top, zNear, zFar);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glGenBuffers()
+{
+    GLsizei n;
+    m_currentFunctionCall.GetParamValue(n, 0);
+    
+    GLuint *buffers = (GLuint*)iStack->AllocFromStack( n*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLuint ),
+        m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLuint ) );
+
+    ::glGenBuffers(n, buffers);
+
+    m_currentFunctionCall.SetVectorData( buffers, n, 1 ); // EOut
+    //TODO: when do we free the allocated buffer??
+    
+    int ret = WriteReply(); //TODO: clarify the copy-pasted magic sequence
+    iStack->ClearStack();
+    buffers = NULL;
+    return ret; 
+}
+int OGLES11Wrapper::glGenTextures()
+{
+    GLsizei n;
+    m_currentFunctionCall.GetParamValue(n, 0);
+    
+    GLuint *textures = (GLuint*)iStack->AllocFromStack( n*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLuint ),
+        m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLuint ) );
+
+    ::glGenTextures(n, textures);
+
+    m_currentFunctionCall.SetVectorData( textures, n, 1 ); // EOut
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    textures = NULL;
+    return ret;    
+}
+int OGLES11Wrapper::glGetBooleanv()
+{
+    GLenum pname;
+    GLboolean *params;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    TInt size1;
+    m_currentFunctionCall.GetVectorData(params, size1, 1);
+    
+    params = (GLboolean*)iStack->AllocFromStack( size1*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLboolean ),
+        m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLboolean ) );
+        
+    ::glGetBooleanv(pname, params); //TODO: how does the ::glGetBooleanv know the array size?
+    
+    m_currentFunctionCall.SetVectorData( params, size1, 1 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    params = NULL;
+    return ret; 
+}
+int OGLES11Wrapper::glGetBufferParameteriv()
+{
+    GLenum target;
+    GLenum pname;
+    GLint *params;
+
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    TInt size2;
+    m_currentFunctionCall.GetVectorData(params, size2, 2);
+
+    params = (GLint*)iStack->AllocFromStack( size2*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLint ),
+        m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLint ) );
+
+    ::glGetBufferParameteriv(target, pname, params);
+
+    m_currentFunctionCall.SetVectorData( params, size2, 2 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    params = NULL;
+    return ret; 
+}
+int OGLES11Wrapper::glGetClipPlanef()
+{
+    GLenum pname;
+    GLfloat *equation;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    TInt size1;
+    m_currentFunctionCall.GetVectorData(equation, size1, 1);
+
+    equation = (GLfloat*)iStack->AllocFromStack( size1*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLfloat ),
+        m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLfloat ) );
+
+
+    ::glGetClipPlanef(pname, equation);
+
+    m_currentFunctionCall.SetVectorData( equation, size1, 1 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    equation = NULL;
+    return ret; 
+}
+int OGLES11Wrapper::glGetClipPlanex()
+{
+    GLenum pname;
+    GLfixed *eqn;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    TInt size1;
+    m_currentFunctionCall.GetVectorData(eqn, size1, 1);
+
+    eqn = (GLfixed*)iStack->AllocFromStack( size1*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLint ),
+        m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLint ) );
+
+    ::glGetClipPlanex(pname, eqn);
+    
+    m_currentFunctionCall.SetVectorData( eqn, size1, 1 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    eqn = NULL;
+    return ret; 
+}
+int OGLES11Wrapper::glGetError()
+{
+    GLenum ret = ::glGetError();
+    m_currentFunctionCall.SetReturnValue((TUint32) ret);
+    return WriteReply();
+}
+int OGLES11Wrapper::glGetFixedv()
+{
+    GLenum pname;
+    GLfixed *params;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    TInt size1;
+    m_currentFunctionCall.GetVectorData(params, size1, 1);
+
+    params = (GLfixed*)iStack->AllocFromStack( size1*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLint ),
+    m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLint ) );        
+
+    ::glGetFixedv(pname, params);
+
+    m_currentFunctionCall.SetVectorData( params, size1, 1 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    params = NULL;
+    return ret; 
+}
+int OGLES11Wrapper::glGetFloatv()
+{
+    GLenum pname;
+    GLfloat *params;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    TInt size1;
+    m_currentFunctionCall.GetVectorData(params, size1, 1);
+
+    params = (GLfloat*)iStack->AllocFromStack( size1*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLfloat ),
+    m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLfloat ) ); 
+    
+    ::glGetFloatv(pname, params);
+
+    m_currentFunctionCall.SetVectorData( params, size1, 1 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    params = NULL;
+    return ret; 
+}
+int OGLES11Wrapper::glGetIntegerv()
+{
+    GLenum pname;
+    GLint *params;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    TInt size1;
+    m_currentFunctionCall.GetVectorData(params, size1, 1);
+
+    params = (GLint*)iStack->AllocFromStack( size1*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLint ),
+    m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLint ) ); 
+    
+    ::glGetIntegerv(pname, params);
+
+    m_currentFunctionCall.SetVectorData( params, size1, 1 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    params = NULL;
+    return ret;
+}
+int OGLES11Wrapper::glGetLightfv()
+{
+    GLenum light;
+    GLenum pname;
+    GLfloat *params;
+
+    m_currentFunctionCall.GetParamValue(light, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    TInt size2;
+    m_currentFunctionCall.GetVectorData(params, size2, 2);
+
+    params = (GLfloat*)iStack->AllocFromStack( size2*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLfloat ),
+    m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLfloat ) );
+    
+    ::glGetLightfv(light, pname, params);
+    
+    m_currentFunctionCall.SetVectorData( params, size2, 2 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    params = NULL;
+    return ret;
+}
+int OGLES11Wrapper::glGetLightxv()
+{
+    GLenum light;
+    GLenum pname;
+    GLfixed *params;
+
+    m_currentFunctionCall.GetParamValue(light, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    TInt size2;
+    m_currentFunctionCall.GetVectorData(params, size2, 2);
+    
+    params = (GLfixed*)iStack->AllocFromStack( size2*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLint ),
+        m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLint ) );
+
+    ::glGetLightxv(light, pname, params);
+
+    m_currentFunctionCall.SetVectorData( params, size2, 2 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    params = NULL;
+    return ret;
+}
+int OGLES11Wrapper::glGetMaterialfv()
+{
+    GLenum face;
+    GLenum pname;
+    GLfloat *params;
+
+    m_currentFunctionCall.GetParamValue(face, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    TInt size2;
+    m_currentFunctionCall.GetVectorData(params, size2, 2);
+
+    params = (GLfloat*)iStack->AllocFromStack( size2*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLfloat ),
+        m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLfloat ) );
+    
+    ::glGetMaterialfv(face, pname, params);
+
+    m_currentFunctionCall.SetVectorData( params, size2, 2 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    params = NULL;
+    return ret;
+}
+int OGLES11Wrapper::glGetMaterialxv()
+{
+    GLenum face;
+    GLenum pname;
+    GLfixed *params;
+
+    m_currentFunctionCall.GetParamValue(face, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    TInt size2;
+    m_currentFunctionCall.GetVectorData(params, size2, 2);
+
+    params = (GLfixed*)iStack->AllocFromStack( size2*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLint ),
+        m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLint ) );
+        
+    ::glGetMaterialxv(face, pname, params);
+
+    m_currentFunctionCall.SetVectorData( params, size2, 2 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    params = NULL;
+    return ret;
+}
+int OGLES11Wrapper::glGetPointerv()
+{
+    //never gets called?
+    return WriteReply();
+}
+int OGLES11Wrapper::glGetString()
+{
+    // Not used
+    return WriteReply();
+}
+int OGLES11Wrapper::glGetTexEnvfv()
+{
+    GLenum env;
+    GLenum pname;
+    GLfloat *params;
+
+    m_currentFunctionCall.GetParamValue(env, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    TInt size2;
+    m_currentFunctionCall.GetVectorData(params, size2, 2);
+
+    params = (GLfloat*)iStack->AllocFromStack( size2*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLfloat ),
+        m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLfloat ) );
+        
+    ::glGetTexEnvfv(env, pname, params);
+
+    m_currentFunctionCall.SetVectorData( params, size2, 2 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    params = NULL;
+    return ret;
+}
+int OGLES11Wrapper::glGetTexEnviv()
+{
+    GLenum env;
+    GLenum pname;
+    GLint *params;
+
+    m_currentFunctionCall.GetParamValue(env, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    TInt size2;
+    m_currentFunctionCall.GetVectorData(params, size2, 2);
+
+    params = (GLint*)iStack->AllocFromStack( size2*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLint ),
+        m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLint ) );
+        
+    ::glGetTexEnviv(env, pname, params);
+
+    m_currentFunctionCall.SetVectorData( params, size2, 2 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    params = NULL;
+    return ret;
+}
+int OGLES11Wrapper::glGetTexEnvxv()
+{
+    GLenum env;
+    GLenum pname;
+    GLfixed *params;
+
+    m_currentFunctionCall.GetParamValue(env, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    TInt size2;
+    m_currentFunctionCall.GetVectorData(params, size2, 2);
+
+    params = (GLfixed*)iStack->AllocFromStack( size2*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLint ),
+        m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLint ) );
+        
+    ::glGetTexEnvxv(env, pname, params);
+
+    m_currentFunctionCall.SetVectorData( params, size2, 2 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    params = NULL;
+    return ret;
+}
+int OGLES11Wrapper::glGetTexParameterfv()
+{
+    GLenum target;
+    GLenum pname;
+    GLfloat *params;
+
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    TInt size2;
+    m_currentFunctionCall.GetVectorData(params, size2, 2);
+
+    params = (GLfloat*)iStack->AllocFromStack( size2*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLfloat ),    
+        m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLfloat ) );
+        
+    ::glGetTexParameterfv(target, pname, params);
+
+    m_currentFunctionCall.SetVectorData( params, size2, 2 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    params = NULL;
+    return ret;
+}
+int OGLES11Wrapper::glGetTexParameteriv()
+{
+    GLenum target;
+    GLenum pname;
+    GLint *params;
+
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    TInt size2;
+    m_currentFunctionCall.GetVectorData(params, size2, 2);
+
+    params = (GLint*)iStack->AllocFromStack( size2*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLint ),
+        m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLint ) );
+        
+    ::glGetTexParameteriv(target, pname, params);
+
+    m_currentFunctionCall.SetVectorData( params, size2, 2 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    params = NULL;
+    return ret;
+}
+int OGLES11Wrapper::glGetTexParameterxv()
+{
+    GLenum target;
+    GLenum pname;
+    GLfixed *params;
+
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    TInt size2;
+    m_currentFunctionCall.GetVectorData(params, size2, 2);
+
+    params = (GLint*)iStack->AllocFromStack( size2*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLint ),
+        m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLint ) );
+        
+    ::glGetTexParameterxv(target, pname, params);
+    
+    m_currentFunctionCall.SetVectorData( params, size2, 2 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    params = NULL;
+    return ret;
+}
+int OGLES11Wrapper::glHint()
+{
+    GLenum target;
+    GLenum mode;
+
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(mode, 1);
+
+    ::glHint(target, mode);
+    
+    return WriteReply();
+}
+int OGLES11Wrapper::glIsBuffer()
+{
+    GLuint buffer;
+
+    m_currentFunctionCall.GetParamValue(buffer, 0);
+
+    GLboolean ret = ::glIsBuffer(buffer);
+    m_currentFunctionCall.SetReturnValue( ret);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glIsEnabled()
+{
+    GLenum cap;
+    m_currentFunctionCall.GetParamValue(cap, 0);
+    
+    GLboolean ret = ::glIsEnabled(cap);
+    m_currentFunctionCall.SetReturnValue( ret);
+    
+    return WriteReply();
+}
+int OGLES11Wrapper::glIsTexture()
+{
+    GLuint texIndex;
+    m_currentFunctionCall.GetParamValue(texIndex, 0);
+    
+    GLboolean ret = ::glIsEnabled(texIndex);
+    m_currentFunctionCall.SetReturnValue( ret);
+        
+    return WriteReply();
+}
+int OGLES11Wrapper::glLightModelf()
+{
+    GLenum pname;
+    GLfloat param;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    m_currentFunctionCall.GetParamValue(param, 1);
+
+    ::glLightModelf(pname, param);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glLightModelfv()
+{
+    GLenum pname;
+    GLfloat *params;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    TInt size1;
+    m_currentFunctionCall.GetVectorData(params, size1, 1);
+
+    ::glLightModelfv(pname, params);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glLightModelx()
+{
+    GLenum pname;
+    GLfixed param;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    m_currentFunctionCall.GetParamValue(param, 1);
+
+    ::glLightModelx(pname, param);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glLightModelxv()
+{
+    GLenum pname;
+    GLfixed *params;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    TInt size1;
+    m_currentFunctionCall.GetVectorData(params, size1, 1);
+
+    ::glLightModelxv(pname, params);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glLightf()
+{
+    GLenum light;
+    GLenum pname;
+    GLfloat param;
+
+    m_currentFunctionCall.GetParamValue(light, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    m_currentFunctionCall.GetParamValue(param, 2);
+
+    ::glLightf(light, pname, param);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glLightfv()
+{
+    GLenum light;
+    GLenum pname;
+    GLfloat *params;
+
+    m_currentFunctionCall.GetParamValue(light, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    TInt size2;
+    m_currentFunctionCall.GetVectorData(params, size2, 2);
+
+    ::glLightfv(light, pname, params);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glLightx()
+{
+    GLenum light;
+    GLenum pname;
+    GLfixed param;
+
+    m_currentFunctionCall.GetParamValue(light, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    m_currentFunctionCall.GetParamValue(param, 2);
+
+    ::glLightx(light, pname, param);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glLightxv()
+{
+    GLenum light;
+    GLenum pname;
+    GLfixed *params;
+
+    m_currentFunctionCall.GetParamValue(light, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    TInt size2;
+    m_currentFunctionCall.GetVectorData(params, size2, 2);
+
+    ::glLightxv(light, pname, params);
+    return WriteReply();
+}
+int OGLES11Wrapper::glLineWidth()
+{
+    GLfloat width;
+
+    m_currentFunctionCall.GetParamValue(width, 0);
+
+    ::glLineWidth(width);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glLineWidthx()
+{
+    GLfixed width;
+
+    m_currentFunctionCall.GetParamValue(width, 0);
+
+    ::glLineWidthx(width);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glLoadIdentity()
+{
+    ::glLoadIdentity();
+    return WriteReply();
+}
+int OGLES11Wrapper::glLoadMatrixf()
+{
+    GLfloat *m;
+
+    TInt size0;
+    m_currentFunctionCall.GetVectorData(m, size0, 0);
+
+    ::glLoadMatrixf(m);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glLoadMatrixx()
+{
+    GLfixed *m;
+
+    TInt size0;
+    m_currentFunctionCall.GetVectorData(m, size0, 0);
+
+    ::glLoadMatrixx(m);
+    return WriteReply();
+}
+int OGLES11Wrapper::glLogicOp()
+{
+    GLenum opcode;
+
+    m_currentFunctionCall.GetParamValue(opcode, 0);
+
+    ::glLogicOp(opcode);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glMaterialf()
+{
+    GLenum face;
+    GLenum pname;
+    GLfloat param;
+
+    m_currentFunctionCall.GetParamValue(face, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    m_currentFunctionCall.GetParamValue(param, 2);
+
+    ::glMaterialf(face, pname, param);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glMaterialfv()
+{
+    GLenum face;
+    GLenum pname;
+    GLfloat *params;
+
+    m_currentFunctionCall.GetParamValue(face, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    TInt size2;
+    m_currentFunctionCall.GetVectorData(params, size2, 2);
+
+    ::glMaterialfv(face, pname, params);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glMaterialx()
+{
+    GLenum face;
+    GLenum pname;
+    GLfixed param;
+
+    m_currentFunctionCall.GetParamValue(face, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    m_currentFunctionCall.GetParamValue(param, 2);
+
+    ::glMaterialx(face, pname, param);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glMaterialxv()
+{
+    GLenum face;
+    GLenum pname;
+    GLfixed *params;
+
+    m_currentFunctionCall.GetParamValue(face, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    TInt size2;
+    m_currentFunctionCall.GetVectorData(params, size2, 2);
+
+    ::glMaterialxv(face, pname, params);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glMatrixMode()
+{
+    GLenum mode;
+
+    m_currentFunctionCall.GetParamValue(mode, 0);
+
+    ::glMatrixMode(mode);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glMultMatrixf()
+{
+    GLfloat *m;
+
+    TInt size0;
+    m_currentFunctionCall.GetVectorData(m, size0, 0);
+
+    ::glMultMatrixf(m);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glMultMatrixx()
+{
+    GLfixed *m;
+
+    TInt size0;
+    m_currentFunctionCall.GetVectorData(m, size0, 0);
+
+    ::glMultMatrixx(m);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glMultiTexCoord4f()
+{
+    GLenum target;
+    GLfloat s;
+    GLfloat t;
+    GLfloat r;
+    GLfloat q;
+
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(s, 1);
+    m_currentFunctionCall.GetParamValue(t, 2);
+    m_currentFunctionCall.GetParamValue(r, 3);
+    m_currentFunctionCall.GetParamValue(q, 4);
+
+    ::glMultiTexCoord4f(target, s, t, r, q);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glMultiTexCoord4x()
+{
+    GLenum target;
+    GLfixed s;
+    GLfixed t;
+    GLfixed r;
+    GLfixed q;
+
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(s, 1);
+    m_currentFunctionCall.GetParamValue(t, 2);
+    m_currentFunctionCall.GetParamValue(r, 3);
+    m_currentFunctionCall.GetParamValue(q, 4);
+
+    ::glMultiTexCoord4x(target, s, t, r, q);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glNormal3f()
+{
+    GLfloat nx;
+    GLfloat ny;
+    GLfloat nz;
+
+    m_currentFunctionCall.GetParamValue(nx, 0);
+    m_currentFunctionCall.GetParamValue(ny, 1);
+    m_currentFunctionCall.GetParamValue(nz, 2);
+
+    ::glNormal3f(nx, ny, nz);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glNormal3x()
+{
+    GLfixed nx;
+    GLfixed ny;
+    GLfixed nz;
+
+    m_currentFunctionCall.GetParamValue(nx, 0);
+    m_currentFunctionCall.GetParamValue(ny, 1);
+    m_currentFunctionCall.GetParamValue(nz, 2);
+
+    ::glNormal3x(nx, ny, nz);
+
+    return WriteReply();
+}
+
+int OGLES11Wrapper::glOrthof()
+{
+    GLfloat left;
+    GLfloat right;
+    GLfloat bottom;
+    GLfloat top;
+    GLfloat zNear;
+    GLfloat zFar;
+
+    m_currentFunctionCall.GetParamValue(left, 0);
+    m_currentFunctionCall.GetParamValue(right, 1);
+    m_currentFunctionCall.GetParamValue(bottom, 2);
+    m_currentFunctionCall.GetParamValue(top, 3);
+    m_currentFunctionCall.GetParamValue(zNear, 4);
+    m_currentFunctionCall.GetParamValue(zFar, 5);
+
+    ::glOrthof(left, right, bottom, top, zNear, zFar);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glOrthox()
+{
+    GLfixed left;
+    GLfixed right;
+    GLfixed bottom;
+    GLfixed top;
+    GLfixed zNear;
+    GLfixed zFar;
+
+    m_currentFunctionCall.GetParamValue(left, 0);
+    m_currentFunctionCall.GetParamValue(right, 1);
+    m_currentFunctionCall.GetParamValue(bottom, 2);
+    m_currentFunctionCall.GetParamValue(top, 3);
+    m_currentFunctionCall.GetParamValue(zNear, 4);
+    m_currentFunctionCall.GetParamValue(zFar, 5);
+
+    ::glOrthox(left, right, bottom, top, zNear, zFar);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glPixelStorei()
+{
+    GLenum pname;
+    GLint param;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    m_currentFunctionCall.GetParamValue(param, 1);
+
+    ::glPixelStorei(pname, param);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glPointParameterf()
+{
+    GLenum pname;
+    GLfloat param;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    m_currentFunctionCall.GetParamValue(param, 1);
+
+    ::glPointParameterf(pname, param);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glPointParameterfv()
+{
+    GLenum pname;
+    GLfloat *params;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    TInt size1;
+    m_currentFunctionCall.GetVectorData(params, size1, 1);
+
+    ::glPointParameterfv(pname, params);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glPointParameterx()
+{
+    GLenum pname;
+    GLfixed param;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    m_currentFunctionCall.GetParamValue(param, 1);
+
+    ::glPointParameterx(pname, param);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glPointParameterxv()
+{
+    GLenum pname;
+    GLfixed *params;
+
+    m_currentFunctionCall.GetParamValue(pname, 0);
+    TInt size1;
+    m_currentFunctionCall.GetVectorData(params, size1, 1);
+
+    ::glPointParameterxv(pname, params);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glPointSize()
+{
+    GLfloat size;
+
+    m_currentFunctionCall.GetParamValue(size, 0);
+
+    ::glPointSize(size);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glPointSizex()
+{
+    GLfixed size;
+
+    m_currentFunctionCall.GetParamValue(size, 0);
+
+    ::glPointSizex(size);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glPolygonOffset()
+{
+    GLfloat factor;
+    GLfloat units;
+
+    m_currentFunctionCall.GetParamValue(factor, 0);
+    m_currentFunctionCall.GetParamValue(units, 1);
+
+    ::glPolygonOffset(factor, units);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glPolygonOffsetx()
+{
+    GLfixed factor;
+    GLfixed units;
+
+    m_currentFunctionCall.GetParamValue(factor, 0);
+    m_currentFunctionCall.GetParamValue(units, 1);
+
+    ::glPolygonOffsetx(factor, units);
+
+    return WriteReply();
+}
+int OGLES11Wrapper::glPopMatrix()
+{
+    ::glPopMatrix();
+    return WriteReply();
+}
+int OGLES11Wrapper::glPushMatrix()
+{
+    ::glPushMatrix();
+    return WriteReply();
+}
+int OGLES11Wrapper::glReadPixels()
+{
+    GLint x;
+    GLint y;
+    GLsizei width;
+    GLsizei height;
+    GLenum format;
+    GLenum type;
+    GLvoid *pixels;
+
+    m_currentFunctionCall.GetParamValue(x, 0);
+    m_currentFunctionCall.GetParamValue(y, 1);
+    m_currentFunctionCall.GetParamValue(width, 2);
+    m_currentFunctionCall.GetParamValue(height, 3);
+    m_currentFunctionCall.GetParamValue(format, 4);
+    m_currentFunctionCall.GetParamValue(type, 5);
+    TInt size6;
+    m_currentFunctionCall.GetVectorData(pixels, size6, 6);
+
+    pixels = (GLvoid*)iStack->AllocFromStack( size6*m_currentFunctionCall.GetTypeSize( OpenGlES11RFC::EGLvoid ),
+        m_currentFunctionCall.GetTypeAlignment( OpenGlES11RFC::EGLvoid ) );
+
+    ::glReadPixels(x, y, width, height, format, type, pixels);
+
+    m_currentFunctionCall.SetVectorData( pixels, size6, 6 ); // EOut    
+
+    int ret = WriteReply();
+    iStack->ClearStack();
+    pixels = NULL;
+    return ret;
+}
+int OGLES11Wrapper::glRotatef()
+{
+    GLfloat angle, x, y, z;
+    m_currentFunctionCall.GetParamValue(angle, 0);
+    m_currentFunctionCall.GetParamValue(x, 1);
+    m_currentFunctionCall.GetParamValue(y, 2);
+    m_currentFunctionCall.GetParamValue(z, 3);
+    ::glRotatef(angle, x, y, z);
+    return WriteReply();
+}
+int OGLES11Wrapper::glRotatex()
+{
+    GLfixed angle, x, y, z;
+    m_currentFunctionCall.GetParamValue(angle, 0);
+    m_currentFunctionCall.GetParamValue(x, 1);
+    m_currentFunctionCall.GetParamValue(y, 2);
+    m_currentFunctionCall.GetParamValue(z, 3);
+    ::glRotatex(angle, x, y, z);
+    return WriteReply();
+}
+int OGLES11Wrapper::glSampleCoverage()
+{
+    GLclampf value;
+    GLboolean invert;
+    m_currentFunctionCall.GetParamValue(value, 0);
+    m_currentFunctionCall.GetParamValue(invert, 1);
+    ::glSampleCoverage(value, invert);
+    return WriteReply();
+}
+int OGLES11Wrapper::glSampleCoveragex()
+{
+    GLclampx value;
+    GLboolean invert;
+    m_currentFunctionCall.GetParamValue(value, 0);
+    m_currentFunctionCall.GetParamValue(invert, 1);
+    ::glSampleCoveragex(value, invert);
+    return WriteReply();
+}
+int OGLES11Wrapper::glScalef()
+{
+    GLfloat x, y, z;
+    m_currentFunctionCall.GetParamValue(x, 0);
+    m_currentFunctionCall.GetParamValue(y, 1);
+    m_currentFunctionCall.GetParamValue(z, 2);
+    ::glScalef(x, y, z);
+    return WriteReply();
+}
+int OGLES11Wrapper::glScalex()
+{
+    GLfixed x, y, z;
+    m_currentFunctionCall.GetParamValue(x, 0);
+    m_currentFunctionCall.GetParamValue(y, 1);
+    m_currentFunctionCall.GetParamValue(z, 2);
+    ::glScalex(x, y, z);
+    return WriteReply();
+}
+int OGLES11Wrapper::glScissor()
+{
+    GLint x, y;
+    GLsizei width, height;
+    m_currentFunctionCall.GetParamValue(x, 0);
+    m_currentFunctionCall.GetParamValue(y, 1);
+    m_currentFunctionCall.GetParamValue(width, 2);
+    m_currentFunctionCall.GetParamValue(height, 3);
+    ::glScissor(x, y, width, height);
+    return WriteReply();
+}
+int OGLES11Wrapper::glShadeModel()
+{
+    GLenum mode;
+    m_currentFunctionCall.GetParamValue(mode, 0);
+    ::glShadeModel(mode);
+    return WriteReply();
+}
+int OGLES11Wrapper::glStencilFunc()
+{
+    GLenum func;
+    GLint ref;
+    GLuint mask;
+    m_currentFunctionCall.GetParamValue(func, 0);
+    m_currentFunctionCall.GetParamValue(ref, 1);
+    m_currentFunctionCall.GetParamValue(mask, 2);
+    ::glStencilFunc(func, ref, mask);
+    return WriteReply();
+}
+int OGLES11Wrapper::glStencilMask()
+{
+    GLuint mask;
+    m_currentFunctionCall.GetParamValue(mask, 0);
+    ::glStencilMask(mask);
+    return WriteReply();
+}
+int OGLES11Wrapper::glStencilOp()
+{
+    GLenum fail, zfail, zpass;
+    m_currentFunctionCall.GetParamValue(fail, 0);
+    m_currentFunctionCall.GetParamValue(zfail, 1);
+    m_currentFunctionCall.GetParamValue(zpass, 2);
+    ::glStencilOp (fail, zfail, zpass);
+    return WriteReply();
+}
+int OGLES11Wrapper::glTexEnvf()
+{
+    GLenum target, pname;
+    GLfloat param;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    m_currentFunctionCall.GetParamValue(param, 2);
+    ::glTexEnvf(target, pname, param);
+    return WriteReply();
+}
+int OGLES11Wrapper::glTexEnvfv()
+{
+    GLenum target, pname;
+    GLfloat *params;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+
+    TInt size;
+    m_currentFunctionCall.GetVectorData(params, size, 2);
+
+    ::glTexEnvfv(target, pname, params);
+    return WriteReply();
+}
+int OGLES11Wrapper::glTexEnvi()
+{
+    GLenum target, pname;
+    GLint param;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    m_currentFunctionCall.GetParamValue(param, 2);
+    ::glTexEnvi(target, pname, param);
+    return WriteReply();
+}
+int OGLES11Wrapper::glTexEnviv()
+{
+    GLenum target, pname;
+    GLint *params;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+
+    TInt size;
+    m_currentFunctionCall.GetVectorData(params, size, 2);
+
+    ::glTexEnviv(target, pname, params);
+    return WriteReply();
+}
+int OGLES11Wrapper::glTexEnvx()
+{
+    GLenum target, pname;
+    GLfixed param;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    m_currentFunctionCall.GetParamValue(param, 2);
+    ::glTexEnvx(target, pname, param);
+    return WriteReply();
+}
+int OGLES11Wrapper::glTexEnvxv()
+{
+    GLenum target, pname;
+    GLfixed *params;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+
+    TInt size;
+    m_currentFunctionCall.GetVectorData(params, size, 2);
+
+    ::glTexEnvxv(target, pname, params);
+    return WriteReply();
+}
+int OGLES11Wrapper::glTexImage2D()
+{
+    GLenum target;
+    GLint level;
+    GLint internalformat;
+    GLsizei width;
+    GLsizei height;
+    GLint border;
+    GLenum format;
+    GLenum type;
+    GLvoid *pixels;
+
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(level, 1);
+    m_currentFunctionCall.GetParamValue(internalformat, 2);
+    m_currentFunctionCall.GetParamValue(width, 3);
+    m_currentFunctionCall.GetParamValue(height, 4);
+    m_currentFunctionCall.GetParamValue(border, 5);
+    m_currentFunctionCall.GetParamValue(format, 6);
+    m_currentFunctionCall.GetParamValue(type, 7);
+
+    TInt size;
+    m_currentFunctionCall.GetVectorData(pixels, size, 8);
+
+    ::glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    return WriteReply();
+}
+int OGLES11Wrapper::glTexParameterf()
+{
+    GLenum target, pname;
+    GLfloat param;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    m_currentFunctionCall.GetParamValue(param, 2);
+    ::glTexParameterf(target, pname, param);
+    return WriteReply();
+}
+int OGLES11Wrapper::glTexParameterfv()
+{
+    GLenum target, pname;
+    GLfloat *params;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+
+    TInt size;
+    m_currentFunctionCall.GetVectorData(params, size, 2);
+
+    ::glTexParameterfv(target, pname, params);
+    return WriteReply();
+}
+int OGLES11Wrapper::glTexParameteri()
+{
+    GLenum target, pname;
+    GLint param;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    m_currentFunctionCall.GetParamValue(param, 2);
+    ::glTexParameteri(target, pname, param);
+    return WriteReply();
+}
+int OGLES11Wrapper::glTexParameteriv()
+{
+    GLenum target, pname;
+    GLint *params;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+
+    TInt size;
+    m_currentFunctionCall.GetVectorData(params, size, 2);
+
+    ::glTexParameteriv(target, pname, params);
+    return WriteReply();
+}
+int OGLES11Wrapper::glTexParameterx()
+{
+    GLenum target, pname;
+    GLfixed param;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+    m_currentFunctionCall.GetParamValue(param, 2);
+    ::glTexParameterx(target, pname, param);
+    return WriteReply();
+}
+int OGLES11Wrapper::glTexParameterxv()
+{
+    GLenum target, pname;
+    GLfixed *params;
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(pname, 1);
+
+    TInt size;
+    m_currentFunctionCall.GetVectorData(params, size, 2);
+
+    ::glTexParameterxv(target, pname, params);
+    return WriteReply();
+}
+int OGLES11Wrapper::glTexSubImage2D()
+{
+    GLenum target;
+    GLint level;
+    GLint xoffset;
+    GLint yoffset;
+    GLsizei width;
+    GLsizei height;
+    GLenum format;
+    GLenum type;
+    GLvoid *pixels;
+
+    m_currentFunctionCall.GetParamValue(target, 0);
+    m_currentFunctionCall.GetParamValue(level, 1);
+    m_currentFunctionCall.GetParamValue(xoffset, 2);
+    m_currentFunctionCall.GetParamValue(yoffset, 3);
+    m_currentFunctionCall.GetParamValue(width, 4);
+    m_currentFunctionCall.GetParamValue(height, 5);
+    m_currentFunctionCall.GetParamValue(format, 6);
+    m_currentFunctionCall.GetParamValue(type, 7);
+    TInt size8;
+    m_currentFunctionCall.GetVectorData(pixels, size8, 8);
+
+    ::glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    return WriteReply();
+}
+int OGLES11Wrapper::glTranslatef()
+{
+    GLfloat x, y, z;
+    m_currentFunctionCall.GetParamValue(x, 0);
+    m_currentFunctionCall.GetParamValue(y, 1);
+    m_currentFunctionCall.GetParamValue(z, 2);
+    ::glTranslatef(x, y, z);
+    return WriteReply();
+}
+int OGLES11Wrapper::glTranslatex()
+{
+    GLfixed x, y, z;
+    m_currentFunctionCall.GetParamValue(x, 0);
+    m_currentFunctionCall.GetParamValue(y, 1);
+    m_currentFunctionCall.GetParamValue(z, 2);
+    ::glTranslatex(x, y, z);
+    return WriteReply();
+}
+int OGLES11Wrapper::glViewport()
+{
+    GLint x, y;
+    GLsizei width, height;
+    m_currentFunctionCall.GetParamValue(x, 0);
+    m_currentFunctionCall.GetParamValue(y, 1);
+    m_currentFunctionCall.GetParamValue(width, 2);
+    m_currentFunctionCall.GetParamValue(height, 3);
+    ::glViewport(x, y, width, height);
+    return WriteReply();
+}
+int OGLES11Wrapper::glCurrentPaletteMatrixOES()
+{
+    return 0;
+}
+int OGLES11Wrapper::glDrawTexfOES()
+{
+    return 0;
+}
+int OGLES11Wrapper::glDrawTexfvOES()
+{
+    return 0;
+}
+int OGLES11Wrapper::glDrawTexiOES()
+{
+    return 0;
+}
+int OGLES11Wrapper::glDrawTexivOES()
+{
+    return 0;
+}
+int OGLES11Wrapper::glDrawTexsOES()
+{
+    return 0;
+}
+int OGLES11Wrapper::glDrawTexsvOES()
+{
+    return 0;
+}
+int OGLES11Wrapper::glDrawTexxOES()
+{
+    return 0;
+}
+int OGLES11Wrapper::glDrawTexxvOES()
+{
+    return 0;
+}
+int OGLES11Wrapper::glLoadPaletteFromModelViewMatrixOES()
+{
+    return 0;
+}
+int OGLES11Wrapper::glQueryMatrixxOES()
+{
+    return 0;
+}