1 // Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // 

    15 

    16 #ifdef WIN32

    17 #define WIN32_LEAN_AND_MEAN                       // Exclude rarely-used stuff from Windows headers

    18 #include <windows.h>

    19 #endif

    20 

    21 #include <stdio.h>

    22 #include <stdlib.h>

    23 #include <GLES/gl.h>

    24 #include "opengles11apiwrapper.h"

    25 #include "serializedfunctioncall.h"

    26 #include "remotefunctioncall.h"

    27 #include "khronosapiwrapperdefs.h"

    28 

    29 #include "openvgrfc.h"

    30 

    31 

    32 OGLES11Wrapper::OGLES11Wrapper(RemoteFunctionCallData& currentFunctionCallData,

    33             APIWrapperStack* stack,

    34             void* result,

    35             MGraphicsVHWCallback* serviceIf):

    36 APIWrapper(currentFunctionCallData, stack, result, serviceIf),

    37 m_currentFunctionCall(m_currentFunctionCallData)

    38 {

    39 }

    40 

    41 int OGLES11Wrapper::DispatchRequest(unsigned long aCode)

    42 {

    43     int ret(0);

    44     TRACE("OpenGLES11APIWrapper: OpenGL ES Op command received: %u\n", aCode);

    45 

    46     switch ( aCode )

    47     {

    48     case OpenGlES11RFC::EglActiveTexture:

    49         ret = glActiveTexture();

    50         break;

    51     case OpenGlES11RFC::EglAlphaFunc:

    52         ret = glAlphaFunc();

    53         break;

    54     case OpenGlES11RFC::EglAlphaFuncx:

    55         ret = glAlphaFuncx();

    56         break;

    57     case OpenGlES11RFC::EglBindBuffer:

    58         ret = glBindBuffer();

    59         break;

    60     case OpenGlES11RFC::EglBindTexture:

    61         ret = glBindTexture();

    62         break;

    63     case OpenGlES11RFC::EglBlendFunc:

    64         ret = glBlendFunc();

    65         break;

    66     case OpenGlES11RFC::EglBufferData:

    67         ret = glBufferData();

    68         break;

    69     case OpenGlES11RFC::EglBufferSubData:

    70         ret = glBufferSubData();

    71         break;

    72     case OpenGlES11RFC::EglClear:

    73         ret = glClear();

    74         break;

    75     case OpenGlES11RFC::EglClearColor:

    76         ret = glClearColor();

    77         break;

    78     case OpenGlES11RFC::EglClearColorx:

    79         ret = glClearColorx();

    80         break;

    81     case OpenGlES11RFC::EglClearDepthf:

    82         ret = glClearDepthf();

    83         break;

    84     case OpenGlES11RFC::EglClearDepthx:

    85         ret = glClearDepthx();

    86         break;

    87     case OpenGlES11RFC::EglClearStencil:

    88         ret = glClearStencil();

    89         break;

    90     case OpenGlES11RFC::EglClientActiveTexture:

    91         ret = glClientActiveTexture();

    92         break;

    93     case OpenGlES11RFC::EglClipPlanef:

    94         ret = glClipPlanef();

    95         break;

    96     case OpenGlES11RFC::EglClipPlanex:

    97         ret = glClipPlanex();

    98         break;

    99     case OpenGlES11RFC::EglColor4f:

   100         ret = glColor4f();

   101         break;

   102     case OpenGlES11RFC::EglColor4ub:

   103         ret = glColor4ub();

   104         break;

   105     case OpenGlES11RFC::EglColor4x:

   106         ret = glColor4x();

   107         break;

   108     case OpenGlES11RFC::EglColorMask:

   109         ret = glColorMask();

   110         break;

   111     case OpenGlES11RFC::EglCompressedTexImage2D:

   112         ret = glCompressedTexImage2D();

   113         break;

   114     case OpenGlES11RFC::EglCompressedTexSubImage2D:

   115         ret = glCompressedTexSubImage2D();

   116         break;

   117     case OpenGlES11RFC::EglCopyTexImage2D:

   118         ret = glCopyTexImage2D();

   119         break;

   120     case OpenGlES11RFC::EglCopyTexSubImage2D:

   121         ret = glCopyTexSubImage2D();

   122         break;

   123     case OpenGlES11RFC::EglCullFace:

   124         ret = glCullFace();

   125         break;

   126     case OpenGlES11RFC::EglDeleteBuffers:

   127         ret = glDeleteBuffers();

   128         break;

   129     case OpenGlES11RFC::EglDeleteTextures:

   130         ret = glDeleteTextures();

   131         break;

   132     case OpenGlES11RFC::EglDepthFunc:

   133         ret = glDepthFunc();

   134         break;

   135     case OpenGlES11RFC::EglDepthMask:

   136         ret = glDepthMask();

   137         break;

   138     case OpenGlES11RFC::EglDepthRangef:

   139         ret = glDepthRangef();

   140         break;

   141     case OpenGlES11RFC::EglDepthRangex:

   142         ret = glDepthRangex();

   143         break;

   144     case OpenGlES11RFC::EglDisable:

   145         ret = glDisable();

   146         break;

   147     case OpenGlES11RFC::EglDisableClientState:

   148         ret = glDisableClientState();

   149         break;

   150     case OpenGlES11RFC::EglDrawArrays:

   151         ret = glDrawArrays();

   152         break;

   153     case OpenGlES11RFC::EglDrawElements:

   154         ret = glDrawElements();

   155         break;

   156     case OpenGlES11RFC::EglEnable:

   157         ret = glEnable();

   158         break;

   159     case OpenGlES11RFC::EglEnableClientState:

   160         ret = glEnableClientState();

   161         break;

   162     case OpenGlES11RFC::EglFinish:

   163         ret = glFinish();

   164         break;

   165     case OpenGlES11RFC::EglFlush:

   166         ret = glFlush();

   167         break;

   168     case OpenGlES11RFC::EglFogf:

   169         ret = glFogf();

   170         break;

   171     case OpenGlES11RFC::EglFogfv:

   172         ret = glFogfv();

   173         break;

   174     case OpenGlES11RFC::EglFogx:

   175         ret = glFogx();

   176         break;

   177     case OpenGlES11RFC::EglFogxv:

   178         ret = glFogxv();

   179         break;

   180     case OpenGlES11RFC::EglFrontFace:

   181         ret = glFrontFace();

   182         break;

   183     case OpenGlES11RFC::EglFrustumf:

   184         ret = glFrustumf();

   185         break;

   186     case OpenGlES11RFC::EglFrustumx:

   187         ret = glFrustumx();

   188         break;

   189     case OpenGlES11RFC::EglGenBuffers:

   190         ret = glGenBuffers();

   191         break;

   192     case OpenGlES11RFC::EglGenTextures:

   193         ret = glGenTextures();

   194         break;

   195     case OpenGlES11RFC::EglGetBooleanv:

   196         ret = glGetBooleanv();

   197         break;

   198     case OpenGlES11RFC::EglGetBufferParameteriv:

   199         ret = glGetBufferParameteriv();

   200         break;

   201     case OpenGlES11RFC::EglGetClipPlanef:

   202         ret = glGetClipPlanef();

   203         break;

   204     case OpenGlES11RFC::EglGetClipPlanex:

   205         ret = glGetClipPlanex();

   206         break;

   207     case OpenGlES11RFC::EglGetError:

   208         ret = glGetError();

   209         break;

   210     case OpenGlES11RFC::EglGetFixedv:

   211         ret = glGetFixedv();

   212         break;

   213     case OpenGlES11RFC::EglGetFloatv:

   214         ret = glGetFloatv();

   215         break;

   216     case OpenGlES11RFC::EglGetIntegerv:

   217         ret = glGetIntegerv();

   218         break;

   219     case OpenGlES11RFC::EglGetLightfv:

   220         ret = glGetLightfv();

   221         break;

   222     case OpenGlES11RFC::EglGetLightxv:

   223         ret = glGetLightxv();

   224         break;

   225     case OpenGlES11RFC::EglGetMaterialfv:

   226         ret = glGetMaterialfv();

   227         break;

   228     case OpenGlES11RFC::EglGetMaterialxv:

   229         ret = glGetMaterialxv();

   230         break;

   231     case OpenGlES11RFC::EglGetPointerv:

   232         ret = glGetPointerv();

   233         break;

   234 //  case OpenGlES11RFC::EglGetString:

   235 //      ret = glGetString();

   236 //      break;

   237     case OpenGlES11RFC::EglGetTexEnvfv:

   238         ret = glGetTexEnvfv();

   239         break;

   240     case OpenGlES11RFC::EglGetTexEnviv:

   241         ret = glGetTexEnviv();

   242         break;

   243     case OpenGlES11RFC::EglGetTexEnvxv:

   244         ret = glGetTexEnvxv();

   245         break;

   246     case OpenGlES11RFC::EglGetTexParameterfv:

   247         ret = glGetTexParameterfv();

   248         break;

   249     case OpenGlES11RFC::EglGetTexParameteriv:

   250         ret = glGetTexParameteriv();

   251         break;

   252     case OpenGlES11RFC::EglGetTexParameterxv:

   253         ret = glGetTexParameterxv();

   254         break;

   255     case OpenGlES11RFC::EglHint:

   256         ret = glHint();

   257         break;

   258     case OpenGlES11RFC::EglIsBuffer:

   259         ret = glIsBuffer();

   260         break;

   261     case OpenGlES11RFC::EglIsEnabled:

   262         ret = glIsEnabled();

   263         break;

   264     case OpenGlES11RFC::EglIsTexture:

   265         ret = glIsTexture();

   266         break;

   267     case OpenGlES11RFC::EglLightModelf:

   268         ret = glLightModelf();

   269         break;

   270     case OpenGlES11RFC::EglLightModelfv:

   271         ret = glLightModelfv();

   272         break;

   273     case OpenGlES11RFC::EglLightModelx:

   274         ret = glLightModelx();

   275         break;

   276     case OpenGlES11RFC::EglLightModelxv:

   277         ret = glLightModelxv();

   278         break;

   279     case OpenGlES11RFC::EglLightf:

   280         ret = glLightf();

   281         break;

   282     case OpenGlES11RFC::EglLightfv:

   283         ret = glLightfv();

   284         break;

   285     case OpenGlES11RFC::EglLightx:

   286         ret = glLightx();

   287         break;

   288     case OpenGlES11RFC::EglLightxv:

   289         ret = glLightxv();

   290         break;

   291     case OpenGlES11RFC::EglLineWidth:

   292         ret = glLineWidth();

   293         break;

   294     case OpenGlES11RFC::EglLineWidthx:

   295         ret = glLineWidthx();

   296         break;

   297     case OpenGlES11RFC::EglLoadIdentity:

   298         ret = glLoadIdentity();

   299         break;

   300     case OpenGlES11RFC::EglLoadMatrixf:

   301         ret = glLoadMatrixf();

   302         break;

   303     case OpenGlES11RFC::EglLoadMatrixx:

   304         ret = glLoadMatrixx();

   305         break;

   306     case OpenGlES11RFC::EglLogicOp:

   307         ret = glLogicOp();

   308         break;

   309     case OpenGlES11RFC::EglMaterialf:

   310         ret = glMaterialf();

   311         break;

   312     case OpenGlES11RFC::EglMaterialfv:

   313         ret = glMaterialfv();

   314         break;

   315     case OpenGlES11RFC::EglMaterialx:

   316         ret = glMaterialx();

   317         break;

   318     case OpenGlES11RFC::EglMaterialxv:

   319         ret = glMaterialxv();

   320         break;

   321     case OpenGlES11RFC::EglMatrixMode:

   322         ret = glMatrixMode();

   323         break;

   324     case OpenGlES11RFC::EglMultMatrixf:

   325         ret = glMultMatrixf();

   326         break;

   327     case OpenGlES11RFC::EglMultMatrixx:

   328         ret = glMultMatrixx();

   329         break;

   330     case OpenGlES11RFC::EglMultiTexCoord4f:

   331         ret = glMultiTexCoord4f();

   332         break;

   333     case OpenGlES11RFC::EglMultiTexCoord4x:

   334         ret = glMultiTexCoord4x();

   335         break;

   336     case OpenGlES11RFC::EglNormal3f:

   337         ret = glNormal3f();

   338         break;

   339     case OpenGlES11RFC::EglNormal3x:

   340         ret = glNormal3x();

   341         break;

   342     case OpenGlES11RFC::EglOrthof:

   343         ret = glOrthof();

   344         break;

   345     case OpenGlES11RFC::EglOrthox:

   346         ret = glOrthox();

   347         break;

   348     case OpenGlES11RFC::EglPixelStorei:

   349         ret = glPixelStorei();

   350         break;

   351     case OpenGlES11RFC::EglPointParameterf:

   352         ret = glPointParameterf();

   353         break;

   354     case OpenGlES11RFC::EglPointParameterfv:

   355         ret = glPointParameterfv();

   356         break;

   357     case OpenGlES11RFC::EglPointParameterx:

   358         ret = glPointParameterx();

   359         break;

   360     case OpenGlES11RFC::EglPointParameterxv:

   361         ret = glPointParameterxv();

   362         break;

   363     case OpenGlES11RFC::EglPointSize:

   364         ret = glPointSize();

   365         break;

   366     case OpenGlES11RFC::EglPointSizex:

   367         ret = glPointSizex();

   368         break;

   369     case OpenGlES11RFC::EglPolygonOffset:

   370         ret = glPolygonOffset();

   371         break;

   372     case OpenGlES11RFC::EglPolygonOffsetx:

   373         ret = glPolygonOffsetx();

   374         break;

   375     case OpenGlES11RFC::EglPopMatrix:

   376         ret = glPopMatrix();

   377         break;

   378     case OpenGlES11RFC::EglPushMatrix:

   379         ret = glPushMatrix();

   380         break;

   381     case OpenGlES11RFC::EglReadPixels:

   382         ret = glReadPixels();

   383         break;

   384     case OpenGlES11RFC::EglRotatef:

   385         ret = glRotatef();

   386         break;

   387     case OpenGlES11RFC::EglRotatex:

   388         ret = glRotatex();

   389         break;

   390     case OpenGlES11RFC::EglSampleCoverage:

   391         ret = glSampleCoverage();

   392         break;

   393     case OpenGlES11RFC::EglSampleCoveragex:

   394         ret = glSampleCoveragex();

   395         break;

   396     case OpenGlES11RFC::EglScalef:

   397         ret = glScalef();

   398         break;

   399     case OpenGlES11RFC::EglScalex:

   400         ret = glScalex();

   401         break;

   402     case OpenGlES11RFC::EglScissor:

   403         ret = glScissor();

   404         break;

   405     case OpenGlES11RFC::EglShadeModel:

   406         ret = glShadeModel();

   407         break;

   408     case OpenGlES11RFC::EglStencilFunc:

   409         ret = glStencilFunc();

   410         break;

   411     case OpenGlES11RFC::EglStencilMask:

   412         ret = glStencilMask();

   413         break;

   414     case OpenGlES11RFC::EglStencilOp:

   415         ret = glStencilOp();

   416         break;

   417     case OpenGlES11RFC::EglTexEnvf:

   418         ret = glTexEnvf();

   419         break;

   420     case OpenGlES11RFC::EglTexEnvfv:

   421         ret = glTexEnvfv();

   422         break;

   423     case OpenGlES11RFC::EglTexEnvi:

   424         ret = glTexEnvi();

   425         break;

   426     case OpenGlES11RFC::EglTexEnviv:

   427         ret = glTexEnviv();

   428         break;

   429     case OpenGlES11RFC::EglTexEnvx:

   430         ret = glTexEnvx();

   431         break;

   432     case OpenGlES11RFC::EglTexEnvxv:

   433         ret = glTexEnvxv();

   434         break;

   435     case OpenGlES11RFC::EglTexImage2D:

   436         ret = glTexImage2D();

   437         break;

   438     case OpenGlES11RFC::EglTexParameterf:

   439         ret = glTexParameterf();

   440         break;

   441     case OpenGlES11RFC::EglTexParameterfv:

   442         ret = glTexParameterfv();

   443         break;

   444     case OpenGlES11RFC::EglTexParameteri:

   445         ret = glTexParameteri();

   446         break;

   447     case OpenGlES11RFC::EglTexParameteriv:

   448         ret = glTexParameteriv();

   449         break;

   450     case OpenGlES11RFC::EglTexParameterx:

   451         ret = glTexParameterx();

   452         break;

   453     case OpenGlES11RFC::EglTexParameterxv:

   454         ret = glTexParameterxv();

   455         break;

   456     case OpenGlES11RFC::EglTexSubImage2D:

   457         ret = glTexSubImage2D();

   458         break;

   459     case OpenGlES11RFC::EglTranslatef:

   460         ret = glTranslatef();

   461         break;

   462     case OpenGlES11RFC::EglTranslatex:

   463         ret = glTranslatex();

   464         break;

   465     case OpenGlES11RFC::EglViewport:

   466         ret = glViewport();

   467         break;

   468 

   469     // from Eglextplatform.h

   470     case OpenGlES11RFC::EglCurrentPaletteMatrixOES:

   471         ret = glCurrentPaletteMatrixOES();

   472         break;

   473     case OpenGlES11RFC::EglDrawTexfOES:

   474         ret = glDrawTexfOES();

   475         break;

   476     case OpenGlES11RFC::EglDrawTexfvOES:

   477         ret = glDrawTexfvOES();

   478         break;

   479     case OpenGlES11RFC::EglDrawTexiOES:

   480         ret = glDrawTexiOES();

   481         break;

   482     case OpenGlES11RFC::EglDrawTexivOES:

   483         ret = glDrawTexivOES();

   484         break;

   485     case OpenGlES11RFC::EglDrawTexsOES:

   486         ret = glDrawTexsOES();

   487         break;

   488     case OpenGlES11RFC::EglDrawTexsvOES:

   489         ret = glDrawTexsvOES();

   490         break;

   491     case OpenGlES11RFC::EglDrawTexxOES:

   492         ret = glDrawTexxOES();

   493         break;

   494     case OpenGlES11RFC::EglDrawTexxvOES:

   495         ret = glDrawTexxvOES();

   496         break;

   497     case OpenGlES11RFC::EglLoadPaletteFromModelViewMatrixOES:

   498         ret = glLoadPaletteFromModelViewMatrixOES();

   499         break;

   500     case OpenGlES11RFC::EglQueryMatrixxOES:

   501         ret = glQueryMatrixxOES();

   502         break;

   503 

   504     case OpenGlES11RFC::EglColorPointer:

   505     case OpenGlES11RFC::EglNormalPointer:

   506     case OpenGlES11RFC::EglTexCoordPointer:

   507     case OpenGlES11RFC::EglVertexPointer:

   508     case OpenGlES11RFC::EglMatrixIndexPointerOES:

   509     case OpenGlES11RFC::EglWeightPointerOES:    

   510         TRACE("OpenGLES11APIWrapper: ERROR! Vertex pointer functions are not handled directly, should not be here\n");

   511         break;

   512         

   513     // client shutdown

   514     case OpenGlES11RFC::EClientShutdown:

   515         TRACE("OpenGLES11APIWrapper: Client shutdown unimplemented\n");

   516         break;

   517 

   518     default:

   519         TRACE("OpenGLES11APIWrapper: Unimplemented OpenGL ES Op code %u\n",aCode);

   520         break;

   521     }

   522     TRACE("OpenGLES11APIWrapper: OpenGL ES 1.1 command processed\n");

   523     return ret;

   524 }

   525 

   526 int OGLES11Wrapper::WriteReply()

   527 {

   528 #ifdef LOG_ERROR

   529     int operationid = (int)m_currentFunctionCall.Data().Header().iOpCode;

   530     

   531     int glerror = ::glGetError();

   532     if ( m_lastGlError != glerror )

   533     {

   534         if ( GL_NO_ERROR != glerror )

   535         {

   536             TRACE("OpenGLES11APIWrapper: OpenGL error 0x%X, for request %d\n", glerror, operationid );

   537         }

   538         m_lastGlError = glerror;

   539     }

   540 #endif

   541     return APIWrapper::WriteReply();

   542 }

   543 

   544 // ///////////////////////////////////////////////////

   545 // Here follows the functions that map to the GL calls

   546 

   547 

   548 int OGLES11Wrapper::glActiveTexture()

   549 {

   550     GLenum texture;

   551     m_currentFunctionCall.GetParamValue(texture, 0);

   552     ::glActiveTexture(texture);

   553     return WriteReply();

   554 }

   555 int OGLES11Wrapper::glAlphaFunc()

   556 {

   557     GLenum func;

   558     m_currentFunctionCall.GetParamValue(func, 0);

   559     GLclampf ref;

   560     m_currentFunctionCall.GetParamValue(ref, 1);

   561     ::glAlphaFunc(func, ref);

   562     return WriteReply();

   563 }

   564 int OGLES11Wrapper::glAlphaFuncx()

   565 {

   566     GLenum func;

   567     m_currentFunctionCall.GetParamValue(func, 0);

   568     GLclampx ref;

   569     m_currentFunctionCall.GetParamValue(ref, 1);

   570     ::glAlphaFuncx(func, ref);

   571     return WriteReply();

   572 }

   573 int OGLES11Wrapper::glBindBuffer()

   574 {

   575     GLenum target;

   576     m_currentFunctionCall.GetParamValue(target, 0);    

   577     GLuint buffer;

   578     m_currentFunctionCall.GetParamValue(buffer, 1);

   579     ::glBindBuffer(target, buffer);

   580     return WriteReply();

   581 }

   582 int OGLES11Wrapper::glBindTexture()

   583 {

   584     GLenum target;

   585     m_currentFunctionCall.GetParamValue(target, 0);    

   586     GLuint texIndex;

   587     m_currentFunctionCall.GetParamValue(texIndex, 1);

   588     ::glBindTexture(target, texIndex);

   589     return WriteReply();

   590 }

   591 int OGLES11Wrapper::glBlendFunc()

   592 {

   593     GLenum src;

   594     m_currentFunctionCall.GetParamValue(src, 0);

   595     GLenum dst;

   596     m_currentFunctionCall.GetParamValue(dst, 1);

   597     ::glBlendFunc(src, dst);

   598     return WriteReply();

   599 }

   600 int OGLES11Wrapper::glBufferData()

   601 {

   602     GLenum target;

   603     m_currentFunctionCall.GetParamValue(target, 0);

   604     //GLsizeiptr size;    

   605     GLint size;

   606     m_currentFunctionCall.GetParamValue(size, 1);

   607     

   608     void* data;

   609     //GLsizeiptr size2;

   610     GLint size2;

   611     m_currentFunctionCall.GetVectorData(data, size2, 2); //is this correct??

   612     //size == size2 ?

   613     

   614     GLenum usage;

   615     m_currentFunctionCall.GetParamValue(usage, 3);

   616     ::glBufferData(target, size, data, usage);

   617     return WriteReply();

   618 }

   619 int OGLES11Wrapper::glBufferSubData()

   620 {

   621     GLenum target;

   622     m_currentFunctionCall.GetParamValue(target, 0);

   623     //GLintptr offset;

   624     GLint offset;

   625     m_currentFunctionCall.GetParamValue(offset, 1);

   626     //GLsizeiptr size;

   627     GLint size;

   628     m_currentFunctionCall.GetParamValue(size, 2);

   629     void* data;

   630     //GLsizeiptr size2;

   631     GLint size2;

   632     m_currentFunctionCall.GetVectorData(data, size2, 3); //is this correct??

   633     ::glBufferSubData(target,offset,size,data);

   634     return WriteReply();

   635 }

   636 int OGLES11Wrapper::glClear()

   637 {

   638     GLbitfield buf;

   639     m_currentFunctionCall.GetParamValue(buf, 0);

   640     ::glClear(buf);

   641     return WriteReply();

   642 }

   643 int OGLES11Wrapper::glClearColor()

   644 {

   645     GLclampf r;

   646     m_currentFunctionCall.GetParamValue(r, 0);

   647     GLclampf g;

   648     m_currentFunctionCall.GetParamValue(g, 1);

   649     GLclampf b;

   650     m_currentFunctionCall.GetParamValue(b, 2);

   651     GLclampf a;

   652     m_currentFunctionCall.GetParamValue(a, 3);

   653     ::glClearColor(r,g,b,a);

   654     return WriteReply();

   655 }

   656 int OGLES11Wrapper::glClearColorx()

   657 {

   658     GLclampx r;

   659     m_currentFunctionCall.GetParamValue(r, 0);

   660     GLclampx g;

   661     m_currentFunctionCall.GetParamValue(g, 1);

   662     GLclampx b;

   663     m_currentFunctionCall.GetParamValue(b, 2);

   664     GLclampx a;

   665     m_currentFunctionCall.GetParamValue(a, 3);

   666     ::glClearColorx(r,g,b,a);

   667     return WriteReply();

   668 }

   669 int OGLES11Wrapper::glClearDepthf()

   670 {

   671     GLclampf d;

   672     m_currentFunctionCall.GetParamValue(d, 0);

   673     ::glClearDepthf(d);

   674     return WriteReply();

   675 }

   676 int OGLES11Wrapper::glClearDepthx()

   677 {

   678     GLfixed d;

   679     m_currentFunctionCall.GetParamValue(d, 0);

   680     ::glClearDepthx(d);    

   681     return WriteReply();

   682 }

   683 int OGLES11Wrapper::glClearStencil()

   684 {

   685     GLint s;

   686     m_currentFunctionCall.GetParamValue(s, 0);

   687     ::glClearStencil(s);     

   688     return WriteReply();

   689 }

   690 int OGLES11Wrapper::glClientActiveTexture()

   691 {

   692     GLenum texture;

   693     m_currentFunctionCall.GetParamValue(texture, 0);

   694     ::glClientActiveTexture(texture);     

   695     return WriteReply();

   696 }

   697 int OGLES11Wrapper::glClipPlanef()

   698 {

   699     GLenum plane;

   700     GLfloat* equation;

   701     m_currentFunctionCall.GetParamValue(plane, 0);

   702     //GLsizeiptr size;

   703     GLint size;

   704     m_currentFunctionCall.GetVectorData(equation, size, 1);

   705     ::glClipPlanef(plane,equation);

   706     return WriteReply();

   707 }

   708 int OGLES11Wrapper::glClipPlanex()

   709 {

   710     GLenum plane;

   711     GLfixed* equation;

   712     //GLsizeiptr size;

   713     GLint size;

   714     m_currentFunctionCall.GetParamValue(plane, 0);

   715     m_currentFunctionCall.GetVectorData(equation, size, 1);

   716     ::glClipPlanex(plane,equation);

   717     return WriteReply();

   718 }

   719 int OGLES11Wrapper::glColor4f()

   720 {

   721     GLfloat r,g,b,a;

   722     m_currentFunctionCall.GetParamValue(r, 0);

   723     m_currentFunctionCall.GetParamValue(g, 1);

   724     m_currentFunctionCall.GetParamValue(b, 2);

   725     m_currentFunctionCall.GetParamValue(a, 3);

   726     ::glColor4f(r,g,b,a);    

   727     return WriteReply();

   728 }

   729 int OGLES11Wrapper::glColor4ub()

   730 {

   731     GLubyte r,g,b,a;

   732     m_currentFunctionCall.GetParamValue(r, 0);

   733     m_currentFunctionCall.GetParamValue(g, 1);

   734     m_currentFunctionCall.GetParamValue(b, 2);

   735     m_currentFunctionCall.GetParamValue(a, 3);

   736     ::glColor4ub(r,g,b,a);  

   737     return WriteReply();

   738 }

   739 int OGLES11Wrapper::glColor4x()

   740 {

   741     GLfixed r,g,b,a;

   742     m_currentFunctionCall.GetParamValue(r, 0);

   743     m_currentFunctionCall.GetParamValue(g, 1);

   744     m_currentFunctionCall.GetParamValue(b, 2);

   745     m_currentFunctionCall.GetParamValue(a, 3);

   746     ::glColor4x(r,g,b,a);

   747     return WriteReply();

   748 }

   749 int OGLES11Wrapper::glColorMask()

   750 {

   751     GLboolean r,g,b,a;

   752     m_currentFunctionCall.GetParamValue(r, 0);

   753     m_currentFunctionCall.GetParamValue(g, 1);

   754     m_currentFunctionCall.GetParamValue(b, 2);

   755     m_currentFunctionCall.GetParamValue(a, 3);

   756     ::glColorMask(r,g,b,a);

   757     return WriteReply();

   758 }

   759 

   760 int OGLES11Wrapper::glCompressedTexImage2D()

   761 {

   762     GLenum target;

   763     GLint level;

   764     GLenum internalFormat;

   765     GLsizei width;

   766     GLsizei height;

   767     GLint border;

   768     GLsizei imageSize;

   769     GLvoid* data;

   770     //GLsizeiptr size;

   771     GLint size;

   772     m_currentFunctionCall.GetParamValue(target, 0);

   773     m_currentFunctionCall.GetParamValue(level, 1);

   774     m_currentFunctionCall.GetParamValue(internalFormat, 2);

   775     m_currentFunctionCall.GetParamValue(width, 3);

   776     m_currentFunctionCall.GetParamValue(height, 4);

   777     m_currentFunctionCall.GetParamValue(border, 5);

   778     m_currentFunctionCall.GetParamValue(imageSize, 6);

   779     m_currentFunctionCall.GetVectorData(data, size, 7);

   780     ::glCompressedTexImage2D(target,level,internalFormat,width,height,border,imageSize,data);

   781     return WriteReply();

   782 }

   783 int OGLES11Wrapper::glCompressedTexSubImage2D()

   784 {

   785     GLenum target;

   786     GLint level;

   787     GLint xoffset;

   788     GLint yoffset;

   789     GLsizei width;

   790     GLsizei height;

   791     GLenum format;

   792     GLsizei imageSize;

   793     GLvoid*   data;

   794     //GLsizeiptr size;

   795     GLint size;

   796     m_currentFunctionCall.GetParamValue(target, 0);

   797     m_currentFunctionCall.GetParamValue(level, 1);

   798     m_currentFunctionCall.GetParamValue(xoffset, 2);

   799     m_currentFunctionCall.GetParamValue(yoffset, 3);

   800     m_currentFunctionCall.GetParamValue(width, 4);

   801     m_currentFunctionCall.GetParamValue(height, 5);

   802     m_currentFunctionCall.GetParamValue(format, 6);

   803     m_currentFunctionCall.GetParamValue(imageSize, 7);

   804     m_currentFunctionCall.GetVectorData(data, size, 8);

   805     ::glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);

   806     return WriteReply();

   807 }

   808 int OGLES11Wrapper::glCopyTexImage2D()

   809 {

   810     GLenum target;    

   811     GLint level;

   812     GLenum internalFormat;

   813     GLint x;

   814     GLint y;

   815     GLsizei width;

   816     GLsizei height;

   817     GLint border;

   818     m_currentFunctionCall.GetParamValue(target, 0);

   819     m_currentFunctionCall.GetParamValue(level, 1);

   820     m_currentFunctionCall.GetParamValue(internalFormat, 2);

   821     m_currentFunctionCall.GetParamValue(x, 3);

   822     m_currentFunctionCall.GetParamValue(y, 4);    

   823     m_currentFunctionCall.GetParamValue(width, 5);    

   824     m_currentFunctionCall.GetParamValue(height, 6);    

   825     m_currentFunctionCall.GetParamValue(border, 7);

   826     ::glCopyTexImage2D(target,level,internalFormat,x,y,width,height,border);

   827     return WriteReply();

   828 }

   829 int OGLES11Wrapper::glCopyTexSubImage2D()

   830 {

   831     GLenum  target;

   832     GLint   level;

   833     GLint   xoffset;

   834     GLint   yoffset;

   835     GLint   x;

   836     GLint   y;

   837     GLsizei width;

   838     GLsizei height;

   839     m_currentFunctionCall.GetParamValue(target, 0);

   840     m_currentFunctionCall.GetParamValue(level, 1);

   841     m_currentFunctionCall.GetParamValue(xoffset, 2);

   842     m_currentFunctionCall.GetParamValue(yoffset, 3);

   843     m_currentFunctionCall.GetParamValue(x, 4);

   844     m_currentFunctionCall.GetParamValue(y, 5);

   845     m_currentFunctionCall.GetParamValue(width, 6);

   846     m_currentFunctionCall.GetParamValue(height, 7);    

   847     ::glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height);

   848     return WriteReply();

   849 }

   850 int OGLES11Wrapper::glCullFace()

   851 {

   852     GLenum mode;

   853 

   854     m_currentFunctionCall.GetParamValue(mode, 0);

   855 

   856     ::glCullFace(mode);

   857     return WriteReply();

   858 }

   859 int OGLES11Wrapper::glDeleteBuffers()

   860 {

   861     GLsizei n;

   862     GLuint *buffers;

   863 

   864     m_currentFunctionCall.GetParamValue(n, 0);

   865     TInt size1;

   866     m_currentFunctionCall.GetVectorData(buffers, size1, 1);

   867 

   868     ::glDeleteBuffers(n, buffers);

   869     return WriteReply();

   870 }

   871 int OGLES11Wrapper::glDeleteTextures()

   872 {

   873     GLsizei n;

   874     GLuint *textures;

   875 

   876     m_currentFunctionCall.GetParamValue(n, 0);

   877     TInt size1;

   878     m_currentFunctionCall.GetVectorData(textures, size1, 1);

   879 

   880     ::glDeleteTextures(n, textures);

   881     return WriteReply();

   882 }

   883 int OGLES11Wrapper::glDepthFunc()

   884 {

   885     GLenum func;

   886 

   887     m_currentFunctionCall.GetParamValue(func, 0);

   888 

   889     ::glDepthFunc(func);

   890     return WriteReply();

   891 }

   892 int OGLES11Wrapper::glDepthMask()

   893 {

   894     GLboolean flag;

   895 

   896     m_currentFunctionCall.GetParamValue(flag, 0);

   897 

   898     ::glDepthMask(flag);

   899     return WriteReply();

   900 }

   901 int OGLES11Wrapper::glDepthRangef()

   902 {

   903     GLclampf zNear;

   904     GLclampf zFar;

   905 

   906     m_currentFunctionCall.GetParamValue(zNear, 0);

   907     m_currentFunctionCall.GetParamValue(zFar, 1);

   908 

   909     ::glDepthRangef(zNear, zFar);

   910 

   911     return WriteReply();

   912 }

   913 int OGLES11Wrapper::glDepthRangex()

   914 {

   915     GLclampx zNear;

   916     GLclampx zFar;

   917 

   918     m_currentFunctionCall.GetParamValue(zNear, 0);

   919     m_currentFunctionCall.GetParamValue(zFar, 1);

   920 

   921     ::glDepthRangex(zNear, zFar);

   922 

   923     return WriteReply();

   924 }

   925 int OGLES11Wrapper::glDisable()

   926 {

   927     GLenum cap;

   928 

   929     m_currentFunctionCall.GetParamValue(cap, 0);

   930 

   931     ::glDisable(cap);

   932 

   933     return WriteReply();

   934 }

   935 int OGLES11Wrapper::glDisableClientState()

   936 {

   937     GLenum array;

   938 

   939     m_currentFunctionCall.GetParamValue(array, 0);

   940 

   941     ::glDisableClientState(array);

   942 

   943     return WriteReply();

   944 }

   945 int OGLES11Wrapper::glDrawArrays()

   946 {

   947     GLenum mode;

   948     GLint first;

   949     GLsizei count;

   950 

   951     m_currentFunctionCall.GetParamValue(mode, 0);

   952     m_currentFunctionCall.GetParamValue(first, 1);

   953     m_currentFunctionCall.GetParamValue(count, 2);

   954 

   955     // Get the data arrays themselves -- note that this is additional data

   956     TInt arrayCount, arrayEnabled;

   957     m_currentFunctionCall.GetParamValue(arrayCount, 3);

   958     m_currentFunctionCall.GetParamValue(arrayEnabled, 4);

   959 

   960     vertexArrayInfo *vertexArrays;

   961     vertexArrays = (vertexArrayInfo *) malloc(arrayCount * sizeof(vertexArrayInfo));

   962 

   963     for (int i=0; i<arrayCount; i++)

   964     {

   965         m_currentFunctionCall.GetParamValue(vertexArrays[i].size, 5 + 4*i);

   966         m_currentFunctionCall.GetParamValue(vertexArrays[i].type, 6 + 4*i);

   967         m_currentFunctionCall.GetParamValue(vertexArrays[i].stride, 7 + 4*i);

   968         TInt size;

   969         m_currentFunctionCall.GetVectorData(vertexArrays[i].pointer, size, 8 + 4*i);

   970     }

   971     

   972     int x = 0; //position in the vertexArrays, 'i' in the loop above

   973     for(int i=0; i<NUM_ARRAYS; i++) 

   974     {

   975         switch( i )

   976         {

   977             case COLOR_ARRAY:

   978                 if (arrayEnabled & (1<<6))

   979                 {

   980                     ::glColorPointer(vertexArrays[x].size, vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);

   981                     x++;

   982                 }

   983                 break;

   984             case NORMAL_ARRAY:

   985                 if (arrayEnabled & (1<<5))

   986                 {

   987                     ::glNormalPointer(vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);

   988                     x++;

   989                 }

   990                 break;

   991             case POINT_SIZE_ARRAY:

   992                 if (arrayEnabled & (1<<4))

   993                 {

   994                     ::glPointSizePointerOES(vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);

   995                     x++;

   996                 }

   997                 break;

   998             case TEX_COORD_ARRAY:

   999                 if (arrayEnabled & (1<<3))

  1000                 {

  1001                     ::glTexCoordPointer(vertexArrays[x].size, vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);

  1002                     x++;

  1003                 }

  1004                 break;

  1005             case VERTEX_ARRAY:

  1006                 if (arrayEnabled & (1<<2)){

  1007                     ::glVertexPointer(vertexArrays[x].size, vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);

  1008                     x++;

  1009                 }

  1010                 break;

  1011             case MATRIX_INDEX_ARRAY:

  1012                 break;

  1013             case WEIGHT_ARRAY:

  1014                 break;

  1015             default:

  1016                 // Do nothing

  1017                 break;

  1018         }   

  1019     }

  1020 

  1021     ::glDrawArrays(mode, first, count);

  1022     return WriteReply();

  1023 }

  1024 int OGLES11Wrapper::glDrawElements()

  1025 {

  1026     GLenum mode;

  1027     GLsizei count;

  1028     GLenum type;

  1029     GLvoid *indices;

  1030 

  1031     m_currentFunctionCall.GetParamValue(mode, 0);

  1032     m_currentFunctionCall.GetParamValue(count, 1);

  1033     m_currentFunctionCall.GetParamValue(type, 2);

  1034     TInt size3;

  1035     m_currentFunctionCall.GetVectorData(indices, size3, 3);

  1036 

  1037     // Get the data arrays themselves -- note that this is additional data

  1038     TInt arrayCount, arrayEnabled;

  1039     m_currentFunctionCall.GetParamValue(arrayCount, 4);

  1040     m_currentFunctionCall.GetParamValue(arrayEnabled, 5);

  1041 

  1042     vertexArrayInfo *vertexArrays;

  1043     vertexArrays = (vertexArrayInfo *) malloc(arrayCount * sizeof(vertexArrayInfo));

  1044 

  1045     for (int i=0; i<arrayCount; i++)

  1046     {

  1047         m_currentFunctionCall.GetParamValue(vertexArrays[i].size, 6 + 4*i);

  1048         m_currentFunctionCall.GetParamValue(vertexArrays[i].type, 7 + 4*i);

  1049         m_currentFunctionCall.GetParamValue(vertexArrays[i].stride, 8 + 4*i);

  1050         TInt size;

  1051         m_currentFunctionCall.GetVectorData(vertexArrays[i].pointer, size, 9 + 4*i);

  1052     }

  1053     

  1054     int x = 0; //position in the vertexArrays, 'i' in the loop above

  1055     for(int i=0; i<NUM_ARRAYS; i++) 

  1056     {

  1057         switch( i )

  1058         {

  1059             case COLOR_ARRAY:

  1060                 if (arrayEnabled & (1<<6))

  1061                 {

  1062                     ::glColorPointer(vertexArrays[x].size, vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);

  1063                     x++;

  1064                 }

  1065                 break;

  1066             case NORMAL_ARRAY:

  1067                 if (arrayEnabled & (1<<5))

  1068                 {

  1069                     ::glNormalPointer(vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);

  1070                     x++;

  1071                 }

  1072                 break;

  1073             case POINT_SIZE_ARRAY:

  1074                 if (arrayEnabled & (1<<4))

  1075                 {

  1076                     ::glPointSizePointerOES(vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);

  1077                     x++;

  1078                 }

  1079                 break;

  1080             case TEX_COORD_ARRAY:

  1081                 if (arrayEnabled & (1<<3))

  1082                 {

  1083                     ::glTexCoordPointer(vertexArrays[x].size, vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);

  1084                     x++;

  1085                 }

  1086                 break;

  1087             case VERTEX_ARRAY:

  1088                 if (arrayEnabled & (1<<2)){

  1089                     ::glVertexPointer(vertexArrays[x].size, vertexArrays[x].type, vertexArrays[x].stride, vertexArrays[x].pointer);

  1090                     x++;

  1091                 }

  1092                 break;

  1093             case MATRIX_INDEX_ARRAY:

  1094                 break;

  1095             case WEIGHT_ARRAY:

  1096                 break;

  1097             default:

  1098                 // Do nothing

  1099                 break;

  1100         }   

  1101     }

  1102 

  1103 

  1104     ::glDrawElements(mode, count, type, indices);

  1105     return WriteReply();

  1106 }

  1107 int OGLES11Wrapper::glEnable()

  1108 {

  1109     GLenum cap;

  1110 

  1111     m_currentFunctionCall.GetParamValue(cap, 0);

  1112 

  1113     ::glEnable(cap);

  1114 

  1115     return WriteReply();

  1116 }

  1117 int OGLES11Wrapper::glEnableClientState()

  1118 {

  1119     GLenum array;

  1120 

  1121     m_currentFunctionCall.GetParamValue(array, 0);

  1122 

  1123     ::glEnableClientState(array);

  1124 

  1125     return WriteReply();

  1126 }

  1127 int OGLES11Wrapper::glFinish()

  1128 {

  1129     ::glFinish();

  1130     return WriteReply();

  1131 }

  1132 int OGLES11Wrapper::glFlush()

  1133 {

  1134     ::glFlush();