--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/vghwinterface/vghwapiwrapper/src/opengles11apiwrapper.cpp Wed Oct 06 17:59:01 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;
+}