# HG changeset patch # User Faisal Memon # Date 1283963776 -3600 # Node ID 1b3a923fcf079c80613ee62f8c78bce1382ede5e # Parent 86401090b67f8460276cc762616557c0828a1953 Add guestopengles11 diff -r 86401090b67f -r 1b3a923fcf07 guestrendering/guestopengles11/group/bld.inf --- a/guestrendering/guestopengles11/group/bld.inf Wed Sep 08 17:21:01 2010 +0100 +++ b/guestrendering/guestopengles11/group/bld.inf Wed Sep 08 17:36:16 2010 +0100 @@ -0,0 +1,23 @@ +// 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: +// Build specification file for the guest OpenGL ES 1.1 implementation + +PRJ_PLATFORMS +DEFAULT -WINSCW + +PRJ_EXPORTS +../rom/guestopengles11.iby /epoc32/rom/include/guestopengles11.iby + +PRJ_MMPFILES +guestopengles11.mmp diff -r 86401090b67f -r 1b3a923fcf07 guestrendering/guestopengles11/group/guestopengles11.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/guestrendering/guestopengles11/group/guestopengles11.mmp Wed Sep 08 17:36:16 2010 +0100 @@ -0,0 +1,48 @@ +// 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: +// Project file for the Guest OpenGL ES 1.1 implementation + +#include +#include // For uids + +target guestopengles11.dll // Destination filename +targettype dll // Binary build type +linkas libGLESv1_CM.dll +uid KUidSharedDllUidValue KUidOpenGLESv1CommonProfileDllUidValue // File uids +capability CAP_GENERAL_DLL +vendorid VID_DEFAULT //Nokia vendor id + +OS_LAYER_ESTLIB_SYSTEMINCLUDE + +systeminclude /epoc32/include // General Symbian include files +userinclude ../inc // Local include files +userinclude ../../vghwutils/inc // Local include files + +USERINCLUDE ../../vghwserialiser/inc +SOURCEPATH ../../vghwserialiser/src // Relative path to source files +SOURCE opengles11rfc.cpp + +sourcepath ../src // Relative path to source files +source opengl.cpp + +library euser.lib // Mandatory +library vghwutils.lib +library guestvideohwapi.lib +library vghwserialiser.lib +LIBRARY libc.lib // For strcmp, etc + +// standard ARM def file baseline for all implementions +DEFFILE /epoc32/include/def/eabi/libglesv1_cm11.def + +EPOCALLOWDLLDATA diff -r 86401090b67f -r 1b3a923fcf07 guestrendering/guestopengles11/inc/opengl.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/guestrendering/guestopengles11/inc/opengl.h Wed Sep 08 17:36:16 2010 +0100 @@ -0,0 +1,107 @@ +// 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: +// Header file for the Guest OpenGL ES 1.1 serialization stubs + +#ifndef __GUESTOPENGLES11_OPENGL_H__ +#define __GUESTOPENGLES11_OPENGL_H__ + +#include + +// set trace level here +#ifndef _OPENGL_TRACE_LEVEL_ +#define _OPENGL_TRACE_LEVEL_ ( _APICALL_ ) +#endif + +// trace levels (in udeb mode) + +#define _NONE_ 0x0000 // no traces in udeb mode +#define _GEN_ (1 << 0) // general traces (default) +#define _APICALL_ (1 << 1) // API call traces (function entry and exit) +#define _DETAIL_ (1 << 2) // detailed traces +#define _ALL_ 0xFFFF + + +#ifdef _DEBUG + #define OPENGL_TRACE(level, fmt, args...) \ + { \ + if(level & _OPENGL_TRACE_LEVEL_) \ + { \ + RDebug::Printf(fmt, ##args); \ + } \ + } + #define GLPANIC_ASSERT(condition, panic) if (!(condition)) { GlesPanic(panic, #condition, __FILE__, __LINE__); } + #define GLPANIC_ASSERT_DEBUG(condition, panic) if (!(condition)) { GlesPanic(panic, #condition, __FILE__, __LINE__); } +#else + #define OPENGL_TRACE(level, fmt, args...) + #define GLPANIC_ASSERT(condition, panic) if (!(condition)) { GlesPanic(panic, NULL, NULL, __LINE__); } + #define GLPANIC_ASSERT_DEBUG(condition, panic) +#endif + +// Guest Open VG panic codes +typedef enum + { + EGlPanicNotReplyOpcode = 1, + } TGlPanic; + +void GlesPanic(TGlPanic aPanicCode, char* aCondition, char* aFile, TInt aLine); + + +/* String constants */ +#define OGL_VENDOR_STRING "Nokia" +#define OGL_RENDERER_STRING "1.1.0" +#define OGL_VERSION_STRING "OpenGL ES-CM 1.1" +#define OGL_EXTENSION_STRING "GL_OES_byte_coordinates GL_OES_fixed_point GL_OES_single_precision " \ + "GL_OES_read_format GL_OES_query_matrix GL_OES_compressed_paletted_texture " \ + "GL_OES_matrix_palette GL_OES_point_sprite GL_OES_point_size_array " \ + "GL_OES_draw_texture GL_OES_matrix_get GL_OES_swap_control GL_OES_render_texture" + +static const char* const g_strings[] = +{ + OGL_VENDOR_STRING, + OGL_RENDERER_STRING, + OGL_VERSION_STRING, + OGL_EXTENSION_STRING +}; + +/* vertex array pointers */ +enum +{ + COLOR_ARRAY, + NORMAL_ARRAY, + POINT_SIZE_ARRAY, + TEX_COORD_ARRAY, + VERTEX_ARRAY, + MATRIX_INDEX_ARRAY, + WEIGHT_ARRAY, + NUM_ARRAYS +}; + +typedef struct +{ + GLint size; + GLenum type; + GLsizei stride; + const GLvoid *pointer; +} vertexArrayInfo; + + +NONSHARABLE_CLASS(TGles11ApiForEgl) : public MGles11ApiForEgl + { +public: + TGles11ApiForEgl(); // constructor used to publish the MGles11ApiForEgl vtable + ~TGles11ApiForEgl(); // destructor used to unpublish the MGles11ApiForEgl vtable + virtual ExtensionProcPointer guestGetGles11ProcAddress (const char *aProcName); + }; + +#endif // __GUESTOPENGLES11_OPENGL_H__ diff -r 86401090b67f -r 1b3a923fcf07 guestrendering/guestopengles11/rom/guestopengles11.iby --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/guestrendering/guestopengles11/rom/guestopengles11.iby Wed Sep 08 17:36:16 2010 +0100 @@ -0,0 +1,23 @@ +// 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: +// Guest OpenGL ES 1.1 Rom IBY file + +#ifndef __GUEST_OPENGL_IBY__ +#define __GUEST_OPENGL_IBY__ + +#include + +file=ABI_DIR\BUILD_DIR\libGLES_CM.dll \sys\bin\libGLES_CM.dll +file=ABI_DIR\BUILD_DIR\guestopengles11.dll sys\bin\libGLESv1_CM.dll +#endif diff -r 86401090b67f -r 1b3a923fcf07 guestrendering/guestopengles11/src/opengl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/guestrendering/guestopengles11/src/opengl.cpp Wed Sep 08 17:36:16 2010 +0100 @@ -0,0 +1,2553 @@ +// 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: +// Implementation of Guest OpenGL ES 1.1 serialization stubs + +#include "remotefunctioncall.h" +#include "opengles11rfc.h" +#include "vghwutils.h" +#include "opengl.h" + +// Writeable Static Data, is initialised to 0s by the compiler +vertexArrayInfo vertexArrays[NUM_ARRAYS]; +bool vertexArraysEnabled[NUM_ARRAYS]; + + +// Writeable Static Data - causes constructor to be called at DLL load time. +TGles11ApiForEgl GlesApiExporter; + + + +// Informative Panic messages +_LIT(KGlesPanicCategory, "Guest GLES"); + +void GlesPanic(TGlPanic aPanicCode, char* aCondition, char* aFile, TInt aLine) + { + if (aCondition && aFile) + { + RDebug::Printf("Guest Open GLES DLL Panic %d for failed Assert (%s), at %s:%d", aPanicCode, aCondition, aFile, aLine); + } + else + { + RDebug::Printf("Guest Open GLES DLL Panic %d for failed Assert (line %d)", aPanicCode, aLine); + } + + User::Panic(KGlesPanicCategory, aPanicCode); + } + + +inline void SetError(GLint aError) + { + MGlesContext* glesContext = CVghwUtils::GlesContext(); + if (glesContext) + { // there is a GL ES context + glesContext->SetGlesError(aError); + } + } + +inline void ExecuteCommand(RemoteFunctionCall& aRequestData) + { + MGlesContext* glesContext = CVghwUtils::GlesContext(); + if (glesContext) + { // there is a GL ES context + glesContext->ExecuteGlesCommand(aRequestData); + } + } + +inline TUint32 ExecuteFunction(RemoteFunctionCall& aRequestData) + { + GLPANIC_ASSERT_DEBUG(aRequestData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EGlPanicNotReplyOpcode); + MGlesContext* glesContext = CVghwUtils::GlesContext(); + if (glesContext) + { // there is GL ES context + glesContext->ExecuteGlesCommand(aRequestData); + return aRequestData.ReturnValue(); + } + return 0; + } + + +extern "C" { + +EXPORT_C void GL_APIENTRY glActiveTexture (GLenum texture) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glActiveTexture ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglActiveTexture, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( texture ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glActiveTexture <-\n"); + } + +EXPORT_C void GL_APIENTRY glAlphaFunc (GLenum func, GLclampf ref) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glAlphaFunc ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglAlphaFunc, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( func ); + call.AppendParam( ref ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glAlphaFunc <-\n"); + } + +EXPORT_C void GL_APIENTRY glAlphaFuncx (GLenum func, GLclampx ref) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glAlphaFuncx ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglAlphaFuncx, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( func ); + call.AppendParam( ref ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glAlphaFuncx <-\n"); + } + +EXPORT_C void GL_APIENTRY glBindBuffer (GLenum target, GLuint buffer) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glBindBuffer ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglBindBuffer, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( buffer ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glBindBuffer <-\n"); + } + +EXPORT_C void GL_APIENTRY glBindTexture (GLenum target, GLuint texture) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glBindTexture ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglBindTexture, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( texture ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glBindTexture <-\n"); + } + +EXPORT_C void GL_APIENTRY glBlendFunc (GLenum sfactor, GLenum dfactor) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glBlendFunc ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglBlendFunc, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( sfactor ); + call.AppendParam( dfactor ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glBlendFunc <-\n"); + } + +EXPORT_C void GL_APIENTRY glBufferData (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glBufferData ->\n"); + if(size < 0) // cannot serialize vector with size < 0 + { + SetError( GL_INVALID_VALUE ); + return; + } + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglBufferData, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( size ); + call.AppendVector( data, size ); + call.AppendParam( usage ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glBufferData <-\n"); + } + +EXPORT_C void GL_APIENTRY glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glBufferSubData ->\n"); + if(offset < 0 || size < 0) // cannot serialize vector with size < 0 + { + SetError( GL_INVALID_VALUE ); + return; + } + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglBufferSubData, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( offset ); + call.AppendParam( size ); + call.AppendVector( data, offset+size ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glBufferSubData <-\n"); + } + +EXPORT_C void GL_APIENTRY glClear (GLbitfield mask) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClear ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglClear, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( mask ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClear <-\n"); + } + +EXPORT_C void GL_APIENTRY glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearColor ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglClearColor, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( red ); + call.AppendParam( green ); + call.AppendParam( blue ); + call.AppendParam( alpha ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearColor <-\n"); + } + +EXPORT_C void GL_APIENTRY glClearColorx (GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearColorx ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglClearColorx, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( red ); + call.AppendParam( green ); + call.AppendParam( blue ); + call.AppendParam( alpha ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearColorx <-\n"); + } + +EXPORT_C void GL_APIENTRY glClearDepthf (GLclampf depth) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearDepthf ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglClearDepthf, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( depth ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearDepthf <-\n"); + } + +EXPORT_C void GL_APIENTRY glClearDepthx (GLclampx depth) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearDepthx ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglClearDepthx, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( depth ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearDepthx <-\n"); + } + +EXPORT_C void GL_APIENTRY glClearStencil (GLint s) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearStencil ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglClearStencil, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( s ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClearStencil <-\n"); + } + +EXPORT_C void GL_APIENTRY glClientActiveTexture (GLenum texture) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClientActiveTexture ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglClientActiveTexture, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( texture ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClientActiveTexture <-\n"); + } + +EXPORT_C void GL_APIENTRY glClipPlanef (GLenum plane, const GLfloat *equation) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClipPlanef ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglClipPlanef, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( plane ); + call.AppendVector( equation, 4 ); // 4 values according to OpenGL_ES_1.1.12.pdf, section 2.11 + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClipPlanef <-\n"); + } + +EXPORT_C void GL_APIENTRY glClipPlanex (GLenum plane, const GLfixed *equation) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClipPlanex ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglClipPlanex, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( plane ); + call.AppendVector( equation, 4 ); // 4 values according to OpenGL_ES_1.1.12.pdf, section 2.11 + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glClipPlanex <-\n"); + } + +EXPORT_C void GL_APIENTRY glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glColor4f ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglColor4f, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( red ); + call.AppendParam( green ); + call.AppendParam( blue ); + call.AppendParam( alpha ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glColor4f <-\n"); + } + +EXPORT_C void GL_APIENTRY glColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glColor4ub ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglColor4ub, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( red ); + call.AppendParam( green ); + call.AppendParam( blue ); + call.AppendParam( alpha ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glColor4ub <-\n"); + } + +EXPORT_C void GL_APIENTRY glColor4x (GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glColor4x ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglColor4x, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( red ); + call.AppendParam( green ); + call.AppendParam( blue ); + call.AppendParam( alpha ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glColor4x <-\n"); + } + +EXPORT_C void GL_APIENTRY glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glColorMask ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglColorMask, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( red ); + call.AppendParam( green ); + call.AppendParam( blue ); + call.AppendParam( alpha ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glColorMask <-\n"); + } + +EXPORT_C void GL_APIENTRY glColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glColorPointer ->\n"); + vertexArrays[COLOR_ARRAY].size = size; + vertexArrays[COLOR_ARRAY].type = type; + vertexArrays[COLOR_ARRAY].stride = stride; + vertexArrays[COLOR_ARRAY].pointer = pointer; + OPENGL_TRACE(_APICALL_, "OpenGL client side: glColorPointer <-\n"); + } + +EXPORT_C void GL_APIENTRY glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glCompressedTexImage2D ->\n"); + if(imageSize < 0) // cannot serialize vector with size < 0 + { + SetError( GL_INVALID_VALUE ); + return; + } + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglCompressedTexImage2D, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( level ); + call.AppendParam( internalformat ); + call.AppendParam( width ); + call.AppendParam( height ); + call.AppendParam( border ); + call.AppendParam( imageSize ); + call.AppendVector( data, imageSize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glCompressedTexImage2D <-\n"); + } + +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) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glCompressedTexSubImage2D ->\n"); + if(imageSize < 0) // cannot serialize vector with size < 0 + { + SetError( GL_INVALID_VALUE ); + return; + } + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglCompressedTexSubImage2D, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( level ); + call.AppendParam( xoffset ); + call.AppendParam( yoffset ); + call.AppendParam( width ); + call.AppendParam( height ); + call.AppendParam( format ); + call.AppendParam( imageSize ); + call.AppendVector( data, imageSize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glCompressedTexSubImage2D <-\n"); + } + +EXPORT_C void GL_APIENTRY glCopyTexImage2D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glCopyTexImage2D ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglCopyTexImage2D, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( level ); + call.AppendParam( internalformat ); + call.AppendParam( x ); + call.AppendParam( y ); + call.AppendParam( width ); + call.AppendParam( height ); + call.AppendParam( border ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glCopyTexImage2D <-\n"); + } + +EXPORT_C void GL_APIENTRY glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glCopyTexSubImage2D ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglCopyTexSubImage2D, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( level ); + call.AppendParam( xoffset ); + call.AppendParam( yoffset ); + call.AppendParam( x ); + call.AppendParam( y ); + call.AppendParam( width ); + call.AppendParam( height ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glCopyTexSubImage2D <-\n"); + } + +EXPORT_C void GL_APIENTRY glCullFace (GLenum mode) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glCullFace ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglCullFace, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( mode ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glCullFace <-\n"); + } + +EXPORT_C void GL_APIENTRY glDeleteBuffers (GLsizei n, const GLuint *buffers) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDeleteBuffers ->\n"); + if(n < 0) // cannot serialize vector with size < 0 + { + SetError( GL_INVALID_VALUE ); + return; + } + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDeleteBuffers, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( n ); + call.AppendVector( buffers, n ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDeleteBuffers <-\n"); + } + +EXPORT_C void GL_APIENTRY glDeleteTextures (GLsizei n, const GLuint *textures) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDeleteTextures ->\n"); + if(n < 0) // cannot serialize vector with size < 0 + { + SetError( GL_INVALID_VALUE ); + return; + } + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDeleteTextures, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( n ); + call.AppendVector( textures, n ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDeleteTextures <-\n"); + } + +EXPORT_C void GL_APIENTRY glDepthFunc (GLenum func) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDepthFunc ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDepthFunc, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( func ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDepthFunc <-\n"); + } + +EXPORT_C void GL_APIENTRY glDepthMask (GLboolean flag) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDepthMask ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDepthMask, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( flag ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDepthMask <-\n"); + } + +EXPORT_C void GL_APIENTRY glDepthRangef (GLclampf zNear, GLclampf zFar) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDepthRangef ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDepthRangef, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( zNear ); + call.AppendParam( zFar ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDepthRangef <-\n"); + } + +EXPORT_C void GL_APIENTRY glDepthRangex (GLclampx zNear, GLclampx zFar) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDepthRangex ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDepthRangex, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( zNear ); + call.AppendParam( zFar ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDepthRangex <-\n"); + } + +EXPORT_C void GL_APIENTRY glDisable (GLenum cap) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDisable ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDisable, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( cap ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDisable <-\n"); + } + +EXPORT_C void GL_APIENTRY glDisableClientState (GLenum array) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDisableClientState ->\n"); + // store state on here as well, used in DrawArrays and DrawElements + bool enumError = false; + switch( array ) + { + case GL_COLOR_ARRAY: + vertexArraysEnabled[COLOR_ARRAY] = false; + break; + case GL_NORMAL_ARRAY: + vertexArraysEnabled[NORMAL_ARRAY] = false; + break; + case GL_POINT_SIZE_ARRAY_OES: + vertexArraysEnabled[POINT_SIZE_ARRAY] = false; + break; + case GL_TEXTURE_COORD_ARRAY: + vertexArraysEnabled[TEX_COORD_ARRAY] = false; + break; + case GL_VERTEX_ARRAY: + vertexArraysEnabled[VERTEX_ARRAY] = false; + break; + case GL_MATRIX_INDEX_ARRAY_OES: + vertexArraysEnabled[MATRIX_INDEX_ARRAY] = false; + break; + case GL_WEIGHT_ARRAY_OES: + vertexArraysEnabled[WEIGHT_ARRAY] = false; + break; + default: + SetError( GL_INVALID_ENUM ); + enumError = true; + break; + } + if( !enumError ) + { + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDisableClientState, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( array ); + ExecuteCommand(call); + } + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDisableClientState <-\n"); + } + +EXPORT_C void GL_APIENTRY glDrawArrays (GLenum mode, GLint first, GLsizei count) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawArrays ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDrawArrays, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( mode ); + call.AppendParam( first ); + call.AppendParam( count ); + + /* serialize vertex arrays + order of the data: + - number of arrays (int) + - bitfield of enabled arrays, order specified by opengl.h vertex array pointer enumeration (int) + - for each enabled vertex array: + - size (int) + - type (int) + - stride (int) + - data vector + */ + int arrayCount = 0; + int arrayEnabled = 0; + for(int i=0; i\n"); + if(count < 0) // cannot serialize vector with size < 0 + { + SetError( GL_INVALID_VALUE ); + return; + } + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDrawElements, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( mode ); + call.AppendParam( count ); + call.AppendParam( type ); + call.AppendVector( indices, count ); + + /* serialize vertex arrays + order of the data: + - number of arrays (int) + - bitfield of enabled arrays, order specified by opengl.h vertex array pointer enumeration (int) + - for each enabled vertex array: + - size (int) + - type (int) + - stride (int) + - data vector + */ + int arrayCount = 0; + int arrayEnabled = 0; + for(int i=0; i maxIndex ) + maxIndex = (int)((GLubyte*)indices)[i]; + } + break; + case GL_UNSIGNED_SHORT: + for(int i=0; i maxIndex ) + maxIndex = (int)((GLushort*)indices)[i]; + } + break; + } + for(int i=0; i\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglEnable, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( cap ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glEnable <-\n"); + } + +EXPORT_C void GL_APIENTRY glEnableClientState (GLenum array) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glEnableClientState ->\n"); + // store state on here as well, used in DrawArrays and DrawElements + bool enumError = false; + switch( array ) + { + case GL_COLOR_ARRAY: + vertexArraysEnabled[COLOR_ARRAY] = true; + break; + case GL_NORMAL_ARRAY: + vertexArraysEnabled[NORMAL_ARRAY] = true; + break; + case GL_POINT_SIZE_ARRAY_OES: + vertexArraysEnabled[POINT_SIZE_ARRAY] = true; + break; + case GL_TEXTURE_COORD_ARRAY: + vertexArraysEnabled[TEX_COORD_ARRAY] = true; + break; + case GL_VERTEX_ARRAY: + vertexArraysEnabled[VERTEX_ARRAY] = true; + break; + case GL_MATRIX_INDEX_ARRAY_OES: + vertexArraysEnabled[MATRIX_INDEX_ARRAY] = true; + break; + case GL_WEIGHT_ARRAY_OES: + vertexArraysEnabled[WEIGHT_ARRAY] = true; + break; + default: + SetError( GL_INVALID_ENUM ); + enumError = true; + break; + } + if( !enumError ) + { + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglEnableClientState, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( array ); + ExecuteCommand(call); + } + OPENGL_TRACE(_APICALL_, "OpenGL client side: glEnableClientState <-\n"); + } + +EXPORT_C void GL_APIENTRY glFinish (void) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFinish ->\n"); + MGlesContext* glesContext = CVghwUtils::GlesContext(); + if (glesContext) + { // there is GL ES context + glesContext->ExecuteGlesFinishCommand(); + } + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFinish <-\n"); + } + +EXPORT_C void GL_APIENTRY glFlush (void) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFlush ->\n"); + MGlesContext* glesContext = CVghwUtils::GlesContext(); + if (glesContext) + { // there is GL ES context + glesContext->ExecuteGlesFlushCommand(); + } + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFlush <-\n"); + } + +EXPORT_C void GL_APIENTRY glFogf (GLenum pname, GLfloat param) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFogf ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglFogf, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFogf <-\n"); + } + +EXPORT_C void GL_APIENTRY glFogfv (GLenum pname, const GLfloat *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFogfv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_FOG_COLOR ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglFogfv, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFogfv <-\n"); + } + +EXPORT_C void GL_APIENTRY glFogx (GLenum pname, GLfixed param) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFogx ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglFogx, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFogx <-\n"); + } + +EXPORT_C void GL_APIENTRY glFogxv (GLenum pname, const GLfixed *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFogxv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_FOG_COLOR ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglFogxv, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFogxv <-\n"); + } + +EXPORT_C void GL_APIENTRY glFrontFace (GLenum mode) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFrontFace ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglFrontFace, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( mode ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFrontFace <-\n"); + } + +EXPORT_C void GL_APIENTRY glFrustumf (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFrustumf ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglFrustumf, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( left ); + call.AppendParam( right ); + call.AppendParam( bottom ); + call.AppendParam( top ); + call.AppendParam( zNear ); + call.AppendParam( zFar ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFrustumf <-\n"); + } + +EXPORT_C void GL_APIENTRY glFrustumx (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFrustumx ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglFrustumx, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( left ); + call.AppendParam( right ); + call.AppendParam( bottom ); + call.AppendParam( top ); + call.AppendParam( zNear ); + call.AppendParam( zFar ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glFrustumx <-\n"); +} + +EXPORT_C void GL_APIENTRY glGenBuffers (GLsizei n, GLuint *buffers) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGenBuffers ->\n"); + if(n < 0) + { + SetError( GL_INVALID_VALUE ); + return; + } + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGenBuffers ); + call.AppendParam( n ); + call.AppendVector( buffers, n, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGenBuffers <-\n"); + } + +EXPORT_C void GL_APIENTRY glGenTextures (GLsizei n, GLuint *textures) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGenTextures ->\n"); + if(n < 0) // cannot serialize vector with size < 0 + { + SetError( GL_INVALID_VALUE ); + return; + } + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGenTextures ); + call.AppendParam( n ); + call.AppendVector( textures, n, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGenTextures <-\n"); + } + +EXPORT_C void GL_APIENTRY glGetBooleanv (GLenum pname, GLboolean *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetBooleanv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_COLOR_WRITEMASK ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetBooleanv ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetBooleanv <-\n"); + } + +EXPORT_C void GL_APIENTRY glGetBufferParameteriv (GLenum target, GLenum pname, GLint *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetBufferParameteriv ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetBufferParameteriv ); + call.AppendParam( target ); + call.AppendParam( pname ); + call.AppendVector( params, 1, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetBufferParameteriv <-\n"); + } + +EXPORT_C void GL_APIENTRY glGetClipPlanef (GLenum pname, GLfloat eqn[4]) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetClipPlanef ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetClipPlanef ); + call.AppendParam( pname ); + call.AppendVector( eqn, 4, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetClipPlanef <-\n"); + } + +EXPORT_C void GL_APIENTRY glGetClipPlanex (GLenum pname, GLfixed eqn[4]) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetClipPlanex ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetClipPlanex ); + call.AppendParam( pname ); + call.AppendVector( eqn, 4, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetClipPlanex <-\n"); + } + +EXPORT_C GLenum GL_APIENTRY glGetError (void) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetError ->\n"); + GLenum gles11Error = GL_NO_ERROR; + MGlesContext* glesContext = CVghwUtils::GlesContext(); + if (glesContext) + { + gles11Error = glesContext->GlesError(); + } + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetError <- %x\n", gles11Error); + return gles11Error; + } + +inline TInt32 getGetterVectorSize(GLenum pname) + { + // oglGetterData.inl, s_getterInfos struct + TInt32 vectorsize; + switch( pname ) + { + case GL_SMOOTH_POINT_SIZE_RANGE: + case GL_SMOOTH_LINE_WIDTH_RANGE: + case GL_DEPTH_RANGE: + case GL_MAX_VIEWPORT_DIMS: + case GL_ALIASED_POINT_SIZE_RANGE: + case GL_ALIASED_LINE_WIDTH_RANGE: + vectorsize = 2; + break; + case GL_CURRENT_NORMAL: + case GL_POINT_DISTANCE_ATTENUATION: + vectorsize = 3; + break; + case GL_CURRENT_COLOR: + case GL_CURRENT_TEXTURE_COORDS: + case GL_LIGHT_MODEL_AMBIENT: + case GL_FOG_COLOR: + case GL_VIEWPORT: + case GL_SCISSOR_BOX: + case GL_COLOR_CLEAR_VALUE: + case GL_COLOR_WRITEMASK: + vectorsize = 4; + break; + case GL_COMPRESSED_TEXTURE_FORMATS: + vectorsize = 10; + break; + case GL_MODELVIEW_MATRIX: + case GL_PROJECTION_MATRIX: + case GL_TEXTURE_MATRIX: + vectorsize = 16; + break; + default: + vectorsize = 1; + break; + } + return vectorsize; + } + +EXPORT_C void GL_APIENTRY glGetFixedv (GLenum pname, GLfixed *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetFixedv ->\n"); + TInt32 vectorsize = getGetterVectorSize(pname); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetFixedv ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetFixedv <-\n"); + } + +EXPORT_C void GL_APIENTRY glGetFloatv (GLenum pname, GLfloat *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetFloatv ->\n"); + TInt32 vectorsize = getGetterVectorSize(pname); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetFloatv ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetFloatv <-\n"); + } + +EXPORT_C void GL_APIENTRY glGetIntegerv (GLenum pname, GLint *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetIntegerv ->\n"); + TInt32 vectorsize = getGetterVectorSize(pname); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetIntegerv ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetIntegerv <-\n"); + } + +inline TInt32 getLightVectorSize(GLenum pname) + { + // oglApi.inl, oglGetLightInternal() + TInt32 vectorsize; + switch( pname ) + { + case GL_SPOT_DIRECTION: + vectorsize = 3; + break; + case GL_AMBIENT: + case GL_DIFFUSE: + case GL_SPECULAR: + case GL_POSITION: + vectorsize = 4; + break; + default: + vectorsize = 1; + break; + } + return vectorsize; + } + +EXPORT_C void GL_APIENTRY glGetLightfv (GLenum light, GLenum pname, GLfloat *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetLightfv ->\n"); + TInt32 vectorsize = getLightVectorSize(pname); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetLightfv ); + call.AppendParam( light ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetLightfv <-\n"); + } + +EXPORT_C void GL_APIENTRY glGetLightxv (GLenum light, GLenum pname, GLfixed *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetLightxv ->\n"); + TInt32 vectorsize = getLightVectorSize(pname); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetLightxv ); + call.AppendParam( light ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetLightxv <-\n"); + } + +inline TInt32 getMaterialVectorSize(GLenum pname) + { + // oglApi.inl, oglGetMaterialInternal() + TInt32 vectorsize; + switch( pname ) + { + case GL_AMBIENT: + case GL_DIFFUSE: + case GL_SPECULAR: + case GL_EMISSION: + vectorsize = 4; + break; + default: + vectorsize = 1; + break; + } + return vectorsize; + } + +EXPORT_C void GL_APIENTRY glGetMaterialfv (GLenum face, GLenum pname, GLfloat *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetMaterialfv ->\n"); + TInt32 vectorsize = getMaterialVectorSize(pname); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetMaterialfv ); + call.AppendParam( face ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetMaterialfv <-\n"); + } + +EXPORT_C void GL_APIENTRY glGetMaterialxv (GLenum face, GLenum pname, GLfixed *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetMaterialxv ->\n"); + TInt32 vectorsize = getMaterialVectorSize(pname); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetMaterialxv ); + call.AppendParam( face ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetMaterialxv <-\n"); + } + +EXPORT_C void GL_APIENTRY glGetPointerv (GLenum pname, void **params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetPointerv ->\n"); + const GLvoid *pointer; + switch( pname ) + { + case GL_COLOR_ARRAY_POINTER: + pointer = vertexArrays[COLOR_ARRAY].pointer; + break; + case GL_NORMAL_ARRAY_POINTER: + pointer = vertexArrays[NORMAL_ARRAY].pointer; + break; + case GL_POINT_SIZE_ARRAY_POINTER_OES: + pointer = vertexArrays[POINT_SIZE_ARRAY].pointer; + break; + case GL_TEXTURE_COORD_ARRAY_POINTER: + pointer = vertexArrays[TEX_COORD_ARRAY].pointer; + break; + case GL_VERTEX_ARRAY_POINTER: + pointer = vertexArrays[VERTEX_ARRAY].pointer; + break; + case GL_MATRIX_INDEX_ARRAY_POINTER_OES: + pointer = vertexArrays[MATRIX_INDEX_ARRAY].pointer; + break; + case GL_WEIGHT_ARRAY_POINTER_OES: + pointer = vertexArrays[WEIGHT_ARRAY].pointer; + break; + default: + pointer = NULL; + break; + } + *params = (void*)pointer; + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetPointerv <-\n"); + } + +EXPORT_C const GLubyte * GL_APIENTRY glGetString (GLenum name) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetString ->\n"); + if(name < GL_VENDOR || name > GL_EXTENSIONS) + { + SetError( GL_INVALID_ENUM ); + return NULL; + } + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetString <-\n"); + return (const GLubyte*) g_strings[name - GL_VENDOR]; + } + +EXPORT_C void GL_APIENTRY glGetTexEnvfv (GLenum env, GLenum pname, GLfloat *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetTexEnvfv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_TEXTURE_ENV_COLOR ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetTexEnvfv ); + call.AppendParam( env ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetTexEnvfv <-\n"); + } + +EXPORT_C void GL_APIENTRY glGetTexEnviv (GLenum env, GLenum pname, GLint *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetTexEnviv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_TEXTURE_ENV_COLOR ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetTexEnviv ); + call.AppendParam( env ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetTexEnviv <-\n"); + } + +EXPORT_C void GL_APIENTRY glGetTexEnvxv (GLenum env, GLenum pname, GLfixed *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetTexEnvxv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_TEXTURE_ENV_COLOR ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetTexEnvxv ); + call.AppendParam( env ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetTexEnvxv <-\n"); + } + +EXPORT_C void GL_APIENTRY glGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetTexParameterfv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_TEXTURE_CROP_RECT_OES ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetTexParameterfv ); + call.AppendParam( target ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetTexParameterfv <-\n"); + } + +EXPORT_C void GL_APIENTRY glGetTexParameteriv (GLenum target, GLenum pname, GLint *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetTexParameteriv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_TEXTURE_CROP_RECT_OES ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetTexParameteriv ); + call.AppendParam( target ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetTexParameteriv <-\n"); + } + +EXPORT_C void GL_APIENTRY glGetTexParameterxv (GLenum target, GLenum pname, GLfixed *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetTexParameterxv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_TEXTURE_CROP_RECT_OES ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglGetTexParameterxv ); + call.AppendParam( target ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glGetTexParameterxv <-\n"); + } + +EXPORT_C void GL_APIENTRY glHint (GLenum target, GLenum mode) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glHint ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglHint, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( mode ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glHint <-\n"); + } + +EXPORT_C GLboolean GL_APIENTRY glIsBuffer (GLuint buffer) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glIsBuffer ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglIsBuffer ); + call.AppendParam( buffer ); + GLboolean result = (GLboolean)ExecuteFunction(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glIsBuffer <-\n"); + return result; + } + +EXPORT_C GLboolean GL_APIENTRY glIsEnabled (GLenum cap) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glIsEnabled ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglIsEnabled ); + call.AppendParam( cap ); + GLboolean result = (GLboolean)ExecuteFunction(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glIsEnabled <-\n"); + return result; + } + +EXPORT_C GLboolean GL_APIENTRY glIsTexture (GLuint texture) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glIsTexture ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglIsTexture ); + call.AppendParam( texture ); + GLboolean result = (GLboolean)ExecuteFunction(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glIsTexture <-\n"); + return result; + } + +EXPORT_C void GL_APIENTRY glLightf (GLenum light, GLenum pname, GLfloat param) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLightf ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglLightf, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( light ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLightf <-\n"); + } + +EXPORT_C void GL_APIENTRY glLightfv (GLenum light, GLenum pname, const GLfloat *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLightfv ->\n"); + TInt32 vectorsize = getLightVectorSize( pname ); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglLightfv, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( light ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLightfv <-\n"); + } + +EXPORT_C void GL_APIENTRY glLightx (GLenum light, GLenum pname, GLfixed param) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLightx ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglLightx, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( light ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLightx <-\n"); + } + +EXPORT_C void GL_APIENTRY glLightxv (GLenum light, GLenum pname, const GLfixed *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLightxv ->\n"); + TInt32 vectorsize = getLightVectorSize( pname ); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglLightxv, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( light ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLightxv <-\n"); + } + +EXPORT_C void GL_APIENTRY glLightModelf (GLenum pname, GLfloat param) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLightModelf ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglLightModelf, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLightModelf <-\n"); + } + +EXPORT_C void GL_APIENTRY glLightModelfv (GLenum pname, const GLfloat *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLightModelfv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_LIGHT_MODEL_AMBIENT ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglLightModelfv, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLightModelfv <-\n"); + } + +EXPORT_C void GL_APIENTRY glLightModelx (GLenum pname, GLfixed param) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLightModelx ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglLightModelx, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLightModelx <-\n"); + } + +EXPORT_C void GL_APIENTRY glLightModelxv (GLenum pname, const GLfixed *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLightModelxv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_LIGHT_MODEL_AMBIENT ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglLightModelxv, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLightModelxv <-\n"); + } + +EXPORT_C void GL_APIENTRY glLineWidth (GLfloat width) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLineWidth ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglLineWidth, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( width ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLineWidth <-\n"); + } + +EXPORT_C void GL_APIENTRY glLineWidthx (GLfixed width) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLineWidthx ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglLineWidthx, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( width ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLineWidthx <-\n"); + } + +EXPORT_C void GL_APIENTRY glLoadIdentity (void) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLoadIdentity ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglLoadIdentity, RemoteFunctionCallData::EOpRequest ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLoadIdentity <-\n"); + } + +EXPORT_C void GL_APIENTRY glLoadMatrixf (const GLfloat *m) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLoadMatrixf ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglLoadMatrixf, RemoteFunctionCallData::EOpRequest ); + call.AppendVector( m, 16 ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLoadMatrixf <-\n"); + } + +EXPORT_C void GL_APIENTRY glLoadMatrixx (const GLfixed *m) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLoadMatrixx ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglLoadMatrixx, RemoteFunctionCallData::EOpRequest ); + call.AppendVector( m, 16 ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLoadMatrixx <-\n"); + } + +EXPORT_C void GL_APIENTRY glLogicOp (GLenum opcode) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLogicOp ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglLogicOp, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( opcode ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLogicOp <-\n"); + } + +EXPORT_C void GL_APIENTRY glMaterialf (GLenum face, GLenum pname, GLfloat param) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMaterialf ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglMaterialf, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( face ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMaterialf <-\n"); + } + +EXPORT_C void GL_APIENTRY glMaterialfv (GLenum face, GLenum pname, const GLfloat *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMaterialfv ->\n"); + TInt32 vectorsize = getMaterialVectorSize( pname ); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglMaterialfv, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( face ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMaterialfv <-\n"); + } + +EXPORT_C void GL_APIENTRY glMaterialx (GLenum face, GLenum pname, GLfixed param) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMaterialx ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglMaterialx, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( face ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMaterialx <-\n"); + } + +EXPORT_C void GL_APIENTRY glMaterialxv (GLenum face, GLenum pname, const GLfixed *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMaterialxv ->\n"); + TInt32 vectorsize = getMaterialVectorSize( pname ); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglMaterialxv, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( face ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMaterialxv <-\n"); + } + +EXPORT_C void GL_APIENTRY glMatrixMode (GLenum mode) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMatrixMode ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglMatrixMode, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( mode ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMatrixMode <-\n"); + } + +EXPORT_C void GL_APIENTRY glMultMatrixf (const GLfloat *m) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMultMatrixf ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglMultMatrixf, RemoteFunctionCallData::EOpRequest ); + call.AppendVector( m, 16 ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMultMatrixf <-\n"); + } + +EXPORT_C void GL_APIENTRY glMultMatrixx (const GLfixed *m) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMultMatrixx ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglMultMatrixx, RemoteFunctionCallData::EOpRequest ); + call.AppendVector( m, 16 ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMultMatrixx <-\n"); + } + +EXPORT_C void GL_APIENTRY glMultiTexCoord4f (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMultiTexCoord4f ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglMultiTexCoord4f, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( s ); + call.AppendParam( t ); + call.AppendParam( r ); + call.AppendParam( q ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMultiTexCoord4f <-\n"); + } + +EXPORT_C void GL_APIENTRY glMultiTexCoord4x (GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMultiTexCoord4x ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglMultiTexCoord4x, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( s ); + call.AppendParam( t ); + call.AppendParam( r ); + call.AppendParam( q ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMultiTexCoord4x <-\n"); + } + +EXPORT_C void GL_APIENTRY glNormal3f (GLfloat nx, GLfloat ny, GLfloat nz) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glNormal3f ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglNormal3f, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( nx ); + call.AppendParam( ny ); + call.AppendParam( nz ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glNormal3f <-\n"); + } + +EXPORT_C void GL_APIENTRY glNormal3x (GLfixed nx, GLfixed ny, GLfixed nz) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glNormal3x ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglNormal3x, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( nx ); + call.AppendParam( ny ); + call.AppendParam( nz ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glNormal3x <-\n"); + } + +EXPORT_C void GL_APIENTRY glNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glNormalPointer ->\n"); + vertexArrays[NORMAL_ARRAY].size = 3; + vertexArrays[NORMAL_ARRAY].type = type; + vertexArrays[NORMAL_ARRAY].stride = stride; + vertexArrays[NORMAL_ARRAY].pointer = pointer; + OPENGL_TRACE(_APICALL_, "OpenGL client side: glNormalPointer <-\n"); + } + +EXPORT_C void GL_APIENTRY glOrthof (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glOrthof ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglOrthof, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( left ); + call.AppendParam( right ); + call.AppendParam( bottom ); + call.AppendParam( top ); + call.AppendParam( zNear ); + call.AppendParam( zFar ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glOrthof <-\n"); + } + +EXPORT_C void GL_APIENTRY glOrthox (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glOrthox ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglOrthox, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( left ); + call.AppendParam( right ); + call.AppendParam( bottom ); + call.AppendParam( top ); + call.AppendParam( zNear ); + call.AppendParam( zFar ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glOrthox <-\n"); + } + +EXPORT_C void GL_APIENTRY glPixelStorei (GLenum pname, GLint param) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPixelStorei ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglPixelStorei, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPixelStorei <-\n"); + } + +EXPORT_C void GL_APIENTRY glPointParameterf (GLenum pname, GLfloat param) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPointParameterf ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglPointParameterf, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPointParameterf <-\n"); + } + +EXPORT_C void GL_APIENTRY glPointParameterfv (GLenum pname, const GLfloat *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPointParameterfv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_POINT_DISTANCE_ATTENUATION ) + vectorsize = 3; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglPointParameterfv, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPointParameterfv <-\n"); + } + +EXPORT_C void GL_APIENTRY glPointParameterx (GLenum pname, GLfixed param) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPointParameterx ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglPointParameterx, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPointParameterx <-\n"); + } + +EXPORT_C void GL_APIENTRY glPointParameterxv (GLenum pname, const GLfixed *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPointParameterxv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_POINT_DISTANCE_ATTENUATION ) + vectorsize = 3; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglPointParameterxv, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPointParameterxv <-\n"); + } + +EXPORT_C void GL_APIENTRY glPointSize (GLfloat size) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPointSize ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglPointSize, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( size ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPointSize <-\n"); + } + +EXPORT_C void GL_APIENTRY glPointSizePointerOES (GLenum type, GLsizei stride, const GLvoid *pointer) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPointSizePointerOES ->\n"); + vertexArrays[POINT_SIZE_ARRAY].size = 1; + vertexArrays[POINT_SIZE_ARRAY].type = type; + vertexArrays[POINT_SIZE_ARRAY].stride = stride; + vertexArrays[POINT_SIZE_ARRAY].pointer = pointer; + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPointSizePointerOES <-\n"); + } + +EXPORT_C void GL_APIENTRY glPointSizex (GLfixed size) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPointSizex ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglPointSizex, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( size ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPointSizex <-\n"); + } + +EXPORT_C void GL_APIENTRY glPolygonOffset (GLfloat factor, GLfloat units) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPolygonOffset ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglPolygonOffset, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( factor ); + call.AppendParam( units ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPolygonOffset <-\n"); + } + +EXPORT_C void GL_APIENTRY glPolygonOffsetx (GLfixed factor, GLfixed units) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPolygonOffsetx ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglPolygonOffsetx, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( factor ); + call.AppendParam( units ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPolygonOffsetx <-\n"); + } + +EXPORT_C void GL_APIENTRY glPopMatrix (void) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPopMatrix ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglPopMatrix, RemoteFunctionCallData::EOpRequest ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPopMatrix <-\n"); + } + +EXPORT_C void GL_APIENTRY glPushMatrix (void) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPushMatrix ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglPushMatrix, RemoteFunctionCallData::EOpRequest ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glPushMatrix <-\n"); + } + +inline TInt32 getPixelSizeInBytes(GLenum format, GLenum type) + { + TInt32 size = 0; + if( format == GL_RGBA && type == GL_UNSIGNED_BYTE ) + { + size = 4; + } + else if( format == GL_RGB && type == GL_UNSIGNED_BYTE ) + { + size = 3; + } + else if( format == GL_RGBA && type == GL_UNSIGNED_SHORT_4_4_4_4 + || format == GL_RGBA && type == GL_UNSIGNED_SHORT_5_5_5_1 + || format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5 + || format == GL_LUMINANCE_ALPHA && type == GL_UNSIGNED_BYTE ) + { + size = 2; + } + return size; + } + +EXPORT_C void GL_APIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glReadPixels ->\n"); + TInt32 vectorsize = width * height * getPixelSizeInBytes( format, type ); + if(vectorsize < 0) // cannot serialize vector with size < 0 + { + SetError( GL_INVALID_VALUE ); + return; + } + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglReadPixels ); + call.AppendParam( x ); + call.AppendParam( y ); + call.AppendParam( width ); + call.AppendParam( height ); + call.AppendParam( format ); + call.AppendParam( type ); + call.AppendVector( pixels, vectorsize, RemoteFunctionCallData::EOut ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glReadPixels <-\n"); + } + +EXPORT_C void GL_APIENTRY glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glRotatef ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglRotatef, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( angle ); + call.AppendParam( x ); + call.AppendParam( y ); + call.AppendParam( z ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glRotatef <-\n"); + } + +EXPORT_C void GL_APIENTRY glRotatex (GLfixed angle, GLfixed x, GLfixed y, GLfixed z) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glRotatex ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglRotatex, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( angle ); + call.AppendParam( x ); + call.AppendParam( y ); + call.AppendParam( z ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glRotatex <-\n"); + } + +EXPORT_C void GL_APIENTRY glSampleCoverage (GLclampf value, GLboolean invert) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glSampleCoverage ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglSampleCoverage, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( value ); + call.AppendParam( invert ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glSampleCoverage <-\n"); + } + +EXPORT_C void GL_APIENTRY glSampleCoveragex (GLclampx value, GLboolean invert) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glSampleCoveragex ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglSampleCoveragex, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( value ); + call.AppendParam( invert ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glSampleCoveragex <-\n"); + } + +EXPORT_C void GL_APIENTRY glScalef (GLfloat x, GLfloat y, GLfloat z) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glScalef ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglScalef, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( x ); + call.AppendParam( y ); + call.AppendParam( z ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glScalef <-\n"); + } + +EXPORT_C void GL_APIENTRY glScalex (GLfixed x, GLfixed y, GLfixed z) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glScalex ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglScalex, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( x ); + call.AppendParam( y ); + call.AppendParam( z ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glScalex <-\n"); + } + +EXPORT_C void GL_APIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glScissor ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglScissor, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( x ); + call.AppendParam( y ); + call.AppendParam( width ); + call.AppendParam( height ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glScissor <-\n"); + } + +EXPORT_C void GL_APIENTRY glShadeModel (GLenum mode) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glShadeModel ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglShadeModel, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( mode ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glShadeModel <-\n"); + } + +EXPORT_C void GL_APIENTRY glStencilFunc (GLenum func, GLint ref, GLuint mask) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glStencilFunc ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglStencilFunc, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( func ); + call.AppendParam( ref ); + call.AppendParam( mask ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glStencilFunc <-\n"); + } + +EXPORT_C void GL_APIENTRY glStencilMask (GLuint mask) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glStencilMask ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglStencilMask, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( mask ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glStencilMask <-\n"); + } + +EXPORT_C void GL_APIENTRY glStencilOp (GLenum fail, GLenum zfail, GLenum zpass) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glStencilOp ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglStencilOp, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( fail ); + call.AppendParam( zfail ); + call.AppendParam( zpass ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glStencilOp <-\n"); + } + +EXPORT_C void GL_APIENTRY glTexCoordPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexCoordPointer ->\n"); + vertexArrays[TEX_COORD_ARRAY].size = size; + vertexArrays[TEX_COORD_ARRAY].type = type; + vertexArrays[TEX_COORD_ARRAY].stride = stride; + vertexArrays[TEX_COORD_ARRAY].pointer = pointer; + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexCoordPointer <-\n"); + } + +EXPORT_C void GL_APIENTRY glTexEnvf (GLenum target, GLenum pname, GLfloat param) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexEnvf ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglTexEnvf, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexEnvf <-\n"); + } + +EXPORT_C void GL_APIENTRY glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexEnvfv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_TEXTURE_ENV_COLOR ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglTexEnvfv, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexEnvfv <-\n"); + } + +EXPORT_C void GL_APIENTRY glTexEnvi (GLenum target, GLenum pname, GLint param) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexEnvi ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglTexEnvi, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexEnvi <-\n"); + } + +EXPORT_C void GL_APIENTRY glTexEnviv (GLenum target, GLenum pname, const GLint *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexEnviv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_TEXTURE_ENV_COLOR ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglTexEnviv, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexEnviv <-\n"); + } + +EXPORT_C void GL_APIENTRY glTexEnvx (GLenum target, GLenum pname, GLfixed param) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexEnvx ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglTexEnvx, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexEnvx <-\n"); + } + +EXPORT_C void GL_APIENTRY glTexEnvxv (GLenum target, GLenum pname, const GLfixed *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexEnvxv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_TEXTURE_ENV_COLOR ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglTexEnvxv, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexEnvxv <-\n"); + } + +EXPORT_C void GL_APIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexImage2D ->\n"); + TInt32 vectorsize = width * height * getPixelSizeInBytes( format, type ); + if(vectorsize < 0) // cannot serialize vector with size < 0 + { + SetError( GL_INVALID_VALUE ); + return; + } + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglTexImage2D, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( level ); + call.AppendParam( internalformat ); + call.AppendParam( width ); + call.AppendParam( height ); + call.AppendParam( border ); + call.AppendParam( format ); + call.AppendParam( type ); + call.AppendVector( pixels, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexImage2D <-\n"); + } + +EXPORT_C void GL_APIENTRY glTexParameterf (GLenum target, GLenum pname, GLfloat param) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexParameterf ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglTexParameterf, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexParameterf <-\n"); + } + +EXPORT_C void GL_APIENTRY glTexParameterfv (GLenum target, GLenum pname, const GLfloat *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexParameterfv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_TEXTURE_CROP_RECT_OES ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglTexParameterfv, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexParameterfv <-\n"); + } + +EXPORT_C void GL_APIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexParameteri ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglTexParameteri, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexParameteri <-\n"); + } + +EXPORT_C void GL_APIENTRY glTexParameteriv (GLenum target, GLenum pname, const GLint *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexParameteriv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_TEXTURE_CROP_RECT_OES ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglTexParameteriv, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexParameteriv <-\n"); + } + +EXPORT_C void GL_APIENTRY glTexParameterx (GLenum target, GLenum pname, GLfixed param) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexParameterx ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglTexParameterx, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( pname ); + call.AppendParam( param ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexParameterx <-\n"); + } + +EXPORT_C void GL_APIENTRY glTexParameterxv (GLenum target, GLenum pname, const GLfixed *params) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexParameterxv ->\n"); + TInt32 vectorsize = 1; + if( pname == GL_TEXTURE_CROP_RECT_OES ) + vectorsize = 4; + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglTexParameterxv, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( pname ); + call.AppendVector( params, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexParameterxv <-\n"); + } + +EXPORT_C void GL_APIENTRY glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexSubImage2D ->\n"); + TInt32 vectorsize = width * height * getPixelSizeInBytes( format, type ); + if(vectorsize < 0) // cannot serialize vector with size < 0 + { + SetError( GL_INVALID_VALUE ); + return; + } + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglTexSubImage2D, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( target ); + call.AppendParam( level ); + call.AppendParam( xoffset ); + call.AppendParam( yoffset ); + call.AppendParam( width ); + call.AppendParam( height ); + call.AppendParam( format ); + call.AppendParam( type ); + call.AppendVector( pixels, vectorsize ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTexSubImage2D <-\n"); + } + +EXPORT_C void GL_APIENTRY glTranslatef (GLfloat x, GLfloat y, GLfloat z) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTranslatef ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglTranslatef, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( x ); + call.AppendParam( y ); + call.AppendParam( z ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTranslatef <-\n"); + } + +EXPORT_C void GL_APIENTRY glTranslatex (GLfixed x, GLfixed y, GLfixed z) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTranslatex ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglTranslatex, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( x ); + call.AppendParam( y ); + call.AppendParam( z ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glTranslatex <-\n"); + } + +EXPORT_C void GL_APIENTRY glVertexPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glVertexPointer ->\n"); + vertexArrays[VERTEX_ARRAY].size = size; + vertexArrays[VERTEX_ARRAY].type = type; + vertexArrays[VERTEX_ARRAY].stride = stride; + vertexArrays[VERTEX_ARRAY].pointer = pointer; + OPENGL_TRACE(_APICALL_, "OpenGL client side: glVertexPointer <-\n"); + } + +EXPORT_C void GL_APIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glViewport ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglViewport, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( x ); + call.AppendParam( y ); + call.AppendParam( width ); + call.AppendParam( height ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glViewport <-\n"); + } + +// Guest Open GL ES extension export support for eglGetProcAddress +typedef struct + { + const char* extnName; // procedure or extension name + ExtensionProcPointer procAddr; + } TGlExtnInfo; + +// GL ES extension functions +static const TGlExtnInfo glesProcedures[] = + { // all the functions below the "from glextplatform.h" comment + { "glCurrentPaletteMatrixOES", (ExtensionProcPointer)glCurrentPaletteMatrixOES }, + { "glDrawTexfOES", (ExtensionProcPointer)glDrawTexfOES }, + { "glDrawTexfvOES", (ExtensionProcPointer)glDrawTexfvOES }, + { "glDrawTexiOES", (ExtensionProcPointer)glDrawTexiOES }, + { "glDrawTexivOES", (ExtensionProcPointer)glDrawTexivOES }, + { "glDrawTexsOES", (ExtensionProcPointer)glDrawTexsOES }, + { "glDrawTexsvOES", (ExtensionProcPointer)glDrawTexsvOES }, + { "glDrawTexxOES", (ExtensionProcPointer)glDrawTexxOES }, + { "glDrawTexxvOES", (ExtensionProcPointer)glDrawTexxvOES }, + { "glLoadPaletteFromModelViewMatrixOES", (ExtensionProcPointer)glLoadPaletteFromModelViewMatrixOES }, + { "glMatrixIndexPointerOES", (ExtensionProcPointer)glMatrixIndexPointerOES }, + { "glQueryMatrixxOES", (ExtensionProcPointer)glQueryMatrixxOES }, + { "glWeightPointerOES", (ExtensionProcPointer)glWeightPointerOES }, + }; + +const TInt glesProcCount = sizeof(glesProcedures) / sizeof(TGlExtnInfo); + + +TGles11ApiForEgl::TGles11ApiForEgl() + { + // DLL has loaded - publish vtable for MGles11ApiForEgl + CVghwUtils::SetGles11ApiForEgl(this); + } + + +TGles11ApiForEgl::~TGles11ApiForEgl() + { + // DLL is unloading - unpublish vtable for MGles11ApiForEgl + CVghwUtils::SetGles11ApiForEgl(NULL); + } + + +ExtensionProcPointer TGles11ApiForEgl::guestGetGles11ProcAddress (const char *aProcName) + { + // exhaustive search, for now. (We should consider a sorted list if the number of functions grows.) + for (TInt idx = 0; idx < glesProcCount; idx++) + { + if (!strcmp(aProcName, glesProcedures[idx].extnName)) + return glesProcedures[idx].procAddr; + } + return NULL; + } + + +EXPORT_C void GL_APIENTRY glCurrentPaletteMatrixOES (GLuint matrixpaletteindex) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glCurrentPaletteMatrixOES ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglCurrentPaletteMatrixOES, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( matrixpaletteindex ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glCurrentPaletteMatrixOES <-\n"); + } + +EXPORT_C void GL_APIENTRY glDrawTexfOES (GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) __SOFTFP + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawTexfOES ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDrawTexfOES, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( x ); + call.AppendParam( y ); + call.AppendParam( width ); + call.AppendParam( height ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawTexfOES <-\n"); + } + +EXPORT_C void GL_APIENTRY glDrawTexfvOES (const GLfloat *coords) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawTexfvOES ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDrawTexfvOES, RemoteFunctionCallData::EOpRequest ); + call.AppendVector( coords, 5 ); // oglFast.c + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawTexfvOES <-\n"); + } + +EXPORT_C void GL_APIENTRY glDrawTexiOES (GLint x, GLint y, GLint z, GLint width, GLint height) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawTexiOES ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDrawTexiOES, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( x ); + call.AppendParam( y ); + call.AppendParam( width ); + call.AppendParam( height ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawTexiOES <-\n"); + } + +EXPORT_C void GL_APIENTRY glDrawTexivOES (const GLint *coords) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawTexivOES ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDrawTexivOES, RemoteFunctionCallData::EOpRequest ); + call.AppendVector( coords, 5 ); // oglFast.c + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawTexivOES <-\n"); + } + +EXPORT_C void GL_APIENTRY glDrawTexsOES (GLshort x, GLshort y, GLshort z, GLshort width, GLshort height) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawTexsOES ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDrawTexsOES, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( x ); + call.AppendParam( y ); + call.AppendParam( width ); + call.AppendParam( height ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawTexsOES <-\n"); + } + +EXPORT_C void GL_APIENTRY glDrawTexsvOES (const GLshort *coords) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawTexsvOES ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDrawTexsvOES, RemoteFunctionCallData::EOpRequest ); + call.AppendVector( coords, 5 ); // oglFast.c + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawTexsvOES <-\n"); + } + +EXPORT_C void GL_APIENTRY glDrawTexxOES (GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawTexxOES ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDrawTexxOES, RemoteFunctionCallData::EOpRequest ); + call.AppendParam( x ); + call.AppendParam( y ); + call.AppendParam( width ); + call.AppendParam( height ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawTexxOES <-\n"); + } + +EXPORT_C void GL_APIENTRY glDrawTexxvOES (const GLfixed *coords) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawTexxvOES ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglDrawTexxvOES, RemoteFunctionCallData::EOpRequest ); + call.AppendVector( coords, 5 ); // oglFast.c + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glDrawTexxvOES <-\n"); + } + +EXPORT_C void GL_APIENTRY glLoadPaletteFromModelViewMatrixOES (void) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLoadPaletteFromModelViewMatrixOES ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglLoadPaletteFromModelViewMatrixOES, RemoteFunctionCallData::EOpRequest ); + ExecuteCommand(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glLoadPaletteFromModelViewMatrixOES <-\n"); + } + +EXPORT_C void GL_APIENTRY glMatrixIndexPointerOES (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMatrixIndexPointerOES ->\n"); + vertexArrays[MATRIX_INDEX_ARRAY].size = size; + vertexArrays[MATRIX_INDEX_ARRAY].type = type; + vertexArrays[MATRIX_INDEX_ARRAY].stride = stride; + vertexArrays[MATRIX_INDEX_ARRAY].pointer = pointer; + OPENGL_TRACE(_APICALL_, "OpenGL client side: glMatrixIndexPointerOES <-\n"); + } + +GLbitfield GL_APIENTRY glQueryMatrixxOES (GLfixed mantissa[16], GLint exponent[16]) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glQueryMatrixxOES ->\n"); + RemoteFunctionCallData rfcData; + OpenGlES11RFC call( rfcData ); + call.Init( OpenGlES11RFC::EglQueryMatrixxOES ); + call.AppendVector( mantissa, 16, RemoteFunctionCallData::EOut ); + call.AppendVector( exponent, 16, RemoteFunctionCallData::EOut ); + GLbitfield result = (GLbitfield)ExecuteFunction(call); + OPENGL_TRACE(_APICALL_, "OpenGL client side: glQueryMatrixxOES <-\n"); + return result; + } + +EXPORT_C void GL_APIENTRY glWeightPointerOES (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) + { + OPENGL_TRACE(_APICALL_, "OpenGL client side: glWeightPointerOES ->\n"); + vertexArrays[WEIGHT_ARRAY].size = size; + vertexArrays[WEIGHT_ARRAY].type = type; + vertexArrays[WEIGHT_ARRAY].stride = stride; + vertexArrays[WEIGHT_ARRAY].pointer = pointer; + OPENGL_TRACE(_APICALL_, "OpenGL client side: glWeightPointerOES <-\n"); + } + +} /* extern "C" */