hw/gles2_es11_calls.c

   1 /* Copyright (c) 2009-2010 Nokia Corporation
   2  * Copyright (c) 2010 Samsung Electronics.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 or
   7  * (at your option) any later version of the License.
   8  *
   9  * You should have received a copy of the GNU General Public License along
  10  * with this program; if not, see <http://www.gnu.org/licenses/>.
  11  */
  12
  13 #include "gles2_calls.h"
  14 #include "GLES/gl.h"
  15 #include "glapi.h"
  16
  17 static int context_index = 0;
  18
  19 static HGL hgl;
  20 #undef GLES2_CB
  21 #define GLES2_CB(func) \
  22     CB(func,es11)
  23
  24 /*********************************************
  25 *
  26 *  OpenGL ES 1.1 helper functions and macros
  27 *
  28 **********************************************/
  29
  30 #define gles1_count_glClipPlanef  4
  31 #define gles1_count_glClipPlanex  4
  32 #define gles1_count_glLoadMatrixf 16
  33 #define gles1_count_glLoadMatrixx 16
  34 #define gles1_count_glMultMatrixf 16
  35 #define gles1_count_glMultMatrixx 16
  36
  37
  38 // Numbers from c->array's end
  39 #define gles1_num_glColorPointer     1
  40 #define gles1_num_glNormalPointer    2
  41 #define gles1_num_glTexCoordPointer  3
  42 #define gles1_num_glVertexPointer    4
  43 #define gles1_num_glPointSizePointer 5
  44
  45 #define gles1_size_glNormalPointer 3
  46 #define gles1_size_glPointSizePointer 1
  47 static void gles1_apply_glVertexPointer(gles2_Array *va);
  48 static void gles1_apply_glTexCoordPointer(gles2_Array *va);
  49 static void gles1_apply_glNormalPointer(gles2_Array *va);
  50 static void gles1_apply_glColorPointer(gles2_Array *va);
  51 static void gles1_apply_glPointSizePointer(gles2_Array *va);
  52
  53 void gles1_loadHGL(void);
  54 void gles1_loadHGL(void)
  55 {
  56     const char *libname =
  57 #ifdef __APPLE__
  58     "libGLES_CM.dylib";
  59 #elif defined(_WIN32)
  60     "GLES_CM.dll";
  61 #else
  62     "libGLES_CM.so";
  63 #endif
  64
  65     void* handle;
  66     if (!(handle = dlopen(libname, RTLD_LOCAL | RTLD_LAZY))) {
  67         fprintf(stderr, "ERROR: Couldn't load GLES_CM library!\n");
  68         exit(0);
  69     }
  70
  71     #define GLES2_HGL_FUNC(ret,name,attr) \
  72         if((hgl.name = dlsym(handle, #name))==NULL) \
  73         { \
  74             fprintf(stderr, "ES1.1 Function " #name " not found!\n"); \
  75         }
  76     GLES2_HGL_FUNCS
  77     #undef DGLES_HGL_FUNC
  78 }
  79
  80 static void gles1_apply_glColorPointer(gles2_Array *va)
  81 {
  82     hgl.glColorPointer(va->size, va->type, 0,
  83         (GLvoid*)((GLchar*)va->ptr - va->delta));
  84     GLenum error;
  85
  86     if ((error = hgl.glGetError()) != GL_NO_ERROR) {
  87         GLES2_PRINT("glColorPointer(%d, 0x%x, %d, %p - %d\n)"
  88             " failed with 0x%x!\n", va->size, va->type, va->stride, va->ptr,
  89             (int)va->delta, error);
  90     }
  91 }
  92
  93 static void gles1_apply_glNormalPointer(gles2_Array *va)
  94 {
  95     hgl.glNormalPointer(va->type, 0,
  96         (GLvoid*)((GLchar*)va->ptr - va->delta));
  97     GLenum error;
  98
  99     if ((error = hgl.glGetError()) != GL_NO_ERROR) {
 100         GLES2_PRINT("glNormalPointer(0x%x, %d, %p - %d\n)"
 101             " failed with 0x%x!\n", va->type, va->stride, va->ptr,
 102             (int)va->delta, error);
 103     }
 104 }
 105
 106 static void gles1_apply_glTexCoordPointer(gles2_Array *va)
 107 {
 108     hgl.glTexCoordPointer(va->size, va->type, 0,
 109         (GLvoid*)((GLchar*)va->ptr - va->delta));
 110     GLenum error;
 111
 112     if ((error = hgl.glGetError()) != GL_NO_ERROR) {
 113         GLES2_PRINT("glTexCoordPointer(%d, 0x%x, %d, %p - %d\n)"
 114             " failed with 0x%x!\n", va->size, va->type, va->stride, va->ptr,
 115             (int)va->delta, error);
 116     }
 117 }
 118
 119 static void gles1_apply_glVertexPointer(gles2_Array *va)
 120 {
 121     hgl.glVertexPointer(va->size, va->type, 0,
 122         (GLvoid*)((GLchar*)va->ptr - va->delta));
 123     GLenum error;
 124
 125     if ((error = hgl.glGetError()) != GL_NO_ERROR) {
 126         GLES2_PRINT("glVertexPointer(%d, 0x%x, %d, %p - %d\n)"
 127             " failed with 0x%x!\n", va->size, va->type, va->stride, va->ptr,
 128             (int)va->delta, error);
 129     }
 130 }
 131
 132 static void gles1_apply_glPointSizePointer(gles2_Array *va)
 133 {
 134     hgl.glPointSizePointerOES(va->type, 0,
 135         (GLvoid*)((GLchar*)va->ptr - va->delta));
 136     GLenum error;
 137
 138     if ((error = hgl.glGetError()) != GL_NO_ERROR) {
 139         GLES2_PRINT("glPointSizePointerOES(0x%x, %d, %p - %p)"
 140                     " failed with 0x%x!\n", va->type, va->stride, va->ptr,
 141                     (void*)va->delta, error);
 142     }
 143 }
 144
 145 static unsigned gles2_GetCount(TGLenum pname)
 146 {
 147     unsigned count;
 148     switch(pname) {
 149         case GL_ACTIVE_TEXTURE: count=1; break;
 150         case GL_ALIASED_LINE_WIDTH_RANGE: count=2; break;
 151         case GL_ALIASED_POINT_SIZE_RANGE: count=2; break;
 152         case GL_ALPHA_BITS: count=1; break;
 153         case GL_ALPHA_SCALE: count=1; break;
 154         case GL_ALPHA_TEST: count=1; break;
 155         case GL_ALPHA_TEST_FUNC: count=1; break;
 156         case GL_ALPHA_TEST_REF: count=1; break;
 157         case GL_AMBIENT: count=4; break;
 158         case GL_AMBIENT_AND_DIFFUSE: count=4; break;
 159         case GL_ARRAY_BUFFER_BINDING: count=1; break;
 160         case GL_BLEND: count=1; break;
 161         case GL_BLEND_DST: count=1; break;
 162         case GL_BLEND_SRC: count=1; break;
 163         case GL_BLUE_BITS: count=1; break;
 164         case GL_CLIENT_ACTIVE_TEXTURE: count=1; break;
 165         case GL_CLIP_PLANE0: count=1; break;
 166         case GL_CLIP_PLANE1: count=1; break;
 167         case GL_CLIP_PLANE2: count=1; break;
 168         case GL_CLIP_PLANE3: count=1; break;
 169         case GL_CLIP_PLANE4: count=1; break;
 170         case GL_CLIP_PLANE5: count=1; break;
 171         case GL_COLOR_ARRAY: count=1; break;
 172         case GL_COLOR_ARRAY_BUFFER_BINDING: count=1; break;
 173         case GL_COLOR_ARRAY_SIZE: count=1; break;
 174         case GL_COLOR_ARRAY_STRIDE: count=1; break;
 175         case GL_COLOR_ARRAY_TYPE: count=1; break;
 176         case GL_COLOR_CLEAR_VALUE: count=4; break;
 177         case GL_COLOR_LOGIC_OP: count=1; break;
 178         case GL_COLOR_MATERIAL: count=1; break;
 179         case GL_COLOR_WRITEMASK: count=4; break;
 180         case GL_COMBINE_ALPHA: count=1; break;
 181         case GL_COMBINE_RGB: count=1; break;
 182         case GL_CONSTANT_ATTENUATION: count=1; break;
 183         case GL_CULL_FACE: count=1; break;
 184         case GL_CULL_FACE_MODE: count=1; break;
 185         case GL_CURRENT_COLOR: count=4; break;
 186         case GL_CURRENT_NORMAL: count=3; break;
 187         case GL_CURRENT_TEXTURE_COORDS: count=4; break;
 188         case GL_DEPTH_BITS: count=1; break;
 189         case GL_DEPTH_CLEAR_VALUE: count=1; break;
 190         case GL_DEPTH_FUNC: count=1; break;
 191         case GL_DEPTH_RANGE: count=2; break;
 192         case GL_DEPTH_TEST: count=1; break;
 193         case GL_DEPTH_WRITEMASK: count=1; break;
 194         case GL_DIFFUSE: count=4; break;
 195         case GL_DITHER: count=1; break;
 196         case GL_ELEMENT_ARRAY_BUFFER_BINDING: count=1; break;
 197         case GL_EMISSION: count=4; break;
 198         case GL_FOG: count=1; break;
 199         case GL_FOG_COLOR: count=4; break;
 200         case GL_FOG_DENSITY: count=1; break;
 201         case GL_FOG_END: count=1; break;
 202         case GL_FOG_HINT: count=1; break;
 203         case GL_FOG_MODE: count=1; break;
 204         case GL_FOG_START: count=1; break;
 205         case GL_FRONT_FACE: count=1; break;
 206         case GL_GREEN_BITS: count=1; break;
 207         case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES: count=1; break;
 208         case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES: count=1; break;
 209         case GL_LIGHT0: count=1; break;
 210         case GL_LIGHT1: count=1; break;
 211         case GL_LIGHT2: count=1; break;
 212         case GL_LIGHT3: count=1; break;
 213         case GL_LIGHT4: count=1; break;
 214         case GL_LIGHT5: count=1; break;
 215         case GL_LIGHT6: count=1; break;
 216         case GL_LIGHT7: count=1; break;
 217         case GL_LIGHTING: count=1; break;
 218         case GL_LIGHT_MODEL_AMBIENT: count=4; break;
 219         case GL_LIGHT_MODEL_TWO_SIDE: count=1; break;
 220         case GL_LINEAR_ATTENUATION: count=1; break;
 221         case GL_LINE_SMOOTH: count=1; break;
 222         case GL_LINE_SMOOTH_HINT: count=1; break;
 223         case GL_LINE_WIDTH: count=1; break;
 224         case GL_LOGIC_OP_MODE: count=1; break;
 225         case GL_MATRIX_MODE: count=1; break;
 226         case GL_MAX_CLIP_PLANES: count=1; break;
 227         case GL_MAX_LIGHTS: count=1; break;
 228         case GL_MAX_MODELVIEW_STACK_DEPTH: count=1; break;
 229         case GL_MAX_PROJECTION_STACK_DEPTH: count=1; break;
 230         case GL_MAX_TEXTURE_SIZE: count=1; break;
 231         case GL_MAX_TEXTURE_STACK_DEPTH: count=1; break;
 232         case GL_MAX_TEXTURE_UNITS: count=1; break;
 233         case GL_MAX_VIEWPORT_DIMS: count=2; break;
 234         case GL_MODELVIEW_MATRIX: count=16; break;
 235         case GL_MODELVIEW_STACK_DEPTH: count=1; break;
 236         case GL_MULTISAMPLE: count=1; break;
 237         case GL_NORMALIZE: count=1; break;
 238         case GL_NORMAL_ARRAY: count=1; break;
 239         case GL_NORMAL_ARRAY_BUFFER_BINDING: count=1; break;
 240         case GL_NORMAL_ARRAY_STRIDE: count=1; break;
 241         case GL_NORMAL_ARRAY_TYPE: count=1; break;
 242         case GL_OPERAND0_ALPHA: count=1; break;
 243         case GL_OPERAND0_RGB: count=1; break;
 244         case GL_OPERAND1_ALPHA: count=1; break;
 245         case GL_OPERAND1_RGB: count=1; break;
 246         case GL_OPERAND2_ALPHA: count=1; break;
 247         case GL_OPERAND2_RGB: count=1; break;
 248         case GL_PACK_ALIGNMENT: count=1; break;
 249         case GL_PERSPECTIVE_CORRECTION_HINT: count=1; break;
 250         case GL_POINT_DISTANCE_ATTENUATION: count=3; break;
 251         case GL_POINT_FADE_THRESHOLD_SIZE: count=1; break;
 252         case GL_POINT_SIZE: count=1; break;
 253         case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES: count = 1; break;
 254         case GL_POINT_SIZE_ARRAY_OES: count = 1; break;
 255         case GL_POINT_SIZE_ARRAY_STRIDE_OES: count = 1; break;
 256         case GL_POINT_SIZE_ARRAY_TYPE_OES: count = 1; break;
 257         case GL_POINT_SIZE_MAX: count=1; break;
 258         case GL_POINT_SIZE_MIN: count=1; break;
 259         case GL_POINT_SMOOTH: count=1; break;
 260         case GL_POINT_SMOOTH_HINT: count=1; break;
 261         case GL_POINT_SPRITE_OES: count=1; break;
 262         case GL_POLYGON_OFFSET_FACTOR: count=1; break;
 263         case GL_POLYGON_OFFSET_FILL: count=1; break;
 264         case GL_POLYGON_OFFSET_UNITS: count=1; break;
 265         case GL_POSITION: count=4; break;
 266         case GL_PROJECTION_MATRIX: count=16; break;
 267         case GL_PROJECTION_STACK_DEPTH: count=1; break;
 268         case GL_QUADRATIC_ATTENUATION: count=1; break;
 269         case GL_RED_BITS: count=1; break;
 270         case GL_RESCALE_NORMAL: count=1; break;
 271         case GL_RGB_SCALE: count=1; break;
 272         case GL_SAMPLES: count=1; break;
 273         case GL_SAMPLE_ALPHA_TO_COVERAGE: count=1; break;
 274         case GL_SAMPLE_ALPHA_TO_ONE: count=1; break;
 275         case GL_SAMPLE_BUFFERS: count=1; break;
 276         case GL_SAMPLE_COVERAGE: count=1; break;
 277         case GL_SAMPLE_COVERAGE_INVERT: count=1; break;
 278         case GL_SAMPLE_COVERAGE_VALUE: count=1; break;
 279         case GL_SCISSOR_BOX: count=4; break;
 280         case GL_SCISSOR_TEST: count=1; break;
 281         case GL_SHADE_MODEL: count=1; break;
 282         case GL_SHININESS: count=1; break;
 283         case GL_SMOOTH_LINE_WIDTH_RANGE: count=2; break;
 284         case GL_SMOOTH_POINT_SIZE_RANGE: count=2; break;
 285         case GL_SPECULAR: count=4; break;
 286         case GL_SPOT_CUTOFF: count=1; break;
 287         case GL_SPOT_DIRECTION: count=3; break;
 288         case GL_SPOT_EXPONENT: count=1; break;
 289         case GL_SRC0_ALPHA: count=1; break;
 290         case GL_SRC0_RGB: count=1; break;
 291         case GL_SRC1_ALPHA: count=1; break;
 292         case GL_SRC1_RGB: count=1; break;
 293         case GL_SRC2_ALPHA: count=1; break;
 294         case GL_SRC2_RGB: count=1; break;
 295         case GL_STENCIL_BITS: count=1; break;
 296         case GL_STENCIL_CLEAR_VALUE: count=1; break;
 297         case GL_STENCIL_FAIL: count=1; break;
 298         case GL_STENCIL_FUNC: count=1; break;
 299         case GL_STENCIL_PASS_DEPTH_FAIL: count=1; break;
 300         case GL_STENCIL_PASS_DEPTH_PASS: count=1; break;
 301         case GL_STENCIL_REF: count=1; break;
 302         case GL_STENCIL_TEST: count=1; break;
 303         case GL_STENCIL_VALUE_MASK: count=1; break;
 304         case GL_STENCIL_WRITEMASK: count=1; break;
 305         case GL_SUBPIXEL_BITS: count=1; break;
 306         case GL_TEXTURE_2D: count=1; break;
 307         case GL_TEXTURE_BINDING_2D: count=1; break;
 308         case GL_TEXTURE_COORD_ARRAY: count=1; break;
 309         case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING: count=1; break;
 310         case GL_TEXTURE_COORD_ARRAY_SIZE: count=1; break;
 311         case GL_TEXTURE_COORD_ARRAY_STRIDE: count=1; break;
 312         case GL_TEXTURE_COORD_ARRAY_TYPE: count=1; break;
 313         case GL_TEXTURE_ENV_COLOR: count=4; break;
 314         case GL_TEXTURE_ENV_MODE: count=1; break;
 315         case GL_TEXTURE_MATRIX: count=16; break;
 316         case GL_TEXTURE_STACK_DEPTH: count=1; break;
 317         case GL_UNPACK_ALIGNMENT: count=1; break;
 318         case GL_VERTEX_ARRAY: count=1; break;
 319         case GL_VERTEX_ARRAY_BUFFER_BINDING: count=1; break;
 320         case GL_VERTEX_ARRAY_SIZE: count=1; break;
 321         case GL_VERTEX_ARRAY_STRIDE: count=1; break;
 322         case GL_VERTEX_ARRAY_TYPE: count=1; break;
 323         case GL_VIEWPORT: count=4; break;
 324         default:
 325             GLES2_PRINT("ERROR: Unknown pname 0x%x in GLES1 GetCount!\n", pname);
 326             count = 1;
 327             break;
 328     }
 329
 330     GLES2_PRINT("GLES1 GetCount(0x%x) -> %u!\n", pname, count);
 331
 332     return count;
 333 }
 334
 335 #include "gles2_escommon_calls.c"
 336
 337 GLES2_CB(glGetPointerv)
 338 {
 339     GLES2_ARG(TGLenum, pname);
 340     GLES2_ARG(Tptr, paramsp);
 341     GLES2_BARRIER_ARG_NORET;
 342     Tptr res = 0;
 343     gles2_Context * ctx = c->context[context_index];
 344     switch (pname)
 345     {
 346     case GL_COLOR_ARRAY_POINTER:
 347         res = ctx->arrays[gles1_num_glColorPointer].tptr;
 348         break;
 349     case GL_NORMAL_ARRAY_POINTER:
 350         res = ctx->arrays[gles1_num_glNormalPointer].tptr;
 351         break;
 352     case GL_TEXTURE_COORD_ARRAY_POINTER:
 353         res = ctx->arrays[gles1_num_glTexCoordPointer].tptr;
 354         break;
 355     case GL_VERTEX_ARRAY_POINTER:
 356         res = ctx->arrays[gles1_num_glVertexPointer].tptr;
 357         break;
 358     case GL_POINT_SIZE_ARRAY_POINTER_OES:
 359         res = ctx->arrays[gles1_num_glPointSizePointer].tptr;
 360         break;
 361     default:
 362         GLES2_PRINT("ERROR: Unknown pname 0x%x in glGetPointerv!\n", pname);
 363         break;
 364     }
 365
 366     gles2_put_Tptr(s, paramsp, res);
 367 }
 368
 369 GLES2_CB(glEnableClientState)
 370 {
 371     GLES2_ARG(TGLenum, array);
 372     GLES2_BARRIER_ARG_NORET;
 373
 374     gles2_Context * ctx = c->context[context_index];
 375     switch (array)
 376     {
 377     case GL_COLOR_ARRAY:
 378         ctx->arrays[gles1_num_glColorPointer].enabled = 1;
 379         break;
 380     case GL_NORMAL_ARRAY:
 381         ctx->arrays[gles1_num_glNormalPointer].enabled = 1;
 382         break;
 383     case GL_TEXTURE_COORD_ARRAY:
 384         ctx->arrays[gles1_num_glTexCoordPointer].enabled = 1;
 385         break;
 386     case GL_VERTEX_ARRAY:
 387         ctx->arrays[gles1_num_glVertexPointer].enabled = 1;
 388         break;
 389     case GL_POINT_SIZE_ARRAY_OES:
 390         ctx->arrays[gles1_num_glPointSizePointer].enabled = 1;
 391         break;
 392     default:
 393         GLES2_PRINT("ERROR: Unknown array 0x%x in glEnableClientState!\n", array);
 394         break;
 395     }
 396     hgl.glEnableClientState(array);
 397 }
 398
 399 GLES2_CB(glDisableClientState)
 400 {
 401     GLES2_ARG(TGLenum, array);
 402     GLES2_BARRIER_ARG_NORET;
 403
 404     gles2_Context * ctx = c->context[context_index];
 405     switch (array)
 406     {
 407     case GL_COLOR_ARRAY:
 408         ctx->arrays[gles1_num_glColorPointer].enabled = 0;
 409         break;
 410     case GL_NORMAL_ARRAY:
 411         ctx->arrays[gles1_num_glNormalPointer].enabled = 0;
 412         break;
 413     case GL_TEXTURE_COORD_ARRAY:
 414         ctx->arrays[gles1_num_glTexCoordPointer].enabled = 0;
 415         break;
 416     case GL_VERTEX_ARRAY:
 417         ctx->arrays[gles1_num_glVertexPointer].enabled = 0;
 418         break;
 419     case GL_POINT_SIZE_ARRAY_OES:
 420         ctx->arrays[gles1_num_glPointSizePointer].enabled = 0;
 421         break;
 422     default:
 423         GLES2_PRINT("ERROR: Unknown array 0x%x in glDisableClientState!\n", array);
 424         break;
 425     }
 426
 427     hgl.glDisableClientState(array);
 428 }
 429
 430
 431 //***************** Has been generated! *******************
 432
 433 GLES2_CB(glAlphaFunc)
 434 {
 435     GLES2_ARG(TGLenum, func);
 436     GLES2_ARG(TGLclampf, ref);
 437     GLES2_BARRIER_ARG_NORET;
 438
 439     hgl.glAlphaFunc(func, ref);
 440 }
 441
 442 GLES2_CB(glClipPlanef)
 443 {
 444     GLES2_ARG(TGLenum, plane);
 445     GLES2_ARG(Tptr, equationp);
 446     unsigned count = gles1_count_glClipPlanef;
 447     GLfloat equation [16];
 448     unsigned i = 0;
 449     for (i = 0; i < count; ++i) {
 450         equation[i] = gles2_get_TGLfloat(s, equationp + i*sizeof(TGLfloat));
 451     }
 452     GLES2_BARRIER_ARG_NORET;
 453
 454     hgl.glClipPlanef(plane, equation);
 455 }
 456
 457 GLES2_CB(glColor4f)
 458 {
 459     GLES2_ARG(TGLfloat, red);
 460     GLES2_ARG(TGLfloat, green);
 461     GLES2_ARG(TGLfloat, blue);
 462     GLES2_ARG(TGLfloat, alpha);
 463     GLES2_BARRIER_ARG_NORET;
 464
 465     hgl.glColor4f(red, green, blue, alpha);
 466 }
 467
 468 GLES2_CB(glFogf)
 469 {
 470     GLES2_ARG(TGLenum, pname);
 471     GLES2_ARG(TGLfloat, param);
 472     GLES2_BARRIER_ARG_NORET;
 473
 474     hgl.glFogf(pname, param);
 475 }
 476
 477 GLES2_CB(glFogfv)
 478 {
 479     GLES2_ARG(TGLenum, pname);
 480     GLES2_ARG(Tptr, paramsp);
 481     unsigned count = gles2_GetCount(pname);
 482     GLfloat params [16];
 483     unsigned i = 0;
 484     for (i = 0; i < count; ++i) {
 485         params[i] = gles2_get_TGLfloat(s, paramsp + i*sizeof(TGLfloat));
 486     }
 487     GLES2_BARRIER_ARG_NORET;
 488
 489     hgl.glFogfv(pname, params);
 490 }
 491
 492 GLES2_CB(glFrustumf)
 493 {
 494     GLES2_ARG(TGLfloat, left);
 495     GLES2_ARG(TGLfloat, right);
 496     GLES2_ARG(TGLfloat, bottom);
 497     GLES2_ARG(TGLfloat, top);
 498     GLES2_ARG(TGLfloat, zNear);
 499     GLES2_ARG(TGLfloat, zFar);
 500     GLES2_BARRIER_ARG_NORET;
 501
 502     hgl.glFrustumf(left, right, bottom, top, zNear, zFar);
 503 }
 504
 505 GLES2_CB(glGetClipPlanef)
 506 {
 507     GLES2_ARG(TGLenum, pname);
 508     GLES2_ARG(Tptr, eqnp);
 509     GLES2_BARRIER_ARG_NORET;
 510     unsigned count = gles2_GetCount(pname);
 511     GLfloat eqn [16];
 512
 513     hgl.glGetClipPlanef(pname, eqn);
 514     unsigned i = 0;
 515     for (i = 0; i < count; ++i) {
 516         gles2_put_TGLfloat(s, eqnp + i*sizeof(TGLfloat), eqn[i]);
 517     }
 518 }
 519
 520 GLES2_CB(glGetLightfv)
 521 {
 522     GLES2_ARG(TGLenum, light);
 523     GLES2_ARG(TGLenum, pname);
 524     GLES2_ARG(Tptr, paramsp);
 525     GLES2_BARRIER_ARG_NORET;
 526     unsigned count = gles2_GetCount(pname);
 527     GLfloat params [16];
 528
 529     hgl.glGetLightfv(light, pname, params);
 530     unsigned i = 0;
 531     for (i = 0; i < count; ++i) {
 532         gles2_put_TGLfloat(s, paramsp + i*sizeof(TGLfloat), params[i]);
 533     }
 534 }
 535
 536 GLES2_CB(glGetMaterialfv)
 537 {
 538     GLES2_ARG(TGLenum, face);
 539     GLES2_ARG(TGLenum, pname);
 540     GLES2_ARG(Tptr, paramsp);
 541     GLES2_BARRIER_ARG_NORET;
 542     unsigned count = gles2_GetCount(pname);
 543     GLfloat params [16];
 544
 545     hgl.glGetMaterialfv(face, pname, params);
 546     unsigned i = 0;
 547     for (i = 0; i < count; ++i) {
 548         gles2_put_TGLfloat(s, paramsp + i*sizeof(TGLfloat), params[i]);
 549     }
 550 }
 551
 552 GLES2_CB(glGetTexEnvfv)
 553 {
 554     GLES2_ARG(TGLenum, env);
 555     GLES2_ARG(TGLenum, pname);
 556     GLES2_ARG(Tptr, paramsp);
 557     GLES2_BARRIER_ARG_NORET;
 558     unsigned count = gles2_GetCount(pname);
 559     GLfloat params [16];
 560
 561     hgl.glGetTexEnvfv(env, pname, params);
 562     unsigned i = 0;
 563     for (i = 0; i < count; ++i) {
 564         gles2_put_TGLfloat(s, paramsp + i*sizeof(TGLfloat), params[i]);
 565     }
 566 }
 567
 568 GLES2_CB(glLightModelf)
 569 {
 570     GLES2_ARG(TGLenum, pname);
 571     GLES2_ARG(TGLfloat, param);
 572     GLES2_BARRIER_ARG_NORET;
 573
 574     hgl.glLightModelf(pname, param);
 575 }
 576
 577 GLES2_CB(glLightModelfv)
 578 {
 579     GLES2_ARG(TGLenum, pname);
 580     GLES2_ARG(Tptr, paramsp);
 581     GLES2_BARRIER_ARG_NORET;
 582     unsigned count = gles2_GetCount(pname);
 583     GLfloat params [16];
 584     unsigned i = 0;
 585     for (i = 0; i < count; ++i) {
 586         params[i] = gles2_get_TGLfloat(s, paramsp + i*sizeof(TGLfloat));
 587     }
 588
 589     hgl.glLightModelfv(pname, params);
 590 }
 591
 592 GLES2_CB(glLightf)
 593 {
 594     GLES2_ARG(TGLenum, light);
 595     GLES2_ARG(TGLenum, pname);
 596     GLES2_ARG(TGLfloat, param);
 597     GLES2_BARRIER_ARG_NORET;
 598
 599     hgl.glLightf(light, pname, param);
 600 }
 601
 602 GLES2_CB(glLightfv)
 603 {
 604     GLES2_ARG(TGLenum, light);
 605     GLES2_ARG(TGLenum, pname);
 606     GLES2_ARG(Tptr, paramsp);
 607     unsigned count = gles2_GetCount(pname);
 608     GLfloat params [16];
 609     unsigned i = 0;
 610     for (i = 0; i < count; ++i) {
 611         params[i] = gles2_get_TGLfloat(s, paramsp + i*sizeof(TGLfloat));
 612     }
 613     GLES2_BARRIER_ARG_NORET;
 614
 615     hgl.glLightfv(light, pname, params);
 616 }
 617
 618 GLES2_CB(glLoadMatrixf)
 619 {
 620     GLES2_ARG(Tptr, mp);
 621     unsigned count = gles1_count_glLoadMatrixf;
 622     GLfloat m [16];
 623     unsigned i = 0;
 624     for (i = 0; i < count; ++i) {
 625         m[i] = gles2_get_TGLfloat(s, mp + i*sizeof(TGLfloat));
 626     }
 627     GLES2_BARRIER_ARG_NORET;
 628
 629     hgl.glLoadMatrixf(m);
 630 }
 631
 632 GLES2_CB(glMaterialf)
 633 {
 634     GLES2_ARG(TGLenum, face);
 635     GLES2_ARG(TGLenum, pname);
 636     GLES2_ARG(TGLfloat, param);
 637     GLES2_BARRIER_ARG_NORET;
 638
 639     hgl.glMaterialf(face, pname, param);
 640 }
 641
 642 GLES2_CB(glMaterialfv)
 643 {
 644     GLES2_ARG(TGLenum, face);
 645     GLES2_ARG(TGLenum, pname);
 646     GLES2_ARG(Tptr, paramsp);
 647     unsigned count = gles2_GetCount(pname);
 648     GLfloat params [16];
 649     unsigned i = 0;
 650     for (i = 0; i < count; ++i) {
 651         params[i] = gles2_get_TGLfloat(s, paramsp + i*sizeof(TGLfloat));
 652     }
 653     GLES2_BARRIER_ARG_NORET;
 654
 655     hgl.glMaterialfv(face, pname, params);
 656 }
 657
 658 GLES2_CB(glMultMatrixf)
 659 {
 660     GLES2_ARG(Tptr, mp);
 661     unsigned count = gles1_count_glMultMatrixf;
 662     GLfloat m [16];
 663     unsigned i = 0;
 664     for (i = 0; i < count; ++i) {
 665         m[i] = gles2_get_TGLfloat(s, mp + i*sizeof(TGLfloat));
 666     }
 667     GLES2_BARRIER_ARG_NORET;
 668
 669     hgl.glMultMatrixf(m);
 670 }
 671
 672 GLES2_CB(glMultiTexCoord4f)
 673 {
 674     GLES2_ARG(TGLenum, target);
 675     GLES2_ARG(TGLfloat, ps);
 676     GLES2_ARG(TGLfloat, t);
 677     GLES2_ARG(TGLfloat, rr);
 678     GLES2_ARG(TGLfloat, q);
 679     GLES2_BARRIER_ARG_NORET;
 680
 681     hgl.glMultiTexCoord4f(target, ps, t, rr, q);
 682 }
 683
 684 GLES2_CB(glNormal3f)
 685 {
 686     GLES2_ARG(TGLfloat, nx);
 687     GLES2_ARG(TGLfloat, ny);
 688     GLES2_ARG(TGLfloat, nz);
 689     GLES2_BARRIER_ARG_NORET;
 690
 691     hgl.glNormal3f(nx, ny, nz);
 692 }
 693
 694 GLES2_CB(glOrthof)
 695 {
 696     GLES2_ARG(TGLfloat, left);
 697     GLES2_ARG(TGLfloat, right);
 698     GLES2_ARG(TGLfloat, bottom);
 699     GLES2_ARG(TGLfloat, top);
 700     GLES2_ARG(TGLfloat, zNear);
 701     GLES2_ARG(TGLfloat, zFar);
 702     GLES2_BARRIER_ARG_NORET;
 703
 704     hgl.glOrthof(left, right, bottom, top, zNear, zFar);
 705 }
 706
 707 GLES2_CB(glPointParameterf)
 708 {
 709     GLES2_ARG(TGLenum, pname);
 710     GLES2_ARG(TGLfloat, param);
 711     GLES2_BARRIER_ARG_NORET;
 712
 713     hgl.glPointParameterf(pname, param);
 714 }
 715
 716 GLES2_CB(glPointParameterfv)
 717 {
 718     GLES2_ARG(TGLenum, pname);
 719     GLES2_ARG(Tptr, paramsp);
 720     unsigned count = gles2_GetCount(pname);
 721     GLfloat params [16];
 722     unsigned i = 0;
 723     for (i = 0; i < count; ++i) {
 724         params[i] = gles2_get_TGLfloat(s, paramsp + i*sizeof(TGLfloat));
 725     }
 726     GLES2_BARRIER_ARG_NORET;
 727
 728     hgl.glPointParameterfv(pname, params);
 729 }
 730
 731 GLES2_CB(glPointSize)
 732 {
 733     GLES2_ARG(TGLfloat, size);
 734     GLES2_BARRIER_ARG_NORET;
 735
 736     hgl.glPointSize(size);
 737 }
 738
 739 GLES2_CB(glRotatef)
 740 {
 741     GLES2_ARG(TGLfloat, angle);
 742     GLES2_ARG(TGLfloat, x);
 743     GLES2_ARG(TGLfloat, y);
 744     GLES2_ARG(TGLfloat, z);
 745     GLES2_BARRIER_ARG_NORET;
 746
 747     hgl.glRotatef(angle, x, y, z);
 748 }
 749
 750 GLES2_CB(glScalef)
 751 {
 752     GLES2_ARG(TGLfloat, x);
 753     GLES2_ARG(TGLfloat, y);
 754     GLES2_ARG(TGLfloat, z);
 755     GLES2_BARRIER_ARG_NORET;
 756
 757     hgl.glScalef(x, y, z);
 758 }
 759
 760 GLES2_CB(glTexEnvf)
 761 {
 762     GLES2_ARG(TGLenum, target);
 763     GLES2_ARG(TGLenum, pname);
 764     GLES2_ARG(TGLfloat, param);
 765     GLES2_BARRIER_ARG_NORET;
 766
 767     hgl.glTexEnvf(target, pname, param);
 768 }
 769
 770 GLES2_CB(glTexEnvfv)
 771 {
 772     GLES2_ARG(TGLenum, target);
 773     GLES2_ARG(TGLenum, pname);
 774     GLES2_ARG(Tptr, paramsp);
 775     unsigned count = gles2_GetCount(pname);
 776     GLfloat params [16];
 777     unsigned i = 0;
 778     for (i = 0; i < count; ++i) {
 779         params[i] = gles2_get_TGLfloat(s, paramsp + i*sizeof(TGLfloat));
 780     }
 781     GLES2_BARRIER_ARG_NORET;
 782
 783     hgl.glTexEnvfv(target, pname, params);
 784 }
 785
 786 GLES2_CB(glTranslatef)
 787 {
 788     GLES2_ARG(TGLfloat, x);
 789     GLES2_ARG(TGLfloat, y);
 790     GLES2_ARG(TGLfloat, z);
 791     GLES2_BARRIER_ARG_NORET;
 792
 793     hgl.glTranslatef(x, y, z);
 794 }
 795
 796 GLES2_CB(glAlphaFuncx)
 797 {
 798     GLES2_ARG(TGLenum, func);
 799     GLES2_ARG(TGLclampx, ref);
 800     GLES2_BARRIER_ARG_NORET;
 801
 802     hgl.glAlphaFuncx(func, ref);
 803 }
 804
 805 GLES2_CB(glClearColorx)
 806 {
 807     GLES2_ARG(TGLclampx, red);
 808     GLES2_ARG(TGLclampx, green);
 809     GLES2_ARG(TGLclampx, blue);
 810     GLES2_ARG(TGLclampx, alpha);
 811     GLES2_BARRIER_ARG_NORET;
 812
 813     hgl.glClearColorx(red, green, blue, alpha);
 814 }
 815
 816 GLES2_CB(glClearDepthx)
 817 {
 818     GLES2_ARG(TGLclampx, depth);
 819     GLES2_BARRIER_ARG_NORET;
 820
 821     hgl.glClearDepthx(depth);
 822 }
 823
 824 GLES2_CB(glClientActiveTexture)
 825 {
 826     GLES2_ARG(TGLenum, texture);
 827     GLES2_BARRIER_ARG_NORET;
 828
 829     hgl.glClientActiveTexture(texture);
 830 }
 831
 832 GLES2_CB(glClipPlanex)
 833 {
 834     GLES2_ARG(TGLenum, plane);
 835     GLES2_ARG(Tptr, equationp);
 836     unsigned count = gles1_count_glClipPlanex;
 837     GLfixed equation [16];
 838     unsigned i = 0;
 839     for (i = 0; i < count; ++i) {
 840         equation[i] = gles2_get_TGLfixed(s, equationp + i*sizeof(TGLfixed));
 841     }
 842     GLES2_BARRIER_ARG_NORET;
 843
 844     hgl.glClipPlanex(plane, equation);
 845 }
 846
 847 GLES2_CB(glColor4ub)
 848 {
 849     GLES2_ARG(TGLubyte, red);
 850     GLES2_ARG(TGLubyte, green);
 851     GLES2_ARG(TGLubyte, blue);
 852     GLES2_ARG(TGLubyte, alpha);
 853     GLES2_BARRIER_ARG_NORET;
 854
 855     hgl.glColor4ub(red, green, blue, alpha);
 856 }
 857
 858 GLES2_CB(glColor4x)
 859 {
 860     GLES2_ARG(TGLfixed, red);
 861     GLES2_ARG(TGLfixed, green);
 862     GLES2_ARG(TGLfixed, blue);
 863     GLES2_ARG(TGLfixed, alpha);
 864     GLES2_BARRIER_ARG_NORET;
 865
 866     hgl.glColor4x(red, green, blue, alpha);
 867 }
 868
 869 GLES2_CB(glColorPointer)
 870 {
 871     GLES2_ARG(TGLint, size);
 872     GLES2_ARG(TGLenum, type);
 873     GLES2_ARG(TGLsizei, stride);
 874     GLES2_ARG(Tptr, pointerp);
 875     GLES2_BARRIER_ARG_NORET;
 876
 877     GLint buffer;
 878     hgl.glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &buffer);
 879
 880     gles2_Context * ctx = c->context[context_index];
 881
 882     gles2_Array *va = ctx->arrays + (gles1_num_glColorPointer);
 883     va->size = size;
 884     va->type = type;
 885     va->stride = stride;
 886     va->tptr = pointerp;
 887     va->apply = gles1_apply_glColorPointer;
 888     va->enabled = 1;
 889     va->buffer = buffer;
 890
 891     if(buffer) {
 892         GLES2_PRINT("Color array data from buffer %d with offset 0x%x (%d elements every %d bytes)\n",
 893         buffer, pointerp, size, stride);
 894         va->ptr = (void*)(intptr_t)va->tptr;
 895         va->delta = 0;
 896         //apply immediately
 897         va->apply(va);
 898     } else {
 899         GLES2_PRINT("Array glColorPointer at 0x%x (%d elements every %d bytes)\n",
 900         pointerp, size, stride);
 901     }
 902 }
 903
 904 GLES2_CB(glDepthRangex)
 905 {
 906     GLES2_ARG(TGLclampx, zNear);
 907     GLES2_ARG(TGLclampx, zFar);
 908     GLES2_BARRIER_ARG_NORET;
 909
 910     hgl.glDepthRangex(zNear, zFar);
 911 }
 912
 913 GLES2_CB(glFogx)
 914 {
 915     GLES2_ARG(TGLenum, pname);
 916     GLES2_ARG(TGLfixed, param);
 917     GLES2_BARRIER_ARG_NORET;
 918
 919     hgl.glFogx(pname, param);
 920 }
 921
 922 GLES2_CB(glFogxv)
 923 {
 924     GLES2_ARG(TGLenum, pname);
 925     GLES2_ARG(Tptr, paramsp);
 926     unsigned count = gles2_GetCount(pname);
 927     GLfixed params [16];
 928     unsigned i = 0;
 929     for (i = 0; i < count; ++i) {
 930         params[i] = gles2_get_TGLfixed(s, paramsp + i*sizeof(TGLfixed));
 931     }
 932     GLES2_BARRIER_ARG_NORET;
 933
 934     hgl.glFogxv(pname, params);
 935 }
 936
 937 GLES2_CB(glFrustumx)
 938 {
 939     GLES2_ARG(TGLfixed, left);
 940     GLES2_ARG(TGLfixed, right);
 941     GLES2_ARG(TGLfixed, bottom);
 942     GLES2_ARG(TGLfixed, top);
 943     GLES2_ARG(TGLfixed, zNear);
 944     GLES2_ARG(TGLfixed, zFar);
 945     GLES2_BARRIER_ARG_NORET;
 946
 947     hgl.glFrustumx(left, right, bottom, top, zNear, zFar);
 948 }
 949
 950 GLES2_CB(glGetClipPlanex)
 951 {
 952     GLES2_ARG(TGLenum, pname);
 953     GLES2_ARG(Tptr, eqnp);
 954     GLES2_BARRIER_ARG_NORET;
 955     unsigned count = gles2_GetCount(pname);
 956     GLfixed eqn [16];
 957
 958     hgl.glGetClipPlanex(pname, eqn);
 959     unsigned i = 0;
 960     for (i = 0; i < count; ++i) {
 961         gles2_put_TGLfixed(s, eqnp + i*sizeof(TGLfixed), eqn[i]);
 962     }
 963 }
 964
 965 GLES2_CB(glGetFixedv)
 966 {
 967     GLES2_ARG(TGLenum, pname);
 968     GLES2_ARG(Tptr, paramsp);
 969     GLES2_BARRIER_ARG_NORET;
 970     unsigned count = gles2_GetCount(pname);
 971     GLfixed params [16];
 972
 973     hgl.glGetFixedv(pname, params);
 974     unsigned i = 0;
 975     for (i = 0; i < count; ++i) {
 976         gles2_put_TGLfixed(s, paramsp + i*sizeof(TGLfixed), params[i]);
 977     }
 978 }
 979
 980 GLES2_CB(glGetLightxv)
 981 {
 982     GLES2_ARG(TGLenum, light);
 983     GLES2_ARG(TGLenum, pname);
 984     GLES2_ARG(Tptr, paramsp);
 985     GLES2_BARRIER_ARG_NORET;
 986     unsigned count = gles2_GetCount(pname);
 987     GLfixed params [16];
 988
 989     hgl.glGetLightxv(light, pname, params);
 990     unsigned i = 0;
 991     for (i = 0; i < count; ++i) {
 992         gles2_put_TGLfixed(s, paramsp + i*sizeof(TGLfixed), params[i]);
 993     }
 994 }
 995
 996 GLES2_CB(glGetMaterialxv)
 997 {
 998     GLES2_ARG(TGLenum, face);
 999     GLES2_ARG(TGLenum, pname);
1000     GLES2_ARG(Tptr, paramsp);
1001     GLES2_BARRIER_ARG_NORET;
1002     unsigned count = gles2_GetCount(pname);
1003     GLfixed params [16];
1004
1005     hgl.glGetMaterialxv(face, pname, params);
1006     unsigned i = 0;
1007     for (i = 0; i < count; ++i) {
1008         gles2_put_TGLfixed(s, paramsp + i*sizeof(TGLfixed), params[i]);
1009     }
1010 }
1011
1012 GLES2_CB(glGetTexEnviv)
1013 {
1014     GLES2_ARG(TGLenum, env);
1015     GLES2_ARG(TGLenum, pname);
1016     GLES2_ARG(Tptr, paramsp);
1017     GLES2_BARRIER_ARG_NORET;
1018     unsigned count = gles2_GetCount(pname);
1019     GLint params [16];
1020
1021     hgl.glGetTexEnviv(env, pname, params);
1022     unsigned i = 0;
1023     for (i = 0; i < count; ++i) {
1024         gles2_put_TGLint(s, paramsp + i*sizeof(TGLint), params[i]);
1025     }
1026 }
1027
1028 GLES2_CB(glGetTexEnvxv)
1029 {
1030     GLES2_ARG(TGLenum, env);
1031     GLES2_ARG(TGLenum, pname);
1032     GLES2_ARG(Tptr, paramsp);
1033     GLES2_BARRIER_ARG_NORET;
1034     unsigned count = gles2_GetCount(pname);
1035     GLfixed params [16];
1036
1037     hgl.glGetTexEnvxv(env, pname, params);
1038     unsigned i = 0;
1039     for (i = 0; i < count; ++i) {
1040         gles2_put_TGLfixed(s, paramsp + i*sizeof(TGLfixed), params[i]);
1041     }
1042 }
1043
1044 GLES2_CB(glGetTexParameterxv)
1045 {
1046     GLES2_ARG(TGLenum, target);
1047     GLES2_ARG(TGLenum, pname);
1048     GLES2_ARG(Tptr, paramsp);
1049     GLES2_BARRIER_ARG_NORET;
1050     unsigned count = gles2_GetCount(pname);
1051     GLfixed params [16];
1052
1053     hgl.glGetTexParameterxv(target, pname, params);
1054     unsigned i = 0;
1055     for (i = 0; i < count; ++i) {
1056         gles2_put_TGLfixed(s, paramsp + i*sizeof(TGLfixed), params[i]);
1057     }
1058 }
1059
1060 GLES2_CB(glLightModelx)
1061 {
1062     GLES2_ARG(TGLenum, pname);
1063     GLES2_ARG(TGLfixed, param);
1064     GLES2_BARRIER_ARG_NORET;
1065
1066     hgl.glLightModelx(pname, param);
1067 }
1068
1069 GLES2_CB(glLightModelxv)
1070 {
1071     GLES2_ARG(TGLenum, pname);
1072     GLES2_ARG(Tptr, paramsp);
1073     unsigned count = gles2_GetCount(pname);
1074     GLfixed params [16];
1075     unsigned i = 0;
1076     for (i = 0; i < count; ++i) {
1077         params[i] = gles2_get_TGLfixed(s, paramsp + i*sizeof(TGLfixed));
1078     }
1079     GLES2_BARRIER_ARG_NORET;
1080
1081     hgl.glLightModelxv(pname, params);
1082 }
1083
1084 GLES2_CB(glLightx)
1085 {
1086     GLES2_ARG(TGLenum, light);
1087     GLES2_ARG(TGLenum, pname);
1088     GLES2_ARG(TGLfixed, param);
1089     GLES2_BARRIER_ARG_NORET;
1090
1091     hgl.glLightx(light, pname, param);
1092 }
1093
1094 GLES2_CB(glLightxv)
1095 {
1096     GLES2_ARG(TGLenum, light);
1097     GLES2_ARG(TGLenum, pname);
1098     GLES2_ARG(Tptr, paramsp);
1099     unsigned count = gles2_GetCount(pname);
1100     GLfixed params [16];
1101     unsigned i = 0;
1102     for (i = 0; i < count; ++i) {
1103         params[i] = gles2_get_TGLfixed(s, paramsp + i*sizeof(TGLfixed));
1104     }
1105     GLES2_BARRIER_ARG_NORET;
1106
1107     hgl.glLightxv(light, pname, params);
1108 }
1109
1110 GLES2_CB(glLineWidthx)
1111 {
1112     GLES2_ARG(TGLfixed, width);
1113     GLES2_BARRIER_ARG_NORET;
1114
1115     hgl.glLineWidthx(width);
1116 }
1117
1118 GLES2_CB(glLoadIdentity)
1119 {
1120     GLES2_BARRIER_ARG_NORET;
1121
1122     hgl.glLoadIdentity();
1123 }
1124
1125 GLES2_CB(glLoadMatrixx)
1126 {
1127     GLES2_ARG(Tptr, mp);
1128     unsigned count = gles1_count_glLoadMatrixx;
1129     GLfixed m [16];
1130     unsigned i = 0;
1131     for (i = 0; i < count; ++i) {
1132         m[i] = gles2_get_TGLfixed(s, mp + i*sizeof(TGLfixed));
1133     }
1134     GLES2_BARRIER_ARG_NORET;
1135
1136     hgl.glLoadMatrixx(m);
1137 }
1138
1139 GLES2_CB(glLogicOp)
1140 {
1141     GLES2_ARG(TGLenum, opcode);
1142     GLES2_BARRIER_ARG_NORET;
1143
1144     hgl.glLogicOp(opcode);
1145 }
1146
1147 GLES2_CB(glMaterialx)
1148 {
1149     GLES2_ARG(TGLenum, face);
1150     GLES2_ARG(TGLenum, pname);
1151     GLES2_ARG(TGLfixed, param);
1152     GLES2_BARRIER_ARG_NORET;
1153
1154     hgl.glMaterialx(face, pname, param);
1155 }
1156
1157 GLES2_CB(glMaterialxv)
1158 {
1159     GLES2_ARG(TGLenum, face);
1160     GLES2_ARG(TGLenum, pname);
1161     GLES2_ARG(Tptr, paramsp);
1162     unsigned count = gles2_GetCount(pname);
1163     GLfixed params [16];
1164     unsigned i = 0;
1165     for (i = 0; i < count; ++i) {
1166         params[i] = gles2_get_TGLfixed(s, paramsp + i*sizeof(TGLfixed));
1167     }
1168     GLES2_BARRIER_ARG_NORET;
1169
1170     hgl.glMaterialxv(face, pname, params);
1171 }
1172
1173 GLES2_CB(glMatrixMode)
1174 {
1175     GLES2_ARG(TGLenum, mode);
1176     GLES2_BARRIER_ARG_NORET;
1177
1178     hgl.glMatrixMode(mode);
1179 }
1180
1181 GLES2_CB(glMultMatrixx)
1182 {
1183     GLES2_ARG(Tptr, mp);
1184     unsigned count = gles1_count_glMultMatrixx;
1185     GLfixed m [16];
1186     unsigned i = 0;
1187     for (i = 0; i < count; ++i) {
1188         m[i] = gles2_get_TGLfixed(s, mp + i*sizeof(TGLfixed));
1189     }
1190     GLES2_BARRIER_ARG_NORET;
1191
1192     hgl.glMultMatrixx(m);
1193 }
1194
1195 GLES2_CB(glMultiTexCoord4x)
1196 {
1197     GLES2_ARG(TGLenum, target);
1198     GLES2_ARG(TGLfixed, ps);
1199     GLES2_ARG(TGLfixed, t);
1200     GLES2_ARG(TGLfixed, rr);
1201     GLES2_ARG(TGLfixed, q);
1202     GLES2_BARRIER_ARG_NORET;
1203
1204     hgl.glMultiTexCoord4x(target, ps, t, rr, q);
1205 }
1206
1207 GLES2_CB(glNormal3x)
1208 {
1209     GLES2_ARG(TGLfixed, nx);
1210     GLES2_ARG(TGLfixed, ny);
1211     GLES2_ARG(TGLfixed, nz);
1212     GLES2_BARRIER_ARG_NORET;
1213
1214     hgl.glNormal3x(nx, ny, nz);
1215 }
1216
1217 GLES2_CB(glNormalPointer)
1218 {
1219     GLES2_ARG(TGLenum, type);
1220     GLES2_ARG(TGLsizei, stride);
1221     GLES2_ARG(Tptr, pointerp);
1222     GLES2_BARRIER_ARG_NORET;
1223
1224     GLint buffer;
1225     hgl.glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &buffer);
1226
1227     gles2_Context * ctx = c->context[context_index];
1228
1229     gles2_Array *va = ctx->arrays + gles1_num_glNormalPointer;
1230     va->type = type;
1231     va->stride = stride;
1232     va->tptr = pointerp;
1233     va->size = gles1_size_glNormalPointer;
1234     va->apply = gles1_apply_glNormalPointer;
1235     va->enabled = 1;
1236     va->buffer = buffer;
1237
1238     if(buffer) {
1239         GLES2_PRINT("Normal array data from buffer %d with offset 0x%x (3 elements every %d bytes)\n",
1240         buffer, pointerp, stride);
1241         va->ptr = (void*)(intptr_t)va->tptr;
1242         va->delta = 0;
1243         //apply immediately
1244         va->apply(va);
1245     } else {
1246         GLES2_PRINT("Array glNormalPointer at 0x%x (3 elements every %d bytes)\n",
1247         pointerp, stride);
1248     }
1249 }
1250
1251 GLES2_CB(glOrthox)
1252 {
1253     GLES2_ARG(TGLfixed, left);
1254     GLES2_ARG(TGLfixed, right);
1255     GLES2_ARG(TGLfixed, bottom);
1256     GLES2_ARG(TGLfixed, top);
1257     GLES2_ARG(TGLfixed, zNear);
1258     GLES2_ARG(TGLfixed, zFar);
1259     GLES2_BARRIER_ARG_NORET;
1260
1261     hgl.glOrthox(left, right, bottom, top, zNear, zFar);
1262 }
1263
1264 GLES2_CB(glPointParameterx)
1265 {
1266     GLES2_ARG(TGLenum, pname);
1267     GLES2_ARG(TGLfixed, param);
1268     GLES2_BARRIER_ARG_NORET;
1269
1270     hgl.glPointParameterx(pname, param);
1271 }
1272
1273 GLES2_CB(glPointParameterxv)
1274 {
1275     GLES2_ARG(TGLenum, pname);
1276     GLES2_ARG(Tptr, paramsp);
1277     unsigned count = gles2_GetCount(pname);
1278     GLfixed params [16];
1279     unsigned i = 0;
1280     for (i = 0; i < count; ++i) {
1281         params[i] = gles2_get_TGLfixed(s, paramsp + i*sizeof(TGLfixed));
1282     }
1283     GLES2_BARRIER_ARG_NORET;
1284
1285     hgl.glPointParameterxv(pname, params);
1286 }
1287
1288 GLES2_CB(glPointSizex)
1289 {
1290     GLES2_ARG(TGLfixed, size);
1291     GLES2_BARRIER_ARG_NORET;
1292
1293     hgl.glPointSizex(size);
1294 }
1295
1296 GLES2_CB(glPolygonOffsetx)
1297 {
1298     GLES2_ARG(TGLfixed, factor);
1299     GLES2_ARG(TGLfixed, units);
1300     GLES2_BARRIER_ARG_NORET;
1301
1302     hgl.glPolygonOffsetx(factor, units);
1303 }
1304
1305 GLES2_CB(glPopMatrix)
1306 {
1307     GLES2_BARRIER_ARG_NORET;
1308
1309     hgl.glPopMatrix();
1310 }
1311
1312 GLES2_CB(glPushMatrix)
1313 {
1314     GLES2_BARRIER_ARG_NORET;
1315
1316     hgl.glPushMatrix();
1317 }
1318
1319 GLES2_CB(glRotatex)
1320 {
1321     GLES2_ARG(TGLfixed, angle);
1322     GLES2_ARG(TGLfixed, x);
1323     GLES2_ARG(TGLfixed, y);
1324     GLES2_ARG(TGLfixed, z);
1325     GLES2_BARRIER_ARG_NORET;
1326
1327     hgl.glRotatex(angle, x, y, z);
1328 }
1329
1330 GLES2_CB(glSampleCoveragex)
1331 {
1332     GLES2_ARG(TGLclampx, value);
1333     GLES2_ARG(TGLboolean, invert);
1334     GLES2_BARRIER_ARG_NORET;
1335
1336     hgl.glSampleCoveragex(value, invert);
1337 }
1338
1339 GLES2_CB(glScalex)
1340 {
1341     GLES2_ARG(TGLfixed, x);
1342     GLES2_ARG(TGLfixed, y);
1343     GLES2_ARG(TGLfixed, z);
1344     GLES2_BARRIER_ARG_NORET;
1345
1346     hgl.glScalex(x, y, z);
1347 }
1348
1349 GLES2_CB(glShadeModel)
1350 {
1351     GLES2_ARG(TGLenum, mode);
1352     GLES2_BARRIER_ARG_NORET;
1353
1354     hgl.glShadeModel(mode);
1355 }
1356
1357 GLES2_CB(glTexCoordPointer)
1358 {
1359     GLES2_ARG(TGLint, size);
1360     GLES2_ARG(TGLenum, type);
1361     GLES2_ARG(TGLsizei, stride);
1362     GLES2_ARG(Tptr, pointerp);
1363     GLES2_BARRIER_ARG_NORET;
1364
1365     GLint buffer;
1366     hgl.glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &buffer);
1367
1368     gles2_Context * ctx = c->context[context_index];
1369     gles2_Array *va = ctx->arrays + gles1_num_glTexCoordPointer;
1370     va->size = size;
1371     va->type = type;
1372     va->stride = stride;
1373     va->tptr = pointerp;
1374     va->apply = gles1_apply_glTexCoordPointer;
1375     va->enabled = 1;
1376     va->buffer = buffer;
1377
1378     if(buffer) {
1379         GLES2_PRINT("TexCoord array data from buffer %d with offset 0x%x (%d elements every %d bytes)\n",
1380         buffer, pointerp, size, stride);
1381         va->ptr = (void*)(intptr_t)va->tptr;
1382         va->delta = 0;
1383         //apply immediately
1384         va->apply(va);
1385     } else {
1386         GLES2_PRINT("Array glTexCoordPointer at 0x%x (%d elements every %d bytes)\n",
1387         pointerp, size, stride);
1388     }
1389 }
1390
1391 GLES2_CB(glTexEnvi)
1392 {
1393     GLES2_ARG(TGLenum, target);
1394     GLES2_ARG(TGLenum, pname);
1395     GLES2_ARG(TGLint, param);
1396     GLES2_BARRIER_ARG_NORET;
1397
1398     hgl.glTexEnvi(target, pname, param);
1399 }
1400
1401 GLES2_CB(glTexEnvx)
1402 {
1403     GLES2_ARG(TGLenum, target);
1404     GLES2_ARG(TGLenum, pname);
1405     GLES2_ARG(TGLfixed, param);
1406     GLES2_BARRIER_ARG_NORET;
1407
1408     hgl.glTexEnvx(target, pname, param);
1409 }
1410
1411 GLES2_CB(glTexEnviv)
1412 {
1413     GLES2_ARG(TGLenum, target);
1414     GLES2_ARG(TGLenum, pname);
1415     GLES2_ARG(Tptr, paramsp);
1416     unsigned count = gles2_GetCount(pname);
1417     GLint params [16];
1418     unsigned i = 0;
1419     for (i = 0; i < count; ++i) {
1420         params[i] = gles2_get_TGLint(s, paramsp + i*sizeof(TGLint));
1421     }
1422     GLES2_BARRIER_ARG_NORET;
1423
1424     hgl.glTexEnviv(target, pname, params);
1425 }
1426
1427 GLES2_CB(glTexEnvxv)
1428 {
1429     GLES2_ARG(TGLenum, target);
1430     GLES2_ARG(TGLenum, pname);
1431     GLES2_ARG(Tptr, paramsp);
1432     unsigned count = gles2_GetCount(pname);
1433     GLfixed params [16];
1434     unsigned i = 0;
1435     for (i = 0; i < count; ++i) {
1436         params[i] = gles2_get_TGLfixed(s, paramsp + i*sizeof(TGLfixed));
1437     }
1438     GLES2_BARRIER_ARG_NORET;
1439
1440     hgl.glTexEnvxv(target, pname, params);
1441 }
1442
1443 GLES2_CB(glTexParameterx)
1444 {
1445     GLES2_ARG(TGLenum, target);
1446     GLES2_ARG(TGLenum, pname);
1447     GLES2_ARG(TGLfixed, param);
1448     GLES2_BARRIER_ARG_NORET;
1449
1450     hgl.glTexParameterx(target, pname, param);
1451 }
1452
1453 GLES2_CB(glTexParameterxv)
1454 {
1455     GLES2_ARG(TGLenum, target);
1456     GLES2_ARG(TGLenum, pname);
1457     GLES2_ARG(Tptr, paramsp);
1458     unsigned count = gles2_GetCount(pname);
1459     GLfixed params [16];
1460     unsigned i = 0;
1461     for (i = 0; i < count; ++i) {
1462         params[i] = gles2_get_TGLfixed(s, paramsp + i*sizeof(TGLfixed));
1463     }
1464     GLES2_BARRIER_ARG_NORET;
1465
1466     hgl.glTexParameterxv(target, pname, params);
1467 }
1468
1469 GLES2_CB(glTranslatex)
1470 {
1471     GLES2_ARG(TGLfixed, x);
1472     GLES2_ARG(TGLfixed, y);
1473     GLES2_ARG(TGLfixed, z);
1474     GLES2_BARRIER_ARG_NORET;
1475
1476     hgl.glTranslatex(x, y, z);
1477 }
1478
1479 GLES2_CB(glVertexPointer)
1480 {
1481     GLES2_ARG(TGLint, size);
1482     GLES2_ARG(TGLenum, type);
1483     GLES2_ARG(TGLsizei, stride);
1484     GLES2_ARG(Tptr, pointerp);
1485     GLES2_BARRIER_ARG_NORET;
1486
1487     GLint buffer;
1488     hgl.glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &buffer);
1489
1490     gles2_Context * ctx = c->context[context_index];
1491
1492     gles2_Array *va = ctx->arrays + gles1_num_glVertexPointer;
1493     va->size = size;
1494     va->type = type;
1495     va->stride = stride;
1496     va->tptr = pointerp;
1497     va->apply = gles1_apply_glVertexPointer;
1498     va->enabled = 1;
1499     va->buffer = buffer;
1500
1501     if(buffer) {
1502         GLES2_PRINT("Vertex array data from buffer %d with offset 0x%x (%d elements every %d bytes)\n",
1503         buffer, pointerp, size, stride);
1504         va->ptr = (void*)(intptr_t)va->tptr;
1505         va->delta = 0;
1506         //apply immediately
1507         va->apply(va);
1508     } else {
1509         GLES2_PRINT("Array glVertexPointer at 0x%x (%d elements every %d bytes)\n",
1510         pointerp, size, stride);
1511     }
1512 }
1513
1514 GLES2_CB(glPointSizePointerOES)
1515 {
1516     GLES2_ARG(TGLenum, type);
1517     GLES2_ARG(TGLsizei, stride);
1518     GLES2_ARG(Tptr, pointerp);
1519     GLES2_BARRIER_ARG_NORET;
1520
1521     GLint buffer;
1522     hgl.glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &buffer);
1523
1524     gles2_Context * ctx = c->context[context_index];
1525
1526     gles2_Array *va = ctx->arrays + gles1_num_glPointSizePointer;
1527     va->size = gles1_size_glPointSizePointer;
1528     va->type = type;
1529     va->stride = stride;
1530     va->tptr = pointerp;
1531     va->apply = gles1_apply_glPointSizePointer;
1532     va->enabled = 1;
1533     va->buffer = buffer;
1534     if(buffer) {
1535         GLES2_PRINT("PointSize array data from buffer %d with offset 0x%x (1 elements every %d bytes)\n",
1536         buffer, pointerp, stride);
1537         va->ptr = (void*)(intptr_t)va->tptr;
1538         va->delta = 0;
1539         //apply immediately
1540         va->apply(va);
1541     } else {
1542         GLES2_PRINT("Array glPointSizePointerOES at 0x%x (1 elements every %d bytes)\n",
1543         pointerp, stride);
1544     }
1545 }