// 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");