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

     2  *

     3  * Permission is hereby granted, free of charge, to any person obtaining a

     4  * copy of this software and /or associated documentation files

     5  * (the "Materials "), to deal in the Materials without restriction,

     6  * including without limitation the rights to use, copy, modify, merge,

     7  * publish, distribute, sublicense, and/or sell copies of the Materials,

     8  * and to permit persons to whom the Materials are furnished to do so,

     9  * subject to the following conditions:

    10  *

    11  * The above copyright notice and this permission notice shall be included

    12  * in all copies or substantial portions of the Materials.

    13  *

    14  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    15  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    16  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

    17  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

    18  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

    19  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR

    20  * THE USE OR OTHER DEALINGS IN THE MATERIALS.

    21  *

    22  * Initial Contributors:

    23  * Nokia Corporation - initial contribution.

    24  *

    25  * Contributors:

    26  *

    27  * Description:

    28  *

    29  */

    30 

    31 #include <GLES/gl.h>

    32 #include <GLES/glplatform.h>

    33 #include <iostream>

    34 #include "GLESDesktopGL.h"

    35 #include "glesInternal.h"

    36 #include "EGLInterface.h"

    37 #include "GLESContext.h"

    38 #include "GLESArray.h"

    39 #include "GLESTexture.h"

    40 #include "glesGet.h"

    41 

    42 // exit()

    43 #include <stdlib.h>

    44 // memcpy

    45 #include <string.h>

    46 

    47 #ifdef __cplusplus

    48 extern "C" {

    49 #endif

    50 

    51 /* Available only in Common profile */

    52 GL_API void GL_APIENTRY glAlphaFunc (GLenum func, GLclampf ref)

    53 {

    54     GLES_ENTER();

    55     ctx->DGL().glAlphaFunc (func, ref);

    56     GLES_LEAVE();

    57 }

    58 GL_API void GL_APIENTRY glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)

    59 {

    60     GLES_ENTER();

    61     ctx->DGL().glClearColor (red, green, blue, alpha);

    62     GLES_LEAVE();

    63 }

    64 GL_API void GL_APIENTRY glClearDepthf (GLclampf depth)

    65 {

    66     GLES_ENTER();

    67     ctx->DGL().glClearDepth (depth);

    68     GLES_LEAVE();

    69 }

    70 GL_API void GL_APIENTRY glClipPlanef (GLenum plane, const GLfloat *equation)

    71 {

    72     GLES_ENTER();

    73     GLES_ERROR_IF(plane < GL_CLIP_PLANE0 || plane >= GL_CLIP_PLANE0 + ctx->MaxClipPlanes(), GL_INVALID_ENUM);

    74     GLdouble dequation[4];

    75     for(int i = 0; i < 4; i++)

    76     {

    77         dequation[i] = static_cast<GLdouble>(equation[i]);

    78     }

    79     ctx->DGL().glClipPlane (plane, dequation);

    80     GLES_LEAVE();

    81 }

    82 GL_API void GL_APIENTRY glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)

    83 {

    84     GLES_ENTER();

    85     ctx->DGL().glColor4f (red, green, blue, alpha);

    86     GLES_LEAVE();

    87 }

    88 GL_API void GL_APIENTRY glDepthRangef (GLclampf zNear, GLclampf zFar)

    89 {

    90     GLES_ENTER();

    91     ctx->DGL().glDepthRange(zNear, zFar);

    92     GLES_LEAVE();

    93 }

    94 bool isValidSingleValuedFogParamEnum(GLenum pname)

    95 {

    96     switch(pname)

    97     {

    98     case GL_FOG_MODE:

    99     case GL_FOG_DENSITY:

   100     case GL_FOG_START:

   101     case GL_FOG_END:

   102         return true;

   103     default:

   104         return false;

   105     }

   106 }

   107 bool isValidFogParamEnum(GLenum pname)

   108 {

   109     return isValidSingleValuedFogParamEnum(pname) || pname == GL_FOG_COLOR;

   110 }

   111 GL_API void GL_APIENTRY glFogf (GLenum pname, GLfloat param)

   112 {

   113     GLES_ENTER();

   114     GLES_ERROR_IF(!isValidFogParamEnum(pname), GL_INVALID_ENUM);

   115     ctx->DGL().glFogf (pname, param);

   116     GLES_LEAVE();

   117 }

   118 GL_API void GL_APIENTRY glFogfv (GLenum pname, const GLfloat *params)

   119 {

   120     GLES_ENTER();

   121     GLES_ERROR_IF(!isValidFogParamEnum(pname), GL_INVALID_ENUM);

   122     ctx->DGL().glFogfv (pname, params);

   123     GLES_LEAVE();

   124 }

   125 GL_API void GL_APIENTRY glFrustumf (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)

   126 {

   127     GLES_ENTER();

   128     ctx->DGL().glFrustum (left, right, bottom, top, zNear, zFar);

   129     GLES_LEAVE();

   130 }

   131 GL_API void GL_APIENTRY glGetClipPlanef (GLenum pname, GLfloat eqn[4])

   132 {

   133     GLES_ENTER();

   134     GLdouble deqn[4];

   135     ctx->DGL().glGetClipPlane (pname, deqn);

   136     for(int i = 0; i < 4; i++)

   137     {

   138         eqn[i] = static_cast<GLfloat>(deqn[i]);

   139     }

   140     GLES_LEAVE();

   141 }

   142 GL_API void GL_APIENTRY glGetFloatv (GLenum pname, GLfloat *params)

   143 {

   144     GLES_ENTER();

   145     if(!glesGetParameter(*ctx, ctx->DGL(), pname, GLES_TYPE_FLOAT, params))

   146     {

   147         GLES_ERROR(GL_INVALID_ENUM);

   148     }

   149     GLES_LEAVE();

   150 }

   151 GL_API void GL_APIENTRY glGetLightfv (GLenum light, GLenum pname, GLfloat *params)

   152 {

   153     GLES_ENTER();

   154     ctx->DGL().glGetLightfv (light, pname, params);

   155     GLES_LEAVE();

   156 }

   157 GL_API void GL_APIENTRY glGetMaterialfv (GLenum face, GLenum pname, GLfloat *params)

   158 {

   159     GLES_ENTER();

   160     ctx->DGL().glGetMaterialfv (face, pname, params);

   161     GLES_LEAVE();

   162 }

   163 bool isValidTexEnvTargetEnum(GLenum target)

   164 {

   165     switch(target)

   166     {

   167     case GL_POINT_SPRITE_OES:

   168     case GL_TEXTURE_ENV:

   169         return true;

   170     default:

   171         return false;

   172     }

   173 }

   174 bool isValidSingleValuedTexEnvParamEnum(GLenum pname)

   175 {

   176     switch(pname)

   177     {

   178     case GL_TEXTURE_ENV_MODE:

   179     case GL_COORD_REPLACE_OES:

   180     case GL_COMBINE_RGB:

   181     case GL_COMBINE_ALPHA:

   182     case GL_SRC0_RGB:

   183     case GL_SRC1_RGB:

   184     case GL_SRC2_RGB:

   185     case GL_SRC0_ALPHA:

   186     case GL_SRC1_ALPHA:

   187     case GL_SRC2_ALPHA:

   188     case GL_OPERAND0_RGB:

   189     case GL_OPERAND1_RGB:

   190     case GL_OPERAND2_RGB:

   191     case GL_OPERAND0_ALPHA:

   192     case GL_OPERAND1_ALPHA:

   193     case GL_OPERAND2_ALPHA:

   194     case GL_RGB_SCALE:

   195     case GL_ALPHA_SCALE:

   196         return true;

   197     default:

   198         return false;

   199     }

   200 }

   201 bool isValidTexEnvParamEnum(GLenum pname)

   202 {

   203     return isValidSingleValuedTexEnvParamEnum(pname) || pname == GL_TEXTURE_ENV_COLOR;

   204 }

   205 GL_API void GL_APIENTRY glGetTexEnvfv (GLenum env, GLenum pname, GLfloat *params)

   206 {

   207     GLES_ENTER();

   208     GLES_ERROR_IF(!isValidTexEnvTargetEnum(env), GL_INVALID_ENUM);

   209     GLES_ERROR_IF(!isValidTexEnvParamEnum(pname), GL_INVALID_ENUM);

   210     env = env == GL_POINT_SPRITE_OES ? GL_POINT_SPRITE : env;

   211     pname = pname == GL_COORD_REPLACE_OES ? GL_COORD_REPLACE : pname;

   212     ctx->DGL().glGetTexEnvfv (env, pname, params);

   213     GLES_LEAVE();

   214 }

   215 bool isValidTexParamEnum(GLenum pname)

   216 {

   217     switch(pname)

   218     {

   219     case GL_TEXTURE_MIN_FILTER:

   220     case GL_TEXTURE_MAG_FILTER:

   221     case GL_TEXTURE_WRAP_S:

   222     case GL_TEXTURE_WRAP_T:

   223     case GL_GENERATE_MIPMAP:

   224         return true;

   225     default:

   226         return false;

   227     }

   228 }

   229 GL_API void GL_APIENTRY glGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params)

   230 {

   231     GLES_ENTER();

   232     GLES_ERROR_IF(!isValidTexParamEnum(pname), GL_INVALID_ENUM);

   233     ctx->DGL().glGetTexParameterfv (target, pname, params);

   234     GLES_LEAVE();

   235 }

   236 bool isValidLightModelParamEnum(GLenum pname)

   237 {

   238     switch(pname)

   239     {

   240     case GL_LIGHT_MODEL_AMBIENT:

   241     case GL_LIGHT_MODEL_TWO_SIDE:

   242         return true;

   243     default:

   244         return false;

   245     }

   246 }

   247 GL_API void GL_APIENTRY glLightModelf (GLenum pname, GLfloat param)

   248 {

   249     GLES_ENTER();

   250     GLES_ERROR_IF(!isValidLightModelParamEnum(pname), GL_INVALID_ENUM);

   251     ctx->DGL().glLightModelf (pname, param);

   252     GLES_LEAVE();

   253 }

   254 GL_API void GL_APIENTRY glLightModelfv (GLenum pname, const GLfloat *params)

   255 {

   256     GLES_ENTER();

   257     GLES_ERROR_IF(!isValidLightModelParamEnum(pname), GL_INVALID_ENUM);

   258     ctx->DGL().glLightModelfv (pname, params);

   259     GLES_LEAVE();

   260 }

   261 GL_API void GL_APIENTRY glLightf (GLenum light, GLenum pname, GLfloat param)

   262 {

   263     GLES_ENTER();

   264     ctx->DGL().glLightf (light, pname, param);

   265     GLES_LEAVE();

   266 }

   267 GL_API void GL_APIENTRY glLightfv (GLenum light, GLenum pname, const GLfloat *params)

   268 {

   269     GLES_ENTER();

   270     ctx->DGL().glLightfv (light, pname, params);

   271     GLES_LEAVE();

   272 }

   273 GL_API void GL_APIENTRY glLineWidth (GLfloat width)

   274 {

   275     GLES_ENTER();

   276     ctx->DGL().glLineWidth (width);

   277     GLES_LEAVE();

   278 }

   279 GL_API void GL_APIENTRY glLoadMatrixf (const GLfloat *m)

   280 {

   281     GLES_ENTER();

   282     ctx->DGL().glLoadMatrixf (m);

   283     GLES_LEAVE();

   284 }

   285 GL_API void GL_APIENTRY glMaterialf (GLenum face, GLenum pname, GLfloat param)

   286 {

   287     GLES_ENTER();

   288     ctx->DGL().glMaterialf (face, pname, param);

   289     GLES_LEAVE();

   290 }

   291 bool isValidSingleValuedMaterialParamEnum(GLenum pname)

   292 {

   293     return pname == GL_SHININESS;

   294 }

   295 bool isValidMaterialParamEnum(GLenum pname)

   296 {

   297     if(isValidSingleValuedMaterialParamEnum(pname))

   298     {

   299         return true;

   300     }

   301     else

   302     {

   303         switch(pname)

   304         {

   305         case GL_AMBIENT:

   306         case GL_DIFFUSE:

   307         case GL_AMBIENT_AND_DIFFUSE:

   308         case GL_SPECULAR:

   309         case GL_EMISSION:

   310         case GL_SHININESS:

   311             return true;

   312         default:

   313             return false;

   314         }

   315     }

   316 }

   317 GL_API void GL_APIENTRY glMaterialfv (GLenum face, GLenum pname, const GLfloat *params)

   318 {

   319     GLES_ENTER();

   320     GLES_ERROR_IF(!isValidMaterialParamEnum(pname), GL_INVALID_ENUM);

   321     ctx->DGL().glMaterialfv (face, pname, params);

   322     GLES_LEAVE();

   323 }

   324 GL_API void GL_APIENTRY glMultMatrixf (const GLfloat *m)

   325 {

   326     GLES_ENTER();

   327     ctx->DGL().glMultMatrixf(m);

   328     GLES_LEAVE();

   329 }

   330 bool isValidTextureTargetEnum(GLenum target, unsigned int maxTextureUnits)

   331 {

   332     return target >= GL_TEXTURE0 && target < GL_TEXTURE0 + maxTextureUnits;

   333 }

   334 GL_API void GL_APIENTRY glMultiTexCoord4f (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)

   335 {

   336     GLES_ENTER();

   337     GLES_ERROR_IF(!isValidTextureTargetEnum(target, ctx->MaxTextureUnits()), GL_INVALID_ENUM);

   338     ctx->DGL().glMultiTexCoord4f(target, s, t, r, q);

   339     GLES_LEAVE();

   340 }

   341 GL_API void GL_APIENTRY glNormal3f (GLfloat nx, GLfloat ny, GLfloat nz)

   342 {

   343     GLES_ENTER();

   344     ctx->DGL().glNormal3f(nx, ny, nz);

   345     GLES_LEAVE();

   346 }

   347 GL_API void GL_APIENTRY glOrthof (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)

   348 {

   349     GLES_ENTER();

   350     ctx->DGL().glOrtho(left, right, bottom, top, zNear, zFar);

   351     GLES_LEAVE();

   352 }

   353 GL_API void GL_APIENTRY glPointParameterf (GLenum pname, GLfloat param)

   354 {

   355     GLES_ENTER();

   356     ctx->DGL().glPointParameterf (pname, param);

   357     GLES_LEAVE();

   358 }

   359 GL_API void GL_APIENTRY glPointParameterfv (GLenum pname, const GLfloat *params)

   360 {

   361     GLES_ENTER();

   362     ctx->DGL().glPointParameterfv (pname, params);

   363     GLES_LEAVE();

   364 }

   365 GL_API void GL_APIENTRY glPointSize (GLfloat size)

   366 {

   367     GLES_ENTER();

   368     ctx->DGL().glPointSize (size);

   369     GLES_LEAVE();

   370 }

   371 GL_API void GL_APIENTRY glPolygonOffset (GLfloat factor, GLfloat units)

   372 {

   373     GLES_ENTER();

   374     ctx->DGL().glPolygonOffset (factor, units);

   375     GLES_LEAVE();

   376 }

   377 GL_API void GL_APIENTRY glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z)

   378 {

   379     GLES_ENTER();

   380     ctx->DGL().glRotatef (angle, x, y, z);

   381     GLES_LEAVE();

   382 }

   383 GL_API void GL_APIENTRY glScalef (GLfloat x, GLfloat y, GLfloat z)

   384 {

   385     GLES_ENTER();

   386     ctx->DGL().glScalef (x, y, z);

   387     GLES_LEAVE();

   388 }

   389 GL_API void GL_APIENTRY glTexEnvf (GLenum target, GLenum pname, GLfloat param)

   390 {

   391     GLES_ENTER();

   392     GLES_ERROR_IF(!isValidTexEnvTargetEnum(target), GL_INVALID_ENUM);

   393     GLES_ERROR_IF(!isValidTexEnvParamEnum(pname), GL_INVALID_ENUM);

   394     target = target == GL_POINT_SPRITE_OES ? GL_POINT_SPRITE : target;

   395     pname = pname == GL_COORD_REPLACE_OES ? GL_COORD_REPLACE : pname;

   396     ctx->DGL().glTexEnvf (target, pname, param);

   397     GLES_LEAVE();

   398 }

   399 GL_API void GL_APIENTRY glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params)

   400 {

   401     GLES_ENTER();

   402     GLES_ERROR_IF(!isValidTexEnvTargetEnum(target), GL_INVALID_ENUM);

   403     GLES_ERROR_IF(!isValidTexEnvParamEnum(pname), GL_INVALID_ENUM);

   404     target = target == GL_POINT_SPRITE_OES ? GL_POINT_SPRITE : target;

   405     pname = pname == GL_COORD_REPLACE_OES ? GL_COORD_REPLACE : pname;

   406     ctx->DGL().glTexEnvfv (target, pname, params);

   407     GLES_LEAVE();

   408 }

   409 GL_API void GL_APIENTRY glTexParameterf (GLenum target, GLenum pname, GLfloat param)

   410 {

   411     GLES_ENTER();

   412     GLES_ERROR_IF(target != GL_TEXTURE_2D, GL_INVALID_ENUM);

   413     GLES_ERROR_IF(!isValidTexParamEnum(pname), GL_INVALID_ENUM);

   414     pname = pname == GL_COORD_REPLACE_OES ? GL_COORD_REPLACE : pname;

   415     ctx->DGL().glTexParameterf (target, pname, param);

   416     GLES_LEAVE();

   417 }

   418 GL_API void GL_APIENTRY glTexParameterfv (GLenum target, GLenum pname, const GLfloat *params)

   419 {

   420     GLES_ENTER();

   421     GLES_ERROR_IF(target != GL_TEXTURE_2D, GL_INVALID_ENUM);

   422     GLES_ERROR_IF(!isValidTexParamEnum(pname), GL_INVALID_ENUM);

   423     target = target == GL_POINT_SPRITE_OES ? GL_POINT_SPRITE : target;

   424     pname = pname == GL_COORD_REPLACE_OES ? GL_COORD_REPLACE : pname;

   425     ctx->DGL().glTexParameterfv (target, pname, params);

   426     GLES_LEAVE();

   427 }

   428 GL_API void GL_APIENTRY glTranslatef (GLfloat x, GLfloat y, GLfloat z)

   429 {

   430     GLES_ENTER();

   431     ctx->DGL().glTranslatef (x, y, z);

   432     GLES_LEAVE();

   433 }

   434 

   435 /* Available in both Common and Common-Lite profiles */

   436 GL_API void GL_APIENTRY glActiveTexture (GLenum texture)

   437 {

   438     GLES_ENTER();

   439     GLES_ERROR_IF(!isValidTextureTargetEnum(texture, ctx->MaxTextureUnits()), GL_INVALID_ENUM);

   440     ctx->DGL().glActiveTexture (texture);

   441     GLES_LEAVE();

   442 }

   443 GL_API void GL_APIENTRY glAlphaFuncx (GLenum func, GLclampx ref)

   444 {

   445     GLES_ENTER();

   446     ctx->DGL().glAlphaFunc(func, X_TO_F(ref));

   447     GLES_LEAVE();

   448 }

   449 bool isValidBufferTarget(GLenum target)

   450 {

   451     switch(target)

   452     {

   453     case GL_ARRAY_BUFFER:

   454     case GL_ELEMENT_ARRAY_BUFFER:

   455         return true;

   456     default:

   457         return false;

   458     }

   459 }

   460 GL_API void GL_APIENTRY glBindBuffer (GLenum target, GLuint buffer)

   461 {

   462     GLES_ENTER();

   463     GLES_ERROR_IF(!isValidBufferTarget(target), GL_INVALID_ENUM);

   464     switch(target)

   465     {

   466     case GL_ARRAY_BUFFER:

   467         if(!ctx->BindArrayBuffer(buffer))

   468         {

   469             GLES_ERROR(GL_OUT_OF_MEMORY);

   470         }

   471         break;

   472     case GL_ELEMENT_ARRAY_BUFFER:

   473         if(!ctx->BindElementArrayBuffer(buffer))

   474         {

   475             GLES_ERROR(GL_OUT_OF_MEMORY);

   476         }

   477         break;

   478     default:

   479         GLES_ERROR(GL_INVALID_ENUM);

   480     }

   481     GLES_LEAVE();

   482 }

   483 GL_API void GL_APIENTRY glBindTexture (GLenum target, GLuint texture)

   484 {

   485     GLES_ENTER();

   486     GLES_ERROR_IF(target != GL_TEXTURE_2D, GL_INVALID_ENUM);

   487     ctx->GetHostError();

   488     ctx->DGL().glBindTexture (target, texture);

   489     if(ctx->GetHostError() == GL_NO_ERROR)

   490     {

   491         ctx->BindTexture(texture);

   492     }

   493     GLES_LEAVE();

   494 }

   495 bool isValidSrcBlendFuncEnum(GLenum func)

   496 {

   497     switch(func)

   498     {

   499     case GL_ZERO:

   500     case GL_ONE:

   501     case GL_DST_COLOR:

   502     case GL_ONE_MINUS_DST_COLOR:

   503     case GL_SRC_ALPHA:

   504     case GL_ONE_MINUS_SRC_ALPHA:

   505     case GL_DST_ALPHA:

   506     case GL_ONE_MINUS_DST_ALPHA:

   507     case GL_SRC_ALPHA_SATURATE:

   508         return true;

   509     default:

   510         return false;

   511     }

   512 }

   513 bool isValidDstBlendFuncEnum(GLenum func)

   514 {

   515     switch(func)

   516     {

   517     case GL_ZERO:

   518     case GL_ONE:

   519     case GL_SRC_COLOR:

   520     case GL_ONE_MINUS_SRC_COLOR:

   521     case GL_SRC_ALPHA:

   522     case GL_ONE_MINUS_SRC_ALPHA:

   523     case GL_DST_ALPHA:

   524     case GL_ONE_MINUS_DST_ALPHA:

   525         return true;

   526     default:

   527         return false;

   528     }

   529 }

   530 GL_API void GL_APIENTRY glBlendFunc (GLenum sfactor, GLenum dfactor)

   531 {

   532     GLES_ENTER();

   533     GLES_ERROR_IF(!isValidSrcBlendFuncEnum(sfactor), GL_INVALID_ENUM);

   534     GLES_ERROR_IF(!isValidDstBlendFuncEnum(dfactor), GL_INVALID_ENUM);

   535     ctx->DGL().glBlendFunc (sfactor, dfactor);

   536     GLES_LEAVE();

   537 }

   538 GL_API void GL_APIENTRY glBufferData (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)

   539 {

   540     GLES_ENTER();

   541     GLES_ERROR_IF(size < 0, GL_INVALID_VALUE);

   542     GLES_ERROR_IF(usage != GL_STATIC_DRAW && usage != GL_DYNAMIC_DRAW, GL_INVALID_ENUM);

   543 

   544     GLESBuffer* buffer;

   545     switch(target)

   546     {

   547     case GL_ARRAY_BUFFER:

   548         GLES_ERROR_IF(ctx->ArrayBufferBinding() == 0, GL_INVALID_OPERATION);

   549         buffer = ctx->ArrayBuffer();

   550         break;

   551     case GL_ELEMENT_ARRAY_BUFFER:

   552         GLES_ERROR_IF(ctx->ElementArrayBufferBinding() == 0, GL_INVALID_OPERATION);

   553         buffer = ctx->ElementArrayBuffer();

   554         break;

   555     default:

   556         GLES_ERROR(GL_INVALID_ENUM);

   557     }

   558     GLES_ASSERT(buffer);

   559 

   560     delete[] buffer->data;

   561     buffer->data = GLES_NEW char[size];

   562     if(buffer->data == NULL)

   563     {

   564         GLES_ERROR(GL_OUT_OF_MEMORY);

   565     }

   566 

   567     if(data != NULL)

   568     {

   569         memcpy(buffer->data, data, size);

   570     }

   571 

   572     buffer->size = size;

   573     buffer->usage = usage;

   574 

   575     GLES_LEAVE();

   576 }

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

   578 {

   579     GLES_ENTER();

   580     GLES_ERROR_IF(offset < 0, GL_INVALID_VALUE);

   581     GLES_ERROR_IF(size < 0, GL_INVALID_VALUE);

   582 

   583     GLESBuffer* buffer;

   584     switch(target)

   585     {

   586     case GL_ARRAY_BUFFER:

   587         GLES_ERROR_IF(ctx->ArrayBufferBinding() == 0, GL_INVALID_OPERATION);

   588         buffer = ctx->ArrayBuffer();

   589         break;

   590     case GL_ELEMENT_ARRAY_BUFFER:

   591         GLES_ERROR_IF(ctx->ElementArrayBufferBinding() == 0, GL_INVALID_OPERATION);

   592         buffer = ctx->ElementArrayBuffer();

   593         break;

   594     default:

   595         GLES_ERROR(GL_INVALID_ENUM);

   596     }

   597     GLES_ASSERT(buffer);

   598 

   599     GLES_ERROR_IF(size + offset > buffer->size, GL_INVALID_VALUE);

   600     memcpy(static_cast<char*>(buffer->data) + offset, data, size);

   601 

   602     GLES_LEAVE();

   603 }

   604 GL_API void GL_APIENTRY glClear (GLbitfield mask)

   605 {

   606 	GLES_ENTER();

   607 	GLES_LOCK_DRAW_SURFACE();

   608 	ctx->DGL().glClear (mask);

   609 	GLES_UNLOCK_SURFACE();

   610     GLES_LEAVE();

   611 }

   612 GL_API void GL_APIENTRY glClearColorx (GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)

   613 {

   614     GLES_ENTER();

   615     ctx->DGL().glClearColor (X_TO_F(red), X_TO_F(green), X_TO_F(blue), X_TO_F(alpha));

   616     GLES_LEAVE();

   617 }

   618 GL_API void GL_APIENTRY glClearDepthx (GLclampx depth)

   619 {

   620     GLES_ENTER();

   621     ctx->DGL().glClearDepth (X_TO_D(depth));

   622     GLES_LEAVE();

   623 }

   624 GL_API void GL_APIENTRY glClearStencil (GLint s)

   625 {

   626     GLES_ENTER();

   627     ctx->DGL().glClearStencil (s);

   628     GLES_LEAVE();

   629 }

   630 GL_API void GL_APIENTRY glClientActiveTexture (GLenum texture)

   631 {

   632     GLES_ENTER();

   633     GLES_ERROR_IF(!isValidTextureTargetEnum(texture, ctx->MaxTextureUnits()), GL_INVALID_ENUM);

   634     ctx->GetHostError();

   635     ctx->DGL().glClientActiveTexture (texture);

   636     if(ctx->GetHostError() == GL_NO_ERROR)

   637     {

   638         ctx->SetClientActiveTexture(texture - GL_TEXTURE0);

   639     }

   640     GLES_LEAVE_NO_ERROR_CHECK();

   641 }

   642 GL_API void GL_APIENTRY glClipPlanex (GLenum plane, const GLfixed *equation)

   643 {

   644     GLES_ENTER();

   645     GLdouble dequation[4];

   646     for(int i = 0; i < 4; i++)

   647     {

   648         dequation[i] = X_TO_D(equation[i]);

   649     }

   650     ctx->DGL().glClipPlane (plane, dequation);

   651     GLES_LEAVE();

   652 }

   653 GL_API void GL_APIENTRY glColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)

   654 {

   655     GLES_ENTER();

   656     ctx->DGL().glColor4ub (red, green, blue, alpha);

   657     GLES_LEAVE();

   658 }

   659 GL_API void GL_APIENTRY glColor4x (GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)

   660 {

   661     GLES_ENTER();

   662     ctx->DGL().glColor4d(X_TO_D(red), X_TO_D(green), X_TO_D(blue), X_TO_D(alpha));

   663     GLES_LEAVE();

   664 }

   665 GL_API void GL_APIENTRY glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)

   666 {

   667     GLES_ENTER();

   668     ctx->DGL().glColorMask (red, green, blue, alpha);

   669     GLES_LEAVE();

   670 }

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

   672 {

   673     GLES_ENTER();

   674     GLES_ERROR_IF(size != 4, GL_INVALID_VALUE);

   675     GLES_ERROR_IF(type != GL_UNSIGNED_BYTE && type != GL_FIXED && type != GL_FLOAT, GL_INVALID_ENUM);

   676     GLES_ERROR_IF(stride < 0, GL_INVALID_VALUE);

   677     ctx->SetColorArray(size, type, stride, pointer);

   678     GLES_LEAVE();

   679 }

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

   681 {

   682 	GLES_ENTER();

   683 	GLES_ERROR_IF(target != GL_TEXTURE_2D, GL_INVALID_ENUM);

   684 	GLES_ERROR_IF(level > 0, GL_INVALID_VALUE);

   685 	GLES_ERROR_IF(!glesIsValidCompressedFormat(internalformat), GL_INVALID_ENUM);

   686 	GLES_ERROR_IF(height < 0, GL_INVALID_VALUE);

   687 	GLES_ERROR_IF(width < 0, GL_INVALID_VALUE);

   688 	GLES_ERROR_IF(height > 0 && !glesIsPowerOfTwo(height), GL_INVALID_VALUE);

   689 	GLES_ERROR_IF(width > 0 && !glesIsPowerOfTwo(width), GL_INVALID_VALUE);

   690 	GLES_ERROR_IF(imageSize < 0, GL_INVALID_VALUE);

   691 

   692 	GLenum baseFormat = glesMapCompressedToBaseFormat(internalformat);

   693 

   694 	int numLevels = -level + 1;

   695 	for(int curLevel = 0; curLevel < numLevels; curLevel++)

   696 	{

   697 		if(data != NULL)

   698 		{

   699 			void* uncompressedData = glesUncompressImage(curLevel, internalformat, width, height, imageSize, data);

   700 			if(uncompressedData == NULL)

   701 			{

   702 				GLES_ERROR(GL_OUT_OF_MEMORY);

   703 			}

   704 			ctx->DGL().glTexImage2D(target, curLevel, baseFormat, width, height, border, baseFormat, GL_UNSIGNED_BYTE, uncompressedData);

   705 			delete uncompressedData;

   706 		}

   707 		else

   708 		{

   709 			ctx->DGL().glTexImage2D(target, curLevel, baseFormat, width, height, border, baseFormat, GL_UNSIGNED_BYTE, NULL);

   710 		}

   711 

   712 		if(ctx->GetHostError() == GL_NO_ERROR)

   713 		{

   714 			GLESTexture* texture = ctx->Texture(ctx->TextureBinding());

   715 			GLES_ASSERT(texture != NULL);

   716 			texture->SetLevel(level, internalformat, width, height);

   717 

   718 			if(texture->Level(level)->boundSurface != NULL)

   719 			{

   720 				// Texture is respecified. Release the bound EGLSurface.

   721 				glesReleaseTexImage(texture->Level(level)->boundSurface, texture->Name(), level);

   722 				texture->Level(level)->boundSurface = NULL;

   723 			}

   724 		}

   725 

   726 		width /= 2;

   727 		height /= 2;

   728 	}

   729 	

   730 	GLES_LEAVE();

   731 }

   732 static bool isPalettedFormat(GLenum format)

   733 {

   734     switch(format)

   735     {

   736     case GL_PALETTE4_RGB8_OES:

   737     case GL_PALETTE4_RGBA8_OES:

   738     case GL_PALETTE4_R5_G6_B5_OES:

   739     case GL_PALETTE4_RGBA4_OES:

   740     case GL_PALETTE4_RGB5_A1_OES:

   741     case GL_PALETTE8_RGB8_OES:

   742     case GL_PALETTE8_RGBA8_OES:

   743     case GL_PALETTE8_R5_G6_B5_OES:

   744     case GL_PALETTE8_RGBA4_OES:

   745     case GL_PALETTE8_RGB5_A1_OES:

   746         return true;

   747     default:

   748         return false;

   749     }

   750 }

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

   752 {

   753     GLES_ENTER();

   754     GLES_ERROR_IF(!isPalettedFormat(format), GL_INVALID_ENUM);

   755     // Not supported for compressed paletted textures.

   756     GLES_ERROR(GL_INVALID_OPERATION);

   757     GLES_LEAVE();

   758 }

   759 bool isValidPixelFormatEnum(GLenum format)

   760 {

   761     switch(format)

   762     {

   763     case GL_ALPHA:

   764     case GL_LUMINANCE:

   765     case GL_LUMINANCE_ALPHA:

   766     case GL_RGB:

   767     case GL_RGBA:

   768         return true;

   769     default:

   770         return false;

   771     }

   772 }

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

   774 {

   775 	GLES_ENTER();

   776 	GLES_ERROR_IF(target != GL_TEXTURE_2D, GL_INVALID_ENUM);

   777 	GLES_ERROR_IF(!isValidPixelFormatEnum(internalformat), GL_INVALID_ENUM);

   778 	

   779 	GLES_LOCK_READ_SURFACE();

   780 	ctx->DGL().glCopyTexImage2D (target, level, internalformat, x, y, width, height, border);

   781 	GLES_UNLOCK_SURFACE();

   782 

   783 	if(ctx->GetHostError() == GL_NO_ERROR)

   784 	{

   785 		GLint genMipmap;

   786 		ctx->DGL().glGetTexParameteriv(target, GL_GENERATE_MIPMAP, &genMipmap);

   787 		GLESTexture* texture = ctx->Texture(ctx->TextureBinding());

   788 		GLES_ASSERT(texture != NULL);

   789 		if(level == 0 && genMipmap)

   790 		{

   791 			texture->GenerateMipmap();

   792 		}

   793 

   794 		if(texture->Level(level)->boundSurface != NULL)

   795 		{

   796 			// Texture is respecified. Release the bound EGLSurface.

   797 			glesReleaseTexImage(texture->Level(level)->boundSurface, texture->Name(), level);

   798 			texture->Level(level)->boundSurface = NULL;

   799 		}

   800 	}

   801 

   802 	GLES_LEAVE();

   803 }

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

   805 {

   806 	GLES_ENTER();

   807 	GLES_ERROR_IF(target != GL_TEXTURE_2D, GL_INVALID_ENUM);

   808 

   809 	GLESTexture* texture = ctx->Texture(ctx->TextureBinding());

   810 	GLES_ASSERT(texture != NULL);

   811 	const GLESTextureLevel* level_obj = texture->Level(level);

   812 	if(isPalettedFormat(level_obj->format))

   813 	{

   814 		GLES_ERROR(GL_INVALID_OPERATION);

   815 	}

   816 

   817 	GLES_LOCK_READ_SURFACE();

   818 	ctx->DGL().glCopyTexSubImage2D (target, level, xoffset, yoffset, x, y, width, height);

   819 	GLES_UNLOCK_SURFACE();

   820 

   821 	if(ctx->GetHostError() == GL_NO_ERROR)

   822 	{

   823 		GLint genMipmap;

   824 		ctx->DGL().glGetTexParameteriv(target, GL_GENERATE_MIPMAP, &genMipmap);

   825 		if(level == 0 && genMipmap)

   826 		{

   827 			GLESTexture* texture = ctx->Texture(ctx->TextureBinding());

   828 			GLES_ASSERT(texture != NULL);

   829 			texture->GenerateMipmap();

   830 		}

   831 	}

   832 

   833 	GLES_LEAVE();

   834 }

   835 GL_API void GL_APIENTRY glCullFace (GLenum mode)

   836 {

   837     GLES_ENTER();

   838     ctx->DGL().glCullFace (mode);

   839     GLES_LEAVE();

   840 }

   841 GL_API void GL_APIENTRY glDeleteBuffers (GLsizei n, const GLuint *buffers)

   842 {

   843     GLES_ENTER();

   844     GLES_ERROR_IF(n < 0, GL_INVALID_VALUE);

   845     for(int i = 0; i < n; i++)

   846     {

   847         ctx->DeleteBuffer(buffers[i]);

   848     }

   849     GLES_LEAVE();

   850 }

   851 GL_API void GL_APIENTRY glDeleteTextures (GLsizei n, const GLuint *textures)

   852 {

   853     GLES_ENTER();

   854     GLES_ERROR_IF(n < 0, GL_INVALID_VALUE);

   855     ctx->GetHostError();

   856     ctx->DGL().glDeleteTextures (n, textures);

   857     if(ctx->GetHostError() == GL_NO_ERROR)

   858     {

   859         for(int i = 0; i < n; i++)

   860         {

   861             ctx->DeleteTexture(textures[i]);

   862         }

   863     }

   864     GLES_LEAVE();

   865 }

   866 GL_API void GL_APIENTRY glDepthFunc (GLenum func)

   867 {

   868     GLES_ENTER();

   869     ctx->DGL().glDepthFunc (func);

   870     GLES_LEAVE();

   871 }

   872 GL_API void GL_APIENTRY glDepthMask (GLboolean flag)

   873 {

   874     GLES_ENTER();

   875     ctx->DGL().glDepthMask (flag);

   876     GLES_LEAVE();

   877 }

   878 GL_API void GL_APIENTRY glDepthRangex (GLclampx zNear, GLclampx zFar)

   879 {

   880     GLES_ENTER();

   881     ctx->DGL().glDepthRange(X_TO_D(zNear), X_TO_D(zFar));

   882     GLES_LEAVE();

   883 }

   884 bool isValidCapabilityEnum(GLenum cap)

   885 {

   886     switch(cap)

   887     {

   888     case GL_NORMALIZE:

   889     case GL_RESCALE_NORMAL:

   890     case GL_CLIP_PLANE0:

   891     case GL_CLIP_PLANE1:

   892     case GL_CLIP_PLANE2:

   893     case GL_CLIP_PLANE3:

   894     case GL_CLIP_PLANE4:

   895     case GL_CLIP_PLANE5:

   896     case GL_FOG:

   897     case GL_LIGHTING:

   898     case GL_COLOR_MATERIAL:

   899     case GL_LIGHT0:

   900     case GL_LIGHT1:

   901     case GL_LIGHT2:

   902     case GL_LIGHT3:

   903     case GL_LIGHT4:

   904     case GL_LIGHT5:

   905     case GL_LIGHT6:

   906     case GL_LIGHT7:

   907     case GL_POINT_SMOOTH:

   908     case GL_POINT_SPRITE_OES:

   909     case GL_LINE_SMOOTH:

   910     case GL_CULL_FACE:

   911     case GL_POLYGON_OFFSET_FILL:

   912     case GL_MULTISAMPLE:

   913     case GL_SAMPLE_ALPHA_TO_COVERAGE:

   914     case GL_SAMPLE_ALPHA_TO_ONE:

   915     case GL_SAMPLE_COVERAGE:

   916     case GL_TEXTURE_2D:

   917     case GL_SCISSOR_TEST:

   918     case GL_ALPHA_TEST:

   919     case GL_STENCIL_TEST:

   920     case GL_DEPTH_TEST:

   921     case GL_BLEND:

   922     case GL_DITHER:

   923     case GL_COLOR_LOGIC_OP:

   924         return true;

   925     default:

   926         return false;

   927     }

   928 }

   929 GL_API void GL_APIENTRY glDisable (GLenum cap)

   930 {

   931     GLES_ENTER();

   932     GLES_ERROR_IF(!isValidCapabilityEnum(cap), GL_INVALID_ENUM);

   933     cap = cap == GL_POINT_SPRITE_OES ? GL_POINT_SPRITE : cap;

   934     ctx->DGL().glDisable (cap);

   935     GLES_LEAVE();

   936 }

   937 static GLESArrayFlag mapArrayType(GLenum type)

   938 {

   939     switch(type)

   940     {

   941     case GL_VERTEX_ARRAY:

   942         return GLES_VERTEX_ARRAY;

   943     case GL_NORMAL_ARRAY:

   944         return GLES_NORMAL_ARRAY;

   945     case GL_COLOR_ARRAY:

   946         return GLES_COLOR_ARRAY;

   947     case GL_POINT_SIZE_ARRAY_OES:

   948         return GLES_POINT_SIZE_ARRAY;

   949     case GL_TEXTURE_COORD_ARRAY:

   950         return GLES_TEXTURE_COORD_ARRAY;

   951     default:

   952         return GLES_INVALID_ARRAY;

   953     }

   954 }

   955 GL_API void GL_APIENTRY glDisableClientState (GLenum array)

   956 {

   957     GLES_ENTER();

   958     int flag = static_cast<int>(mapArrayType(array));

   959     GLES_ERROR_IF(flag == GLES_INVALID_ARRAY, GL_INVALID_ENUM);

   960     if(flag == GLES_TEXTURE_COORD_ARRAY)

   961     {

   962         flag <<= ctx->ClientActiveTexture();

   963     }

   964     ctx->DisableArray(static_cast<GLESArrayFlag>(flag));

   965     if(array != GL_POINT_SIZE_ARRAY_OES)

   966     {

   967         ctx->DGL().glDisableClientState(array);

   968     }

   969     GLES_LEAVE();

   970 }

   971 static bool convertArrays(const GLESContext& ctx, GLsizei count, GLESArray** vertexArr, GLESArray** normalArr,

   972                           GLESArray** colorArr, GLESArray** texCoordArr)

   973 {

   974     *vertexArr = ctx.VertexArray().Convert(count);

   975     if(*vertexArr == NULL)

   976     {

   977         return false;

   978     }

   979     ctx.DGL().glVertexPointer((*vertexArr)->Size(), (*vertexArr)->Type(), (*vertexArr)->Stride(), (*vertexArr)->Pointer());

   980 

   981     if(ctx.IsArrayEnabled(GLES_NORMAL_ARRAY))

   982     {

   983         *normalArr = ctx.NormalArray().Convert(count);

   984         if(*normalArr == NULL)

   985         {

   986             return false;

   987         }

   988         ctx.DGL().glNormalPointer((*normalArr)->Type(), (*normalArr)->Stride(), (*normalArr)->Pointer());

   989     }

   990 

   991     if(ctx.IsArrayEnabled(GLES_COLOR_ARRAY))

   992     {

   993         *colorArr = ctx.ColorArray().Convert(count);

   994         if(*colorArr == NULL)

   995         {

   996             return false;

   997         }

   998         ctx.DGL().glColorPointer((*colorArr)->Size(), (*colorArr)->Type(), (*colorArr)->Stride(), (*colorArr)->Pointer());

   999     }

  1000 

  1001     for(unsigned int i = 0; i < ctx.MaxTextureUnits(); i++)

  1002     {

  1003         if(ctx.IsArrayEnabled(static_cast<GLESArrayFlag>(GLES_TEXTURE_COORD_ARRAY << i)))

  1004         {

  1005             texCoordArr[i] = ctx.TexCoordArray(i).Convert(count);

  1006             if(texCoordArr[i] == NULL)

  1007             {

  1008                 return false;

  1009             }

  1010             ctx.DGL().glClientActiveTexture(GL_TEXTURE0 + i);

  1011             ctx.DGL().glTexCoordPointer(texCoordArr[i]->Size(), texCoordArr[i]->Type(),

  1012                                     texCoordArr[i]->Stride(), texCoordArr[i]->Pointer());

  1013         }

  1014     }

  1015 

  1016     // Reset state

  1017     ctx.DGL().glClientActiveTexture(GL_TEXTURE0 + ctx.ClientActiveTexture());

  1018 

  1019     return true;

  1020 }

  1021 void drawPoint(const GLESContext& ctx, int i, GLESArrayPointer& vertexPtr, GLESArrayPointer& normalPtr,

  1022                GLESArrayPointer& colorPtr, GLESArrayPointer& pointSizePtr,

  1023                GLESArrayPointer* texCoordPtr)

  1024 {

  1025     if(normalPtr != NULL)

  1026     {

  1027         switch(normalPtr.Type())

  1028         {

  1029         case GL_BYTE:

  1030         case GL_SHORT:

  1031             ctx.DGL().glNormal3sv(static_cast<const GLshort*>(normalPtr[i]));

  1032             break;

  1033         case GL_FIXED:

  1034         case GL_FLOAT:

  1035             ctx.DGL().glNormal3fv(static_cast<const GLfloat*>(normalPtr[i]));

  1036             break;

  1037         default:

  1038             GLES_ASSERT(false);

  1039         }

  1040     }

  1041 

  1042     if(colorPtr != NULL)

  1043     {

  1044         switch(colorPtr.Type())

  1045         {

  1046         case GL_UNSIGNED_BYTE:

  1047             ctx.DGL().glColor4ubv(static_cast<const GLubyte*>(colorPtr[i]));

  1048             break;

  1049         case GL_FIXED:

  1050         case GL_FLOAT:

  1051             ctx.DGL().glColor4fv(static_cast<const GLfloat*>(colorPtr[i]));

  1052             break;

  1053         default:

  1054             GLES_ASSERT(false);

  1055         }

  1056     }

  1057 

  1058     GLES_ASSERT(pointSizePtr != NULL);

  1059     ctx.DGL().glPointSize(*static_cast<const GLfloat*>(pointSizePtr[i]));

  1060 

  1061     for(unsigned int j = 0; j < ctx.MaxTextureUnits(); j++)

  1062     {

  1063         int texture = GL_TEXTURE0 + j;

  1064 		

  1065         if(texCoordPtr[j] != NULL)

  1066         {

  1067             switch(texCoordPtr[j].Type())

  1068             {

  1069             case GL_BYTE:

  1070             case GL_SHORT:

  1071                 switch(texCoordPtr[j].Size())

  1072                 {

  1073                 case 2:

  1074                     ctx.DGL().glMultiTexCoord2sv(texture, static_cast<const GLshort*>(texCoordPtr[j][i]));

  1075                     break;

  1076                 case 3:

  1077                     ctx.DGL().glMultiTexCoord3sv(texture, static_cast<const GLshort*>(texCoordPtr[j][i]));

  1078                     break;

  1079                 case 4:

  1080                     ctx.DGL().glMultiTexCoord4sv(texture, static_cast<const GLshort*>(texCoordPtr[j][i]));

  1081                     break;

  1082                 default:

  1083                     GLES_ASSERT(false);

  1084                 }

  1085                 break;

  1086             case GL_FIXED:

  1087             case GL_FLOAT:

  1088                 switch(texCoordPtr[j].Size())

  1089                 {

  1090                 case 2:

  1091                     ctx.DGL().glMultiTexCoord2fv(texture, static_cast<const GLfloat*>(texCoordPtr[j][i]));

  1092                     break;

  1093                 case 3:

  1094                     ctx.DGL().glMultiTexCoord3fv(texture, static_cast<const GLfloat*>(texCoordPtr[j][i]));

  1095                     break;

  1096                 case 4:

  1097                     ctx.DGL().glMultiTexCoord4fv(texture, static_cast<const GLfloat*>(texCoordPtr[j][i]));

  1098                     break;

  1099                 default:

  1100                     GLES_ASSERT(false);

  1101                 }

  1102                 break;

  1103             default:

  1104                 GLES_ASSERT(false);

  1105             }

  1106         }

  1107     }

  1108 

  1109     GLES_ASSERT(vertexPtr != NULL);

  1110     ctx.DGL().glBegin(GL_POINTS);

  1111     switch(vertexPtr.Type())

  1112     {

  1113     case GL_BYTE:

  1114     case GL_SHORT:

  1115         switch(vertexPtr.Size())

  1116         {

  1117         case 2:

  1118             ctx.DGL().glVertex2sv(static_cast<const GLshort*>(vertexPtr[i]));

  1119             break;

  1120         case 3:

  1121             ctx.DGL().glVertex3sv(static_cast<const GLshort*>(vertexPtr[i]));

  1122             break;

  1123         case 4:

  1124             ctx.DGL().glVertex4sv(static_cast<const GLshort*>(vertexPtr[i]));

  1125             break;

  1126         default:

  1127             GLES_ASSERT(false);

  1128         }

  1129         break;

  1130     case GL_FIXED:

  1131     case GL_FLOAT:

  1132         switch(vertexPtr.Size())

  1133         {

  1134         case 2: