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 // Implementation of Guest OpenGL ES 1.1 serialization stubs

    15 

    16 #include "remotefunctioncall.h"

    17 #include "opengles11rfc.h"

    18 #include "vghwutils.h"

    19 #include "opengl.h"

    20 

    21 // Writeable Static Data, is initialised to 0s by the compiler

    22 vertexArrayInfo vertexArrays[NUM_ARRAYS];

    23 bool vertexArraysEnabled[NUM_ARRAYS];

    24 

    25 

    26 // Writeable Static Data - causes constructor to be called at DLL load time.

    27 TGles11ApiForEgl GlesApiExporter;

    28 

    29 

    30 

    31 // Informative Panic messages

    32 _LIT(KGlesPanicCategory, "Guest GLES");

    33 

    34 void GlesPanic(TGlPanic aPanicCode, char* aCondition, char* aFile, TInt aLine)

    35 	{

    36 	if (aCondition && aFile)

    37 		{

    38 		RDebug::Printf("Guest Open GLES DLL Panic %d for failed Assert (%s), at %s:%d", aPanicCode, aCondition, aFile, aLine);

    39 		}

    40 	else

    41 		{  

    42 		RDebug::Printf("Guest Open GLES DLL Panic %d for failed Assert (line %d)", aPanicCode, aLine);

    43 		}

    44 		

    45 	User::Panic(KGlesPanicCategory, aPanicCode);

    46 	}

    47 

    48 

    49 inline void SetError(GLint aError)

    50 	{

    51 	MGlesContext* glesContext = CVghwUtils::GlesContext();

    52 	if (glesContext)

    53 		{ // there is a GL ES context  

    54 		glesContext->SetGlesError(aError);

    55 		}

    56 	}

    57 

    58 inline void ExecuteCommand(RemoteFunctionCall& aRequestData)

    59 	{

    60 	MGlesContext* glesContext = CVghwUtils::GlesContext();

    61 	if (glesContext)

    62 		{ // there is a GL ES context  

    63 		glesContext->ExecuteGlesCommand(aRequestData);

    64 		}

    65     }

    66 

    67 inline TUint32 ExecuteFunction(RemoteFunctionCall& aRequestData)

    68 	{

    69 	GLPANIC_ASSERT_DEBUG(aRequestData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EGlPanicNotReplyOpcode);

    70 	MGlesContext* glesContext = CVghwUtils::GlesContext();

    71 	if (glesContext)

    72 		{ // there is GL ES context  

    73 		glesContext->ExecuteGlesCommand(aRequestData);

    74 		return aRequestData.ReturnValue();

    75 		}

    76 	return 0;

    77     }

    78 

    79 

    80 extern "C" {

    81 

    82 EXPORT_C void GL_APIENTRY glActiveTexture (GLenum texture)

    83 	{

    84     OPENGL_TRACE(_APICALL_, "OpenGL client side: glActiveTexture ->\n");

    85     RemoteFunctionCallData rfcData;

    86     OpenGlES11RFC call( rfcData );

    87     call.Init( OpenGlES11RFC::EglActiveTexture, RemoteFunctionCallData::EOpRequest );

    88     call.AppendParam( texture );

    89     ExecuteCommand(call);

    90     OPENGL_TRACE(_APICALL_, "OpenGL client side: glActiveTexture <-\n");

    91 	}

    92 

    93 EXPORT_C void GL_APIENTRY glAlphaFunc (GLenum func, GLclampf ref) __SOFTFP

    94 	{

    95     OPENGL_TRACE(_APICALL_, "OpenGL client side: glAlphaFunc ->\n");

    96     RemoteFunctionCallData rfcData;

    97     OpenGlES11RFC call( rfcData );

    98     call.Init( OpenGlES11RFC::EglAlphaFunc, RemoteFunctionCallData::EOpRequest );

    99     call.AppendParam( func );

   100     call.AppendParam( ref );

   101     ExecuteCommand(call);

   102     OPENGL_TRACE(_APICALL_, "OpenGL client side: glAlphaFunc <-\n");

   103 	}

   104 

   105 EXPORT_C void GL_APIENTRY glAlphaFuncx (GLenum func, GLclampx ref)

   106 	{

   107     OPENGL_TRACE(_APICALL_, "OpenGL client side: glAlphaFuncx ->\n");

   108     RemoteFunctionCallData rfcData;

   109     OpenGlES11RFC call( rfcData );

   110     call.Init( OpenGlES11RFC::EglAlphaFuncx, RemoteFunctionCallData::EOpRequest );

   111     call.AppendParam( func );

   112     call.AppendParam( ref );

   113     ExecuteCommand(call);

   114     OPENGL_TRACE(_APICALL_, "OpenGL client side: glAlphaFuncx <-\n");

   115 	}

   116 

   117 EXPORT_C void GL_APIENTRY glBindBuffer (GLenum target, GLuint buffer)

   118 	{

   119     OPENGL_TRACE(_APICALL_, "OpenGL client side: glBindBuffer ->\n");

   120     RemoteFunctionCallData rfcData;

   121     OpenGlES11RFC call( rfcData );

   122     call.Init( OpenGlES11RFC::EglBindBuffer, RemoteFunctionCallData::EOpRequest );

   123     call.AppendParam( target );

   124     call.AppendParam( buffer );

   125     ExecuteCommand(call);

   126     OPENGL_TRACE(_APICALL_, "OpenGL client side: glBindBuffer <-\n");

   127 	}

   128 

   129 EXPORT_C void GL_APIENTRY glBindTexture (GLenum target, GLuint texture)

   130 	{

   131     OPENGL_TRACE(_APICALL_, "OpenGL client side: glBindTexture ->\n");

   132     RemoteFunctionCallData rfcData;

   133     OpenGlES11RFC call( rfcData );

   134     call.Init( OpenGlES11RFC::EglBindTexture, RemoteFunctionCallData::EOpRequest );

   135     call.AppendParam( target );

   136     call.AppendParam( texture );

   137     ExecuteCommand(call);

   138     OPENGL_TRACE(_APICALL_, "OpenGL client side: glBindTexture <-\n");

   139 	}

   140 

   141 EXPORT_C void GL_APIENTRY glBlendFunc (GLenum sfactor, GLenum dfactor)

   142 	{

   143     OPENGL_TRACE(_APICALL_, "OpenGL client side: glBlendFunc ->\n");

   144     RemoteFunctionCallData rfcData;

   145     OpenGlES11RFC call( rfcData );

   146     call.Init( OpenGlES11RFC::EglBlendFunc, RemoteFunctionCallData::EOpRequest );

   147     call.AppendParam( sfactor );

   148     call.AppendParam( dfactor );

   149     ExecuteCommand(call);

   150     OPENGL_TRACE(_APICALL_, "OpenGL client side: glBlendFunc <-\n");

   151 	}

   152 

   153 EXPORT_C void GL_APIENTRY glBufferData (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)

   154 	{

   155     OPENGL_TRACE(_APICALL_, "OpenGL client side: glBufferData ->\n");

   156     if(size < 0) // cannot serialize vector with size < 0

   157     	{

   158         SetError( GL_INVALID_VALUE );

   159         return;

   160     	}

   161     RemoteFunctionCallData rfcData;

   162     OpenGlES11RFC call( rfcData );

   163     call.Init( OpenGlES11RFC::EglBufferData, RemoteFunctionCallData::EOpRequest );

   164     call.AppendParam( target );

   165     call.AppendParam( size );

   166     call.AppendVector( data, size );

   167     call.AppendParam( usage );

   168     ExecuteCommand(call);

   169     OPENGL_TRACE(_APICALL_, "OpenGL client side: glBufferData <-\n");

   170 	}

   171 

   172 EXPORT_C void GL_APIENTRY glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)

   173 	{

   174     OPENGL_TRACE(_APICALL_, "OpenGL client side: glBufferSubData ->\n");

   175     if(offset < 0 || size < 0) // cannot serialize vector with size < 0

   176     	{

   177         SetError( GL_INVALID_VALUE );

   178         return;

   179     	}

   180     RemoteFunctionCallData rfcData;

   181     OpenGlES11RFC call( rfcData );

   182     call.Init( OpenGlES11RFC::EglBufferSubData, RemoteFunctionCallData::EOpRequest );

   183     call.AppendParam( target );

   184     call.AppendParam( offset );

   185     call.AppendParam( size );

   186     call.AppendVector( data, offset+size );

   187     ExecuteCommand(call);

   188     OPENGL_TRACE(_APICALL_, "OpenGL client side: glBufferSubData <-\n");

   189 	}

   190 

   191 EXPORT_C void GL_APIENTRY glClear (GLbitfield mask)

   192 	{

   193     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClear ->\n");

   194     RemoteFunctionCallData rfcData;

   195     OpenGlES11RFC call( rfcData );

   196     call.Init( OpenGlES11RFC::EglClear, RemoteFunctionCallData::EOpRequest );

   197     call.AppendParam( mask );

   198     ExecuteCommand(call);

   199     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClear <-\n");

   200 	}

   201 

   202 EXPORT_C void GL_APIENTRY glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) __SOFTFP

   203 	{

   204     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearColor ->\n");

   205     RemoteFunctionCallData rfcData;

   206     OpenGlES11RFC call( rfcData );

   207     call.Init( OpenGlES11RFC::EglClearColor, RemoteFunctionCallData::EOpRequest );

   208     call.AppendParam( red );

   209     call.AppendParam( green );

   210     call.AppendParam( blue );

   211     call.AppendParam( alpha );

   212     ExecuteCommand(call);

   213     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearColor <-\n");

   214 	}

   215 

   216 EXPORT_C void GL_APIENTRY glClearColorx (GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)

   217 	{

   218     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearColorx ->\n");

   219     RemoteFunctionCallData rfcData;

   220     OpenGlES11RFC call( rfcData );

   221     call.Init( OpenGlES11RFC::EglClearColorx, RemoteFunctionCallData::EOpRequest );

   222     call.AppendParam( red );

   223     call.AppendParam( green );

   224     call.AppendParam( blue );

   225     call.AppendParam( alpha );

   226     ExecuteCommand(call);

   227     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearColorx <-\n");

   228 	}

   229 

   230 EXPORT_C void GL_APIENTRY glClearDepthf (GLclampf depth) __SOFTFP

   231 	{

   232     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearDepthf ->\n");

   233     RemoteFunctionCallData rfcData;

   234     OpenGlES11RFC call( rfcData );

   235     call.Init( OpenGlES11RFC::EglClearDepthf, RemoteFunctionCallData::EOpRequest );

   236     call.AppendParam( depth );

   237     ExecuteCommand(call);

   238     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearDepthf <-\n");

   239 	}

   240 

   241 EXPORT_C void GL_APIENTRY glClearDepthx (GLclampx depth)

   242 	{

   243     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearDepthx ->\n");

   244     RemoteFunctionCallData rfcData;

   245     OpenGlES11RFC call( rfcData );

   246     call.Init( OpenGlES11RFC::EglClearDepthx, RemoteFunctionCallData::EOpRequest );

   247     call.AppendParam( depth );

   248     ExecuteCommand(call);

   249     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearDepthx <-\n");

   250 	}

   251 

   252 EXPORT_C void GL_APIENTRY glClearStencil (GLint s)

   253 	{

   254     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearStencil ->\n");

   255     RemoteFunctionCallData rfcData;

   256     OpenGlES11RFC call( rfcData );

   257     call.Init( OpenGlES11RFC::EglClearStencil, RemoteFunctionCallData::EOpRequest );

   258     call.AppendParam( s );

   259     ExecuteCommand(call);

   260     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearStencil <-\n");

   261 	}

   262 

   263 EXPORT_C void GL_APIENTRY glClientActiveTexture (GLenum texture)

   264 	{

   265     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClientActiveTexture ->\n");

   266     RemoteFunctionCallData rfcData;

   267     OpenGlES11RFC call( rfcData );

   268     call.Init( OpenGlES11RFC::EglClientActiveTexture, RemoteFunctionCallData::EOpRequest );

   269     call.AppendParam( texture );

   270     ExecuteCommand(call);

   271     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClientActiveTexture <-\n");

   272 	}

   273 

   274 EXPORT_C void GL_APIENTRY glClipPlanef (GLenum plane, const GLfloat *equation)

   275 	{

   276     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClipPlanef ->\n");

   277     RemoteFunctionCallData rfcData;

   278     OpenGlES11RFC call( rfcData );

   279     call.Init( OpenGlES11RFC::EglClipPlanef, RemoteFunctionCallData::EOpRequest );

   280     call.AppendParam( plane );

   281     call.AppendVector( equation, 4 ); // 4 values according to OpenGL_ES_1.1.12.pdf, section 2.11

   282     ExecuteCommand(call);

   283     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClipPlanef <-\n");

   284 	}

   285 

   286 EXPORT_C void GL_APIENTRY glClipPlanex (GLenum plane, const GLfixed *equation)

   287 	{

   288     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClipPlanex ->\n");

   289     RemoteFunctionCallData rfcData;

   290     OpenGlES11RFC call( rfcData );

   291     call.Init( OpenGlES11RFC::EglClipPlanex, RemoteFunctionCallData::EOpRequest );

   292     call.AppendParam( plane );

   293     call.AppendVector( equation, 4 ); // 4 values according to OpenGL_ES_1.1.12.pdf, section 2.11

   294     ExecuteCommand(call);

   295     OPENGL_TRACE(_APICALL_, "OpenGL client side: glClipPlanex <-\n");

   296 	}

   297 

   298 EXPORT_C void GL_APIENTRY glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) __SOFTFP

   299 	{

   300     OPENGL_TRACE(_APICALL_, "OpenGL client side: glColor4f ->\n");

   301     RemoteFunctionCallData rfcData;

   302     OpenGlES11RFC call( rfcData );

   303     call.Init( OpenGlES11RFC::EglColor4f, RemoteFunctionCallData::EOpRequest );

   304     call.AppendParam( red );

   305     call.AppendParam( green );

   306     call.AppendParam( blue );

   307     call.AppendParam( alpha );

   308     ExecuteCommand(call);

   309     OPENGL_TRACE(_APICALL_, "OpenGL client side: glColor4f <-\n");

   310 	}

   311 

   312 EXPORT_C void GL_APIENTRY glColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)

   313 	{

   314     OPENGL_TRACE(_APICALL_, "OpenGL client side: glColor4ub ->\n");

   315     RemoteFunctionCallData rfcData;

   316     OpenGlES11RFC call( rfcData );

   317     call.Init( OpenGlES11RFC::EglColor4ub, RemoteFunctionCallData::EOpRequest );

   318     call.AppendParam( red );

   319     call.AppendParam( green );

   320     call.AppendParam( blue );

   321     call.AppendParam( alpha );

   322     ExecuteCommand(call);

   323     OPENGL_TRACE(_APICALL_, "OpenGL client side: glColor4ub <-\n");

   324 	}

   325 

   326 EXPORT_C void GL_APIENTRY glColor4x (GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)

   327 	{

   328     OPENGL_TRACE(_APICALL_, "OpenGL client side: glColor4x ->\n");

   329     RemoteFunctionCallData rfcData;

   330     OpenGlES11RFC call( rfcData );

   331     call.Init( OpenGlES11RFC::EglColor4x, RemoteFunctionCallData::EOpRequest );

   332     call.AppendParam( red );

   333     call.AppendParam( green );

   334     call.AppendParam( blue );

   335     call.AppendParam( alpha );

   336     ExecuteCommand(call);

   337     OPENGL_TRACE(_APICALL_, "OpenGL client side: glColor4x <-\n");

   338 	}

   339 

   340 EXPORT_C void GL_APIENTRY glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)

   341 	{

   342     OPENGL_TRACE(_APICALL_, "OpenGL client side: glColorMask ->\n");

   343     RemoteFunctionCallData rfcData;

   344     OpenGlES11RFC call( rfcData );

   345     call.Init( OpenGlES11RFC::EglColorMask, RemoteFunctionCallData::EOpRequest );

   346     call.AppendParam( red );

   347     call.AppendParam( green );

   348     call.AppendParam( blue );

   349     call.AppendParam( alpha );

   350     ExecuteCommand(call);

   351     OPENGL_TRACE(_APICALL_, "OpenGL client side: glColorMask <-\n");

   352 	}

   353 

   354 EXPORT_C void GL_APIENTRY glColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)

   355 	{

   356     OPENGL_TRACE(_APICALL_, "OpenGL client side: glColorPointer ->\n");

   357     vertexArrays[COLOR_ARRAY].size = size;

   358     vertexArrays[COLOR_ARRAY].type = type;

   359     vertexArrays[COLOR_ARRAY].stride = stride;

   360     vertexArrays[COLOR_ARRAY].pointer = pointer;

   361     OPENGL_TRACE(_APICALL_, "OpenGL client side: glColorPointer <-\n");

   362 	}

   363 

   364 EXPORT_C void GL_APIENTRY glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)

   365 	{

   366     OPENGL_TRACE(_APICALL_, "OpenGL client side: glCompressedTexImage2D ->\n");

   367     if(imageSize < 0) // cannot serialize vector with size < 0

   368     	{

   369         SetError( GL_INVALID_VALUE );

   370         return;

   371     	}

   372     RemoteFunctionCallData rfcData;

   373     OpenGlES11RFC call( rfcData );

   374     call.Init( OpenGlES11RFC::EglCompressedTexImage2D, RemoteFunctionCallData::EOpRequest );

   375     call.AppendParam( target );

   376     call.AppendParam( level );

   377     call.AppendParam( internalformat );

   378     call.AppendParam( width );

   379     call.AppendParam( height );

   380     call.AppendParam( border );

   381     call.AppendParam( imageSize );

   382     call.AppendVector( data, imageSize );

   383     ExecuteCommand(call);

   384     OPENGL_TRACE(_APICALL_, "OpenGL client side: glCompressedTexImage2D <-\n");

   385 	}

   386 

   387 EXPORT_C void GL_APIENTRY glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)

   388 	{

   389     OPENGL_TRACE(_APICALL_, "OpenGL client side: glCompressedTexSubImage2D ->\n");

   390     if(imageSize < 0) // cannot serialize vector with size < 0

   391     	{

   392         SetError( GL_INVALID_VALUE );

   393         return;

   394     	}

   395     RemoteFunctionCallData rfcData;

   396     OpenGlES11RFC call( rfcData );

   397     call.Init( OpenGlES11RFC::EglCompressedTexSubImage2D, RemoteFunctionCallData::EOpRequest );

   398     call.AppendParam( target );

   399     call.AppendParam( level );

   400     call.AppendParam( xoffset );

   401     call.AppendParam( yoffset );

   402     call.AppendParam( width );

   403     call.AppendParam( height );

   404     call.AppendParam( format );

   405     call.AppendParam( imageSize );

   406     call.AppendVector( data, imageSize );

   407     ExecuteCommand(call);

   408     OPENGL_TRACE(_APICALL_, "OpenGL client side: glCompressedTexSubImage2D <-\n");

   409 	}

   410 

   411 EXPORT_C void GL_APIENTRY glCopyTexImage2D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)

   412 	{

   413     OPENGL_TRACE(_APICALL_, "OpenGL client side: glCopyTexImage2D ->\n");

   414     RemoteFunctionCallData rfcData;

   415     OpenGlES11RFC call( rfcData );

   416     call.Init( OpenGlES11RFC::EglCopyTexImage2D, RemoteFunctionCallData::EOpRequest );

   417     call.AppendParam( target );

   418     call.AppendParam( level );

   419     call.AppendParam( internalformat );

   420     call.AppendParam( x );

   421     call.AppendParam( y );

   422     call.AppendParam( width );

   423     call.AppendParam( height );

   424     call.AppendParam( border );

   425     ExecuteCommand(call);

   426     OPENGL_TRACE(_APICALL_, "OpenGL client side: glCopyTexImage2D <-\n");

   427 	}

   428 

   429 EXPORT_C void GL_APIENTRY glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)

   430 	{

   431     OPENGL_TRACE(_APICALL_, "OpenGL client side: glCopyTexSubImage2D ->\n");

   432     RemoteFunctionCallData rfcData;

   433     OpenGlES11RFC call( rfcData );

   434     call.Init( OpenGlES11RFC::EglCopyTexSubImage2D, RemoteFunctionCallData::EOpRequest );

   435     call.AppendParam( target );

   436     call.AppendParam( level );

   437     call.AppendParam( xoffset );

   438     call.AppendParam( yoffset );

   439     call.AppendParam( x );

   440     call.AppendParam( y );

   441     call.AppendParam( width );

   442     call.AppendParam( height );

   443     ExecuteCommand(call);

   444     OPENGL_TRACE(_APICALL_, "OpenGL client side: glCopyTexSubImage2D <-\n");

   445 	}

   446 

   447 EXPORT_C void GL_APIENTRY glCullFace (GLenum mode)

   448 	{

   449     OPENGL_TRACE(_APICALL_, "OpenGL client side: glCullFace ->\n");

   450     RemoteFunctionCallData rfcData;

   451     OpenGlES11RFC call( rfcData );

   452     call.Init( OpenGlES11RFC::EglCullFace, RemoteFunctionCallData::EOpRequest );

   453     call.AppendParam( mode );

   454     ExecuteCommand(call);

   455     OPENGL_TRACE(_APICALL_, "OpenGL client side: glCullFace <-\n");

   456 	}

   457 

   458 EXPORT_C void GL_APIENTRY glDeleteBuffers (GLsizei n, const GLuint *buffers)

   459 	{

   460     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDeleteBuffers ->\n");

   461     if(n < 0) // cannot serialize vector with size < 0

   462     	{

   463         SetError( GL_INVALID_VALUE );

   464         return;

   465 		}

   466     RemoteFunctionCallData rfcData;

   467     OpenGlES11RFC call( rfcData );

   468     call.Init( OpenGlES11RFC::EglDeleteBuffers, RemoteFunctionCallData::EOpRequest );

   469     call.AppendParam( n );

   470     call.AppendVector( buffers, n );

   471     ExecuteCommand(call);

   472     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDeleteBuffers <-\n");

   473 	}

   474 

   475 EXPORT_C void GL_APIENTRY glDeleteTextures (GLsizei n, const GLuint *textures)

   476 	{

   477     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDeleteTextures ->\n");

   478     if(n < 0) // cannot serialize vector with size < 0

   479     	{

   480         SetError( GL_INVALID_VALUE );

   481         return;

   482 		}

   483     RemoteFunctionCallData rfcData;

   484     OpenGlES11RFC call( rfcData );

   485     call.Init( OpenGlES11RFC::EglDeleteTextures, RemoteFunctionCallData::EOpRequest );

   486     call.AppendParam( n );

   487     call.AppendVector( textures, n );

   488     ExecuteCommand(call);

   489     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDeleteTextures <-\n");

   490 	}

   491 

   492 EXPORT_C void GL_APIENTRY glDepthFunc (GLenum func)

   493 	{

   494     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDepthFunc ->\n");

   495     RemoteFunctionCallData rfcData;

   496     OpenGlES11RFC call( rfcData );

   497     call.Init( OpenGlES11RFC::EglDepthFunc, RemoteFunctionCallData::EOpRequest );

   498     call.AppendParam( func );

   499     ExecuteCommand(call);

   500     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDepthFunc <-\n");

   501 	}

   502 

   503 EXPORT_C void GL_APIENTRY glDepthMask (GLboolean flag)

   504 	{

   505     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDepthMask ->\n");

   506     RemoteFunctionCallData rfcData;

   507     OpenGlES11RFC call( rfcData );

   508     call.Init( OpenGlES11RFC::EglDepthMask, RemoteFunctionCallData::EOpRequest );

   509     call.AppendParam( flag );

   510     ExecuteCommand(call);

   511     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDepthMask <-\n");

   512 	}

   513 

   514 EXPORT_C void GL_APIENTRY glDepthRangef (GLclampf zNear, GLclampf zFar) __SOFTFP

   515 	{

   516     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDepthRangef ->\n");

   517     RemoteFunctionCallData rfcData;

   518     OpenGlES11RFC call( rfcData );

   519     call.Init( OpenGlES11RFC::EglDepthRangef, RemoteFunctionCallData::EOpRequest );

   520     call.AppendParam( zNear );

   521     call.AppendParam( zFar );

   522     ExecuteCommand(call);

   523     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDepthRangef <-\n");

   524 	}

   525 

   526 EXPORT_C void GL_APIENTRY glDepthRangex (GLclampx zNear, GLclampx zFar)

   527 	{

   528     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDepthRangex ->\n");

   529     RemoteFunctionCallData rfcData;

   530     OpenGlES11RFC call( rfcData );

   531     call.Init( OpenGlES11RFC::EglDepthRangex, RemoteFunctionCallData::EOpRequest );

   532     call.AppendParam( zNear );

   533     call.AppendParam( zFar );

   534     ExecuteCommand(call);

   535     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDepthRangex <-\n");

   536 	}

   537 

   538 EXPORT_C void GL_APIENTRY glDisable (GLenum cap)

   539 	{

   540     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDisable ->\n");

   541     RemoteFunctionCallData rfcData;

   542     OpenGlES11RFC call( rfcData );

   543     call.Init( OpenGlES11RFC::EglDisable, RemoteFunctionCallData::EOpRequest );

   544     call.AppendParam( cap );

   545     ExecuteCommand(call);

   546     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDisable <-\n");

   547 	}

   548 

   549 EXPORT_C void GL_APIENTRY glDisableClientState (GLenum array)

   550 	{

   551     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDisableClientState ->\n");

   552     // store state on here as well, used in DrawArrays and DrawElements

   553     bool enumError = false;

   554     switch( array )

   555     	{

   556         case GL_COLOR_ARRAY:

   557             vertexArraysEnabled[COLOR_ARRAY] = false;

   558             break;

   559         case GL_NORMAL_ARRAY:

   560             vertexArraysEnabled[NORMAL_ARRAY] = false;

   561             break;

   562         case GL_POINT_SIZE_ARRAY_OES:

   563             vertexArraysEnabled[POINT_SIZE_ARRAY] = false;

   564             break;

   565         case GL_TEXTURE_COORD_ARRAY:

   566             vertexArraysEnabled[TEX_COORD_ARRAY] = false;

   567             break;

   568         case GL_VERTEX_ARRAY:

   569             vertexArraysEnabled[VERTEX_ARRAY] = false;

   570             break;

   571         case GL_MATRIX_INDEX_ARRAY_OES:

   572             vertexArraysEnabled[MATRIX_INDEX_ARRAY] = false;

   573             break;

   574         case GL_WEIGHT_ARRAY_OES:

   575             vertexArraysEnabled[WEIGHT_ARRAY] = false;

   576             break;

   577         default:

   578             SetError( GL_INVALID_ENUM );

   579             enumError = true;

   580             break;

   581     	}

   582     if( !enumError )

   583     	{

   584         RemoteFunctionCallData rfcData;

   585         OpenGlES11RFC call( rfcData );

   586         call.Init( OpenGlES11RFC::EglDisableClientState, RemoteFunctionCallData::EOpRequest );

   587         call.AppendParam( array );

   588         ExecuteCommand(call);

   589     	}

   590     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDisableClientState <-\n");

   591 	}

   592 

   593 EXPORT_C void GL_APIENTRY glDrawArrays (GLenum mode, GLint first, GLsizei count)

   594 	{

   595     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawArrays ->\n");

   596     RemoteFunctionCallData rfcData;

   597     OpenGlES11RFC call( rfcData );

   598     call.Init( OpenGlES11RFC::EglDrawArrays, RemoteFunctionCallData::EOpRequest );

   599     call.AppendParam( mode );

   600     call.AppendParam( first );

   601     call.AppendParam( count );

   602 

   603     /* serialize vertex arrays

   604        order of the data:

   605        - number of arrays (int)

   606        - bitfield of enabled arrays, order specified by opengl.h vertex array pointer enumeration (int)

   607        - for each enabled vertex array:

   608          - size (int)

   609          - type (int)

   610          - stride (int)

   611          - data vector

   612     */

   613     int arrayCount = 0;

   614     int arrayEnabled = 0;

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

   616     {

   617         arrayEnabled = (arrayEnabled << 1) + vertexArraysEnabled[i];

   618         if( vertexArraysEnabled[i] )

   619             arrayCount++;

   620     }

   621     call.AppendParam( arrayCount );

   622     call.AppendParam( arrayEnabled );

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

   624     	{

   625 		if( vertexArraysEnabled[i] )

   626 			{

   627             call.AppendParam( vertexArrays[i].size );

   628             call.AppendParam( vertexArrays[i].type );

   629             call.AppendParam( vertexArrays[i].stride );

   630             int vectorsize;

   631             if( vertexArrays[i].stride )

   632                 vectorsize = vertexArrays[i].stride * (first + count - 1) + sizeof(vertexArrays[i].type) * vertexArrays[i].size;

   633             else 

   634                 vectorsize = sizeof(vertexArrays[i].type) * vertexArrays[i].size * (first + count);

   635             call.AppendVector( vertexArrays[i].pointer, vectorsize ); 

   636 			}

   637     	}

   638 

   639     ExecuteCommand(call);

   640     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawArrays <-\n");

   641 	}

   642 

   643 EXPORT_C void GL_APIENTRY glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)

   644 	{

   645     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawElements ->\n");

   646     if(count < 0) // cannot serialize vector with size < 0

   647     	{

   648         SetError( GL_INVALID_VALUE );

   649         return;

   650     	}

   651     RemoteFunctionCallData rfcData;

   652     OpenGlES11RFC call( rfcData );

   653     call.Init( OpenGlES11RFC::EglDrawElements, RemoteFunctionCallData::EOpRequest );

   654     call.AppendParam( mode );

   655     call.AppendParam( count );

   656     call.AppendParam( type );

   657     call.AppendVector( indices, count );

   658     

   659     /* serialize vertex arrays

   660        order of the data:

   661        - number of arrays (int)

   662        - bitfield of enabled arrays, order specified by opengl.h vertex array pointer enumeration (int)

   663        - for each enabled vertex array:

   664          - size (int)

   665          - type (int)

   666          - stride (int)

   667          - data vector

   668     */

   669     int arrayCount = 0;

   670     int arrayEnabled = 0;

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

   672     	{

   673         arrayEnabled = (arrayEnabled << 1) + vertexArraysEnabled[i];

   674         if( vertexArraysEnabled[i] )

   675             arrayCount++;

   676 		}

   677     call.AppendParam( arrayCount );

   678     call.AppendParam( arrayEnabled );

   679     // find max index

   680     int maxIndex = 0;

   681     switch( type )

   682     	{

   683         case GL_UNSIGNED_BYTE:

   684             for(int i=0; i<count; i++)

   685             	{

   686                 if( ((GLubyte*)indices)[i] > maxIndex )

   687                 	maxIndex = (int)((GLubyte*)indices)[i];

   688 				}

   689             break;

   690         case GL_UNSIGNED_SHORT:

   691             for(int i=0; i<count; i++)

   692             	{

   693                 if( ((GLushort*)indices)[i] > maxIndex )

   694                     maxIndex = (int)((GLushort*)indices)[i];

   695             	}

   696             break;

   697     	}

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

   699     	{

   700         if( vertexArraysEnabled[i] )

   701         	{

   702             call.AppendParam( vertexArrays[i].size );

   703             call.AppendParam( vertexArrays[i].type );

   704             call.AppendParam( vertexArrays[i].stride );

   705             int vectorsize;

   706             int typesize = 0;

   707             switch(vertexArrays[i].type)

   708             	{

   709                 case GL_BYTE:

   710                 case GL_UNSIGNED_BYTE:

   711                     typesize = 1;

   712                     break;

   713                 case GL_SHORT:

   714                 case GL_UNSIGNED_SHORT:

   715                     typesize = 2;

   716                     break;

   717                 case GL_FLOAT:

   718                 case GL_FIXED:

   719                     typesize = 4;

   720                     break;

   721             	}

   722             if( vertexArrays[i].stride )

   723                 vectorsize = vertexArrays[i].stride * maxIndex + typesize * vertexArrays[i].size;

   724             else 

   725                 vectorsize = typesize * vertexArrays[i].size * (maxIndex+1);

   726             call.AppendVector( vertexArrays[i].pointer, vectorsize );

   727         	}

   728     	}

   729     

   730     ExecuteCommand(call);

   731     OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawElements <-\n");

   732 	}

   733 

   734 EXPORT_C void GL_APIENTRY glEnable (GLenum cap)

   735 	{

   736     OPENGL_TRACE(_APICALL_, "OpenGL client side: glEnable ->\n");

   737     RemoteFunctionCallData rfcData;

   738     OpenGlES11RFC call( rfcData );

   739     call.Init( OpenGlES11RFC::EglEnable, RemoteFunctionCallData::EOpRequest );

   740     call.AppendParam( cap );

   741     ExecuteCommand(call);

   742     OPENGL_TRACE(_APICALL_, "OpenGL client side: glEnable <-\n");

   743 	}

   744 

   745 EXPORT_C void GL_APIENTRY glEnableClientState (GLenum array)

   746 	{

   747     OPENGL_TRACE(_APICALL_, "OpenGL client side: glEnableClientState ->\n");

   748     // store state on here as well, used in DrawArrays and DrawElements

   749     bool enumError = false;

   750     switch( array )

   751     	{

   752         case GL_COLOR_ARRAY:

   753             vertexArraysEnabled[COLOR_ARRAY] = true;

   754             break;

   755         case GL_NORMAL_ARRAY:

   756             vertexArraysEnabled[NORMAL_ARRAY] = true;

   757             break;

   758         case GL_POINT_SIZE_ARRAY_OES:

   759             vertexArraysEnabled[POINT_SIZE_ARRAY] = true;

   760             break;

   761         case GL_TEXTURE_COORD_ARRAY:

   762             vertexArraysEnabled[TEX_COORD_ARRAY] = true;

   763             break;

   764         case GL_VERTEX_ARRAY:

   765             vertexArraysEnabled[VERTEX_ARRAY] = true;

   766             break;

   767         case GL_MATRIX_INDEX_ARRAY_OES:

   768             vertexArraysEnabled[MATRIX_INDEX_ARRAY] = true;

   769             break;

   770         case GL_WEIGHT_ARRAY_OES:

   771             vertexArraysEnabled[WEIGHT_ARRAY] = true;

   772             break;

   773         default:

   774             SetError( GL_INVALID_ENUM );

   775             enumError = true;

   776             break;

   777     	}

   778     if( !enumError )

   779     	{

   780         RemoteFunctionCallData rfcData;

   781         OpenGlES11RFC call( rfcData );

   782         call.Init( OpenGlES11RFC::EglEnableClientState, RemoteFunctionCallData::EOpRequest );

   783         call.AppendParam( array );

   784         ExecuteCommand(call);

   785     	}

   786     OPENGL_TRACE(_APICALL_, "OpenGL client side: glEnableClientState <-\n");

   787 	}

   788 

   789 EXPORT_C void GL_APIENTRY glFinish (void)

   790 	{

   791     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFinish ->\n");

   792     MGlesContext* glesContext = CVghwUtils::GlesContext();

   793 	if (glesContext)

   794 		{ // there is GL ES context  

   795 		glesContext->ExecuteGlesFinishCommand();

   796 		}

   797     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFinish <-\n");

   798 	}

   799 

   800 EXPORT_C void GL_APIENTRY glFlush (void)

   801 	{

   802     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFlush ->\n");

   803     MGlesContext* glesContext = CVghwUtils::GlesContext();

   804 	if (glesContext)

   805 		{ // there is GL ES context  

   806 		glesContext->ExecuteGlesFlushCommand();

   807 		}

   808     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFlush <-\n");

   809 	}

   810 

   811 EXPORT_C void GL_APIENTRY glFogf (GLenum pname, GLfloat param) __SOFTFP

   812 	{

   813     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFogf ->\n");

   814     RemoteFunctionCallData rfcData;

   815     OpenGlES11RFC call( rfcData );

   816     call.Init( OpenGlES11RFC::EglFogf, RemoteFunctionCallData::EOpRequest );

   817     call.AppendParam( pname );

   818     call.AppendParam( param );

   819     ExecuteCommand(call);

   820     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFogf <-\n");

   821 	}

   822 

   823 EXPORT_C void GL_APIENTRY glFogfv (GLenum pname, const GLfloat *params)

   824 	{

   825     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFogfv ->\n");

   826     TInt32 vectorsize = 1;

   827     if( pname == GL_FOG_COLOR )

   828         vectorsize = 4;

   829     RemoteFunctionCallData rfcData;

   830     OpenGlES11RFC call( rfcData );

   831     call.Init( OpenGlES11RFC::EglFogfv, RemoteFunctionCallData::EOpRequest );

   832     call.AppendParam( pname );

   833     call.AppendVector( params, vectorsize );

   834     ExecuteCommand(call);

   835     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFogfv <-\n");

   836 	}

   837 

   838 EXPORT_C void GL_APIENTRY glFogx (GLenum pname, GLfixed param)

   839 	{

   840     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFogx ->\n");

   841     RemoteFunctionCallData rfcData;

   842     OpenGlES11RFC call( rfcData );

   843     call.Init( OpenGlES11RFC::EglFogx, RemoteFunctionCallData::EOpRequest );

   844     call.AppendParam( pname );

   845     call.AppendParam( param );

   846     ExecuteCommand(call);

   847     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFogx <-\n");

   848 	}

   849 

   850 EXPORT_C void GL_APIENTRY glFogxv (GLenum pname, const GLfixed *params)

   851 	{

   852     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFogxv ->\n");

   853     TInt32 vectorsize = 1;

   854     if( pname == GL_FOG_COLOR )

   855         vectorsize = 4;

   856     RemoteFunctionCallData rfcData;

   857     OpenGlES11RFC call( rfcData );

   858     call.Init( OpenGlES11RFC::EglFogxv, RemoteFunctionCallData::EOpRequest );

   859     call.AppendParam( pname );

   860     call.AppendVector( params, vectorsize );

   861     ExecuteCommand(call);

   862     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFogxv <-\n");

   863 	}

   864 

   865 EXPORT_C void GL_APIENTRY glFrontFace (GLenum mode)

   866 	{

   867     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFrontFace ->\n");

   868     RemoteFunctionCallData rfcData;

   869     OpenGlES11RFC call( rfcData );

   870     call.Init( OpenGlES11RFC::EglFrontFace, RemoteFunctionCallData::EOpRequest );

   871     call.AppendParam( mode );

   872     ExecuteCommand(call);

   873     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFrontFace <-\n");

   874 	}

   875 

   876 EXPORT_C void GL_APIENTRY glFrustumf (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) __SOFTFP

   877 	{

   878     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFrustumf ->\n");

   879     RemoteFunctionCallData rfcData;

   880     OpenGlES11RFC call( rfcData );

   881     call.Init( OpenGlES11RFC::EglFrustumf, RemoteFunctionCallData::EOpRequest );

   882     call.AppendParam( left );

   883     call.AppendParam( right );

   884     call.AppendParam( bottom );

   885     call.AppendParam( top );

   886     call.AppendParam( zNear );

   887     call.AppendParam( zFar );

   888     ExecuteCommand(call);

   889     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFrustumf <-\n");

   890 	}

   891 

   892 EXPORT_C void GL_APIENTRY glFrustumx (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)

   893 	{

   894     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFrustumx ->\n");

   895     RemoteFunctionCallData rfcData;

   896     OpenGlES11RFC call( rfcData );

   897     call.Init( OpenGlES11RFC::EglFrustumx, RemoteFunctionCallData::EOpRequest );

   898     call.AppendParam( left );

   899     call.AppendParam( right );

   900     call.AppendParam( bottom );

   901     call.AppendParam( top );

   902     call.AppendParam( zNear );

   903     call.AppendParam( zFar );

   904     ExecuteCommand(call);

   905     OPENGL_TRACE(_APICALL_, "OpenGL client side: glFrustumx <-\n");

   906 }

   907 

   908 EXPORT_C void GL_APIENTRY glGenBuffers (GLsizei n, GLuint *buffers)

   909 	{

   910     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGenBuffers ->\n");

   911     if(n < 0)

   912     	{

   913         SetError( GL_INVALID_VALUE );

   914         return;

   915     	}

   916     RemoteFunctionCallData rfcData;

   917     OpenGlES11RFC call( rfcData );

   918     call.Init( OpenGlES11RFC::EglGenBuffers );

   919     call.AppendParam( n );

   920     call.AppendVector( buffers, n, RemoteFunctionCallData::EOut );

   921     ExecuteCommand(call);

   922     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGenBuffers <-\n");

   923 	}

   924 

   925 EXPORT_C void GL_APIENTRY glGenTextures (GLsizei n, GLuint *textures)

   926 	{

   927     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGenTextures ->\n");

   928     if(n < 0) // cannot serialize vector with size < 0

   929     	{

   930         SetError( GL_INVALID_VALUE );

   931         return;

   932     	}

   933     RemoteFunctionCallData rfcData;

   934     OpenGlES11RFC call( rfcData );

   935     call.Init( OpenGlES11RFC::EglGenTextures );

   936     call.AppendParam( n );

   937     call.AppendVector( textures, n, RemoteFunctionCallData::EOut );

   938     ExecuteCommand(call);

   939     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGenTextures <-\n");

   940 	}

   941 

   942 EXPORT_C void GL_APIENTRY glGetBooleanv (GLenum pname, GLboolean *params)

   943 	{

   944     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetBooleanv ->\n");

   945     TInt32 vectorsize = 1;

   946     if( pname == GL_COLOR_WRITEMASK )

   947         vectorsize = 4;

   948     RemoteFunctionCallData rfcData;

   949     OpenGlES11RFC call( rfcData );

   950     call.Init( OpenGlES11RFC::EglGetBooleanv );

   951     call.AppendParam( pname );

   952     call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut );

   953     ExecuteCommand(call);

   954     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetBooleanv <-\n");

   955 	}

   956 

   957 EXPORT_C void GL_APIENTRY glGetBufferParameteriv (GLenum target, GLenum pname, GLint *params)

   958 	{

   959     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetBufferParameteriv ->\n");

   960     RemoteFunctionCallData rfcData;

   961     OpenGlES11RFC call( rfcData );

   962     call.Init( OpenGlES11RFC::EglGetBufferParameteriv );

   963     call.AppendParam( target );

   964     call.AppendParam( pname );

   965     call.AppendVector( params, 1, RemoteFunctionCallData::EOut );

   966     ExecuteCommand(call);

   967     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetBufferParameteriv <-\n");

   968 	}

   969 

   970 EXPORT_C void GL_APIENTRY glGetClipPlanef (GLenum pname, GLfloat eqn[4])

   971 	{

   972     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetClipPlanef ->\n");

   973     RemoteFunctionCallData rfcData;

   974     OpenGlES11RFC call( rfcData );

   975     call.Init( OpenGlES11RFC::EglGetClipPlanef );

   976     call.AppendParam( pname );

   977     call.AppendVector( eqn, 4, RemoteFunctionCallData::EOut );

   978     ExecuteCommand(call);

   979     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetClipPlanef <-\n");

   980 	}

   981 

   982 EXPORT_C void GL_APIENTRY glGetClipPlanex (GLenum pname, GLfixed eqn[4])

   983 	{

   984     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetClipPlanex ->\n");

   985     RemoteFunctionCallData rfcData;

   986     OpenGlES11RFC call( rfcData );

   987     call.Init( OpenGlES11RFC::EglGetClipPlanex );

   988     call.AppendParam( pname );

   989     call.AppendVector( eqn, 4, RemoteFunctionCallData::EOut );

   990     ExecuteCommand(call);

   991     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetClipPlanex <-\n");

   992 	}

   993 

   994 EXPORT_C GLenum GL_APIENTRY glGetError (void)

   995 	{

   996     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetError ->\n");

   997     GLenum gles11Error = GL_NO_ERROR;

   998     MGlesContext* glesContext = CVghwUtils::GlesContext();

   999     if (glesContext)

  1000     	{

  1001 		gles11Error = glesContext->GlesError();

  1002     	}

  1003     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetError <- %x\n", gles11Error);

  1004     return gles11Error;

  1005 	}

  1006 

  1007 inline TInt32 getGetterVectorSize(GLenum pname)

  1008 	{

  1009     // oglGetterData.inl, s_getterInfos struct

  1010     TInt32 vectorsize;

  1011     switch( pname )

  1012     	{

  1013         case GL_SMOOTH_POINT_SIZE_RANGE:

  1014         case GL_SMOOTH_LINE_WIDTH_RANGE:

  1015         case GL_DEPTH_RANGE:

  1016         case GL_MAX_VIEWPORT_DIMS:

  1017         case GL_ALIASED_POINT_SIZE_RANGE:

  1018         case GL_ALIASED_LINE_WIDTH_RANGE:

  1019             vectorsize = 2;

  1020             break;

  1021         case GL_CURRENT_NORMAL:

  1022         case GL_POINT_DISTANCE_ATTENUATION:

  1023             vectorsize = 3;

  1024             break;

  1025         case GL_CURRENT_COLOR:

  1026         case GL_CURRENT_TEXTURE_COORDS:

  1027         case GL_LIGHT_MODEL_AMBIENT:

  1028         case GL_FOG_COLOR:

  1029         case GL_VIEWPORT:

  1030         case GL_SCISSOR_BOX:

  1031         case GL_COLOR_CLEAR_VALUE:

  1032         case GL_COLOR_WRITEMASK:

  1033             vectorsize = 4;

  1034             break;

  1035         case GL_COMPRESSED_TEXTURE_FORMATS:

  1036             vectorsize = 10;

  1037             break;

  1038         case GL_MODELVIEW_MATRIX:

  1039         case GL_PROJECTION_MATRIX:

  1040         case GL_TEXTURE_MATRIX:

  1041             vectorsize = 16;

  1042             break;

  1043         default:

  1044             vectorsize = 1;

  1045             break;

  1046     	}

  1047     return vectorsize;

  1048 	}

  1049 

  1050 EXPORT_C void GL_APIENTRY glGetFixedv (GLenum pname, GLfixed *params)

  1051 	{

  1052     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetFixedv ->\n");

  1053     TInt32 vectorsize = getGetterVectorSize(pname);

  1054     RemoteFunctionCallData rfcData;

  1055     OpenGlES11RFC call( rfcData );

  1056     call.Init( OpenGlES11RFC::EglGetFixedv );

  1057     call.AppendParam( pname );

  1058     call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut );

  1059     ExecuteCommand(call);

  1060     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetFixedv <-\n");

  1061 	}

  1062 

  1063 EXPORT_C void GL_APIENTRY glGetFloatv (GLenum pname, GLfloat *params)

  1064 	{

  1065     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetFloatv ->\n");

  1066     TInt32 vectorsize = getGetterVectorSize(pname);

  1067     RemoteFunctionCallData rfcData;

  1068     OpenGlES11RFC call( rfcData );

  1069     call.Init( OpenGlES11RFC::EglGetFloatv );

  1070     call.AppendParam( pname );

  1071     call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut );

  1072     ExecuteCommand(call);

  1073     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetFloatv <-\n");

  1074 	}

  1075 

  1076 EXPORT_C void GL_APIENTRY glGetIntegerv (GLenum pname, GLint *params)

  1077 	{

  1078     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetIntegerv ->\n");

  1079     TInt32 vectorsize = getGetterVectorSize(pname);

  1080     RemoteFunctionCallData rfcData;

  1081     OpenGlES11RFC call( rfcData );

  1082     call.Init( OpenGlES11RFC::EglGetIntegerv );

  1083     call.AppendParam( pname );

  1084     call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut );

  1085     ExecuteCommand(call);

  1086     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetIntegerv <-\n");

  1087 	}

  1088 

  1089 inline TInt32 getLightVectorSize(GLenum pname)

  1090 	{

  1091     // oglApi.inl, oglGetLightInternal()

  1092     TInt32 vectorsize;

  1093     switch( pname )

  1094     	{

  1095         case GL_SPOT_DIRECTION:

  1096             vectorsize = 3;

  1097             break;

  1098         case GL_AMBIENT:

  1099         case GL_DIFFUSE:

  1100         case GL_SPECULAR:

  1101         case GL_POSITION:

  1102             vectorsize = 4;

  1103             break;

  1104         default:

  1105             vectorsize = 1;

  1106             break;

  1107 		}

  1108     return vectorsize;

  1109 	}

  1110 

  1111 EXPORT_C void GL_APIENTRY glGetLightfv (GLenum light, GLenum pname, GLfloat *params)

  1112 	{

  1113     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetLightfv ->\n");

  1114     TInt32 vectorsize = getLightVectorSize(pname);

  1115     RemoteFunctionCallData rfcData;

  1116     OpenGlES11RFC call( rfcData );

  1117     call.Init( OpenGlES11RFC::EglGetLightfv );

  1118     call.AppendParam( light );

  1119     call.AppendParam( pname );

  1120     call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut );

  1121     ExecuteCommand(call);

  1122     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetLightfv <-\n");

  1123 	}

  1124 

  1125 EXPORT_C void GL_APIENTRY glGetLightxv (GLenum light, GLenum pname, GLfixed *params)

  1126 	{

  1127     OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetLightxv ->\n");

  1128     TInt32 vectorsize = getLightVectorSize(pname);

  1129     RemoteFunctionCallData rfcData;

  1130     OpenGlES11RFC call( rfcData );

  1131     call.Init( OpenGlES11RFC::EglGetLightxv );

  1132     call.AppendParam( light );

  1133     call.AppendParam( pname );

  1134     call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut );