opengl/libagl/array.cpp

   1 /*
   2 ** Copyright 2006, The Android Open Source Project
   3 **
   4 ** Licensed under the Apache License, Version 2.0 (the "License");
   5 ** you may not use this file except in compliance with the License.
   6 ** You may obtain a copy of the License at
   7 **
   8 **     http://www.apache.org/licenses/LICENSE-2.0
   9 **
  10 ** Unless required by applicable law or agreed to in writing, software
  11 ** distributed under the License is distributed on an "AS IS" BASIS,
  12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 ** See the License for the specific language governing permissions and
  14 ** limitations under the License.
  15 */
  16
  17 #include <stdlib.h>
  18 #include <stdio.h>
  19
  20 #include "context.h"
  21 #include "fp.h"
  22 #include "state.h"
  23 #include "matrix.h"
  24 #include "vertex.h"
  25 #include "light.h"
  26 #include "primitives.h"
  27 #include "texture.h"
  28 #include "BufferObjectManager.h"
  29
  30 // ----------------------------------------------------------------------------
  31
  32 #define VC_CACHE_STATISTICS     0
  33 #define VC_CACHE_TYPE_NONE      0
  34 #define VC_CACHE_TYPE_INDEXED   1
  35 #define VC_CACHE_TYPE_LRU       2
  36 #define VC_CACHE_TYPE           VC_CACHE_TYPE_INDEXED
  37
  38 #if VC_CACHE_STATISTICS
  39 #include <utils/Timers.h>
  40 #endif
  41
  42 // ----------------------------------------------------------------------------
  43
  44 namespace android {
  45
  46 static void validate_arrays(ogles_context_t* c, GLenum mode);
  47
  48 static void compileElements__generic(ogles_context_t*,
  49         vertex_t*, GLint, GLsizei);
  50 static void compileElement__generic(ogles_context_t*,
  51         vertex_t*, GLint);
  52
  53 static void drawPrimitivesPoints(ogles_context_t*, GLint, GLsizei);
  54 static void drawPrimitivesLineStrip(ogles_context_t*, GLint, GLsizei);
  55 static void drawPrimitivesLineLoop(ogles_context_t*, GLint, GLsizei);
  56 static void drawPrimitivesLines(ogles_context_t*, GLint, GLsizei);
  57 static void drawPrimitivesTriangleStrip(ogles_context_t*, GLint, GLsizei);
  58 static void drawPrimitivesTriangleFan(ogles_context_t*, GLint, GLsizei);
  59 static void drawPrimitivesTriangles(ogles_context_t*, GLint, GLsizei);
  60
  61 static void drawIndexedPrimitivesPoints(ogles_context_t*,
  62         GLsizei, const GLvoid*);
  63 static void drawIndexedPrimitivesLineStrip(ogles_context_t*,
  64         GLsizei, const GLvoid*);
  65 static void drawIndexedPrimitivesLineLoop(ogles_context_t*,
  66         GLsizei, const GLvoid*);
  67 static void drawIndexedPrimitivesLines(ogles_context_t*,
  68         GLsizei, const GLvoid*);
  69 static void drawIndexedPrimitivesTriangleStrip(ogles_context_t*,
  70         GLsizei, const GLvoid*);
  71 static void drawIndexedPrimitivesTriangleFan(ogles_context_t*,
  72         GLsizei, const GLvoid*);
  73 static void drawIndexedPrimitivesTriangles(ogles_context_t*,
  74         GLsizei, const GLvoid*);
  75
  76 // ----------------------------------------------------------------------------
  77
  78 typedef void (*arrays_prims_fct_t)(ogles_context_t*, GLint, GLsizei);
  79 static const arrays_prims_fct_t drawArraysPrims[] = {
  80     drawPrimitivesPoints,
  81     drawPrimitivesLines,
  82     drawPrimitivesLineLoop,
  83     drawPrimitivesLineStrip,
  84     drawPrimitivesTriangles,
  85     drawPrimitivesTriangleStrip,
  86     drawPrimitivesTriangleFan
  87 };
  88
  89 typedef void (*elements_prims_fct_t)(ogles_context_t*, GLsizei, const GLvoid*);
  90 static const elements_prims_fct_t drawElementsPrims[] = {
  91     drawIndexedPrimitivesPoints,
  92     drawIndexedPrimitivesLines,
  93     drawIndexedPrimitivesLineLoop,
  94     drawIndexedPrimitivesLineStrip,
  95     drawIndexedPrimitivesTriangles,
  96     drawIndexedPrimitivesTriangleStrip,
  97     drawIndexedPrimitivesTriangleFan
  98 };
  99
 100 // ----------------------------------------------------------------------------
 101 #if 0
 102 #pragma mark -
 103 #endif
 104
 105 void ogles_init_array(ogles_context_t* c)
 106 {
 107     c->arrays.vertex.size = 4;
 108     c->arrays.vertex.type = GL_FLOAT;
 109     c->arrays.color.size = 4;
 110     c->arrays.color.type = GL_FLOAT;
 111     c->arrays.normal.size = 4;
 112     c->arrays.normal.type = GL_FLOAT;
 113     for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
 114         c->arrays.texture[i].size = 4;
 115         c->arrays.texture[i].type = GL_FLOAT;
 116     }
 117     c->vc.init();
 118
 119     if (!c->vc.vBuffer) {
 120         // this could have failed
 121         ogles_error(c, GL_OUT_OF_MEMORY);
 122     }
 123 }
 124
 125 void ogles_uninit_array(ogles_context_t* c)
 126 {
 127     c->vc.uninit();
 128 }
 129
 130 // ----------------------------------------------------------------------------
 131 #if 0
 132 #pragma mark -
 133 #pragma mark Array fetchers
 134 #endif
 135
 136 static void currentColor(ogles_context_t* c, GLfixed* v, const GLvoid*) {
 137     memcpy(v, c->current.color.v, sizeof(vec4_t));
 138 }
 139 static void currentColor_clamp(ogles_context_t* c, GLfixed* v, const GLvoid*) {
 140     memcpy(v, c->currentColorClamped.v, sizeof(vec4_t));
 141 }
 142 static void currentNormal(ogles_context_t* c, GLfixed* v, const GLvoid*) {
 143     memcpy(v, c->currentNormal.v, sizeof(vec3_t));
 144 }
 145 static void currentTexCoord(ogles_context_t* c, GLfixed* v, const GLvoid*) {
 146     memcpy(v, c->current.texture[c->arrays.tmu].v, sizeof(vec4_t));
 147 }
 148
 149
 150 static void fetchNop(ogles_context_t*, GLfixed*, const GLvoid*) {
 151 }
 152 static void fetch2b(ogles_context_t*, GLfixed* v, const GLbyte* p) {
 153     v[0] = gglIntToFixed(p[0]);
 154     v[1] = gglIntToFixed(p[1]);
 155 }
 156 static void fetch2s(ogles_context_t*, GLfixed* v, const GLshort* p) {
 157     v[0] = gglIntToFixed(p[0]);
 158     v[1] = gglIntToFixed(p[1]);
 159 }
 160 static void fetch2x(ogles_context_t*, GLfixed* v, const GLfixed* p) {
 161     memcpy(v, p, 2*sizeof(GLfixed));
 162 }
 163 static void fetch2f(ogles_context_t*, GLfixed* v, const GLfloat* p) {
 164     v[0] = gglFloatToFixed(p[0]);
 165     v[1] = gglFloatToFixed(p[1]);
 166 }
 167 static void fetch3b(ogles_context_t*, GLfixed* v, const GLbyte* p) {
 168     v[0] = gglIntToFixed(p[0]);
 169     v[1] = gglIntToFixed(p[1]);
 170     v[2] = gglIntToFixed(p[2]);
 171 }
 172 static void fetch3s(ogles_context_t*, GLfixed* v, const GLshort* p) {
 173     v[0] = gglIntToFixed(p[0]);
 174     v[1] = gglIntToFixed(p[1]);
 175     v[2] = gglIntToFixed(p[2]);
 176 }
 177 static void fetch3x(ogles_context_t*, GLfixed* v, const GLfixed* p) {
 178     memcpy(v, p, 3*sizeof(GLfixed));
 179 }
 180 static void fetch3f(ogles_context_t*, GLfixed* v, const GLfloat* p) {
 181     v[0] = gglFloatToFixed(p[0]);
 182     v[1] = gglFloatToFixed(p[1]);
 183     v[2] = gglFloatToFixed(p[2]);
 184 }
 185 static void fetch4b(ogles_context_t*, GLfixed* v, const GLbyte* p) {
 186     v[0] = gglIntToFixed(p[0]);
 187     v[1] = gglIntToFixed(p[1]);
 188     v[2] = gglIntToFixed(p[2]);
 189     v[3] = gglIntToFixed(p[3]);
 190 }
 191 static void fetch4s(ogles_context_t*, GLfixed* v, const GLshort* p) {
 192     v[0] = gglIntToFixed(p[0]);
 193     v[1] = gglIntToFixed(p[1]);
 194     v[2] = gglIntToFixed(p[2]);
 195     v[3] = gglIntToFixed(p[3]);
 196 }
 197 static void fetch4x(ogles_context_t*, GLfixed* v, const GLfixed* p) {
 198     memcpy(v, p, 4*sizeof(GLfixed));
 199 }
 200 static void fetch4f(ogles_context_t*, GLfixed* v, const GLfloat* p) {
 201     v[0] = gglFloatToFixed(p[0]);
 202     v[1] = gglFloatToFixed(p[1]);
 203     v[2] = gglFloatToFixed(p[2]);
 204     v[3] = gglFloatToFixed(p[3]);
 205 }
 206 static void fetchExpand4ub(ogles_context_t*, GLfixed* v, const GLubyte* p) {
 207     v[0] = GGL_UB_TO_X(p[0]);
 208     v[1] = GGL_UB_TO_X(p[1]);
 209     v[2] = GGL_UB_TO_X(p[2]);
 210     v[3] = GGL_UB_TO_X(p[3]);
 211 }
 212 static void fetchClamp4x(ogles_context_t*, GLfixed* v, const GLfixed* p) {
 213     v[0] = gglClampx(p[0]);
 214     v[1] = gglClampx(p[1]);
 215     v[2] = gglClampx(p[2]);
 216     v[3] = gglClampx(p[3]);
 217 }
 218 static void fetchClamp4f(ogles_context_t*, GLfixed* v, const GLfloat* p) {
 219     v[0] = gglClampx(gglFloatToFixed(p[0]));
 220     v[1] = gglClampx(gglFloatToFixed(p[1]));
 221     v[2] = gglClampx(gglFloatToFixed(p[2]));
 222     v[3] = gglClampx(gglFloatToFixed(p[3]));
 223 }
 224 static void fetchExpand3ub(ogles_context_t*, GLfixed* v, const GLubyte* p) {
 225     v[0] = GGL_UB_TO_X(p[0]);
 226     v[1] = GGL_UB_TO_X(p[1]);
 227     v[2] = GGL_UB_TO_X(p[2]);
 228     v[3] = 0x10000;
 229 }
 230 static void fetchClamp3x(ogles_context_t*, GLfixed* v, const GLfixed* p) {
 231     v[0] = gglClampx(p[0]);
 232     v[1] = gglClampx(p[1]);
 233     v[2] = gglClampx(p[2]);
 234     v[3] = 0x10000;
 235 }
 236 static void fetchClamp3f(ogles_context_t*, GLfixed* v, const GLfloat* p) {
 237     v[0] = gglClampx(gglFloatToFixed(p[0]));
 238     v[1] = gglClampx(gglFloatToFixed(p[1]));
 239     v[2] = gglClampx(gglFloatToFixed(p[2]));
 240     v[3] = 0x10000;
 241 }
 242 static void fetchExpand3b(ogles_context_t*, GLfixed* v, const GLbyte* p) {
 243     v[0] = GGL_B_TO_X(p[0]);
 244     v[1] = GGL_B_TO_X(p[1]);
 245     v[2] = GGL_B_TO_X(p[2]);
 246 }
 247 static void fetchExpand3s(ogles_context_t*, GLfixed* v, const GLshort* p) {
 248     v[0] = GGL_S_TO_X(p[0]);
 249     v[1] = GGL_S_TO_X(p[1]);
 250     v[2] = GGL_S_TO_X(p[2]);
 251 }
 252
 253 typedef array_t::fetcher_t fn_t;
 254
 255 static const fn_t color_fct[2][16] = { // size={3,4}, type={ub,f,x}
 256     { 0, (fn_t)fetchExpand3ub, 0, 0, 0, 0,
 257          (fn_t)fetch3f, 0, 0, 0, 0, 0,
 258          (fn_t)fetch3x },
 259     { 0, (fn_t)fetchExpand4ub, 0, 0, 0, 0,
 260          (fn_t)fetch4f, 0, 0, 0, 0, 0,
 261          (fn_t)fetch4x },
 262 };
 263 static const fn_t color_clamp_fct[2][16] = { // size={3,4}, type={ub,f,x}
 264     { 0, (fn_t)fetchExpand3ub, 0, 0, 0, 0,
 265          (fn_t)fetchClamp3f, 0, 0, 0, 0, 0,
 266          (fn_t)fetchClamp3x },
 267     { 0, (fn_t)fetchExpand4ub, 0, 0, 0, 0,
 268          (fn_t)fetchClamp4f, 0, 0, 0, 0, 0,
 269          (fn_t)fetchClamp4x },
 270 };
 271 static const fn_t normal_fct[1][16] = { // size={3}, type={b,s,f,x}
 272     { (fn_t)fetchExpand3b, 0,
 273       (fn_t)fetchExpand3s, 0, 0, 0,
 274       (fn_t)fetch3f, 0, 0, 0, 0, 0,
 275       (fn_t)fetch3x },
 276 };
 277 static const fn_t vertex_fct[3][16] = { // size={2,3,4}, type={b,s,f,x}
 278     { (fn_t)fetch2b, 0,
 279       (fn_t)fetch2s, 0, 0, 0,
 280       (fn_t)fetch2f, 0, 0, 0, 0, 0,
 281       (fn_t)fetch3x },
 282     { (fn_t)fetch3b, 0,
 283       (fn_t)fetch3s, 0, 0, 0,
 284       (fn_t)fetch3f, 0, 0, 0, 0, 0,
 285       (fn_t)fetch3x },
 286     { (fn_t)fetch4b, 0,
 287       (fn_t)fetch4s, 0, 0, 0,
 288       (fn_t)fetch4f, 0, 0, 0, 0, 0,
 289       (fn_t)fetch4x }
 290 };
 291 static const fn_t texture_fct[3][16] = { // size={2,3,4}, type={b,s,f,x}
 292     { (fn_t)fetch2b, 0,
 293       (fn_t)fetch2s, 0, 0, 0,
 294       (fn_t)fetch2f, 0, 0, 0, 0, 0,
 295       (fn_t)fetch2x },
 296     { (fn_t)fetch3b, 0,
 297       (fn_t)fetch3s, 0, 0, 0,
 298       (fn_t)fetch3f, 0, 0, 0, 0, 0,
 299       (fn_t)fetch3x },
 300     { (fn_t)fetch4b, 0,
 301       (fn_t)fetch4s, 0, 0, 0,
 302       (fn_t)fetch4f, 0, 0, 0, 0, 0,
 303       (fn_t)fetch4x }
 304 };
 305
 306 // ----------------------------------------------------------------------------
 307 #if 0
 308 #pragma mark -
 309 #pragma mark array_t
 310 #endif
 311
 312 void array_t::init(
 313         GLint size, GLenum type, GLsizei stride,
 314         const GLvoid *pointer, const buffer_t* bo, GLsizei count)
 315 {
 316     if (!stride) {
 317         stride = size;
 318         switch (type) {
 319         case GL_SHORT:
 320         case GL_UNSIGNED_SHORT:
 321             stride *= 2;
 322             break;
 323         case GL_FLOAT:
 324         case GL_FIXED:
 325             stride *= 4;
 326             break;
 327         }
 328     }
 329     this->size = size;
 330     this->type = type;
 331     this->stride = stride;
 332     this->pointer = pointer;
 333     this->bo = bo;
 334     this->bounds = count;
 335 }
 336
 337 inline void array_t::resolve()
 338 {
 339     physical_pointer = (bo) ? (bo->data + uintptr_t(pointer)) : pointer;
 340 }
 341
 342 // ----------------------------------------------------------------------------
 343 #if 0
 344 #pragma mark -
 345 #pragma mark vertex_cache_t
 346 #endif
 347
 348 void vertex_cache_t::init()
 349 {
 350     // make sure the size of vertex_t allows cache-line alignment
 351     CTA<(sizeof(vertex_t) & 0x1F) == 0> assertAlignedSize;
 352
 353     const int align = 32;
 354     const size_t s = VERTEX_BUFFER_SIZE + VERTEX_CACHE_SIZE;
 355     const size_t size = s*sizeof(vertex_t) + align;
 356     base = malloc(size);
 357     if (base) {
 358         memset(base, 0, size);
 359         vBuffer = (vertex_t*)((size_t(base) + align - 1) & ~(align-1));
 360         vCache = vBuffer + VERTEX_BUFFER_SIZE;
 361         sequence = 0;
 362     }
 363 }
 364
 365 void vertex_cache_t::uninit()
 366 {
 367     free(base);
 368     base = vBuffer = vCache = 0;
 369 }
 370
 371 void vertex_cache_t::clear()
 372 {
 373 #if VC_CACHE_STATISTICS
 374     startTime = systemTime(SYSTEM_TIME_THREAD);
 375     total = 0;
 376     misses = 0;
 377 #endif
 378
 379 #if VC_CACHE_TYPE == VC_CACHE_TYPE_LRU
 380     vertex_t* v = vBuffer;
 381     size_t count = VERTEX_BUFFER_SIZE + VERTEX_CACHE_SIZE;
 382     do {
 383         v->mru = 0;
 384         v++;
 385     } while (--count);
 386 #endif
 387
 388     sequence += INDEX_SEQ;
 389     if (sequence >= 0x80000000LU) {
 390         sequence = INDEX_SEQ;
 391         vertex_t* v = vBuffer;
 392         size_t count = VERTEX_BUFFER_SIZE + VERTEX_CACHE_SIZE;
 393         do {
 394             v->index = 0;
 395             v++;
 396         } while (--count);
 397     }
 398 }
 399
 400 #if VC_CACHE_STATISTICS
 401 void vertex_cache_t::dump_stats(GLenum mode)
 402 {
 403     nsecs_t time = systemTime(SYSTEM_TIME_THREAD) - startTime;
 404     uint32_t hits = total - misses;
 405     uint32_t prim_count;
 406     switch (mode) {
 407     case GL_POINTS:             prim_count = total;         break;
 408     case GL_LINE_STRIP:         prim_count = total - 1;     break;
 409     case GL_LINE_LOOP:          prim_count = total - 1;     break;
 410     case GL_LINES:              prim_count = total / 2;     break;
 411     case GL_TRIANGLE_STRIP:     prim_count = total - 2;     break;
 412     case GL_TRIANGLE_FAN:       prim_count = total - 2;     break;
 413     case GL_TRIANGLES:          prim_count = total / 3;     break;
 414     default:    return;
 415     }
 416     printf( "total=%5u, hits=%5u, miss=%5u, hitrate=%3u%%,"
 417             " prims=%5u, time=%6u us, prims/s=%d, v/t=%f\n",
 418             total, hits, misses, (hits*100)/total,
 419             prim_count, int(ns2us(time)), int(prim_count*float(seconds(1))/time),
 420             float(misses) / prim_count);
 421 }
 422 #else
 423 void vertex_cache_t::dump_stats(GLenum /*mode*/)
 424 {
 425 }
 426 #endif
 427
 428 // ----------------------------------------------------------------------------
 429 #if 0
 430 #pragma mark -
 431 #endif
 432
 433 static __attribute__((noinline))
 434 void enableDisableClientState(ogles_context_t* c, GLenum array, bool enable)
 435 {
 436     const int tmu = c->arrays.activeTexture;
 437     array_t* a;
 438     switch (array) {
 439     case GL_COLOR_ARRAY:            a = &c->arrays.color;           break;
 440     case GL_NORMAL_ARRAY:           a = &c->arrays.normal;          break;
 441     case GL_TEXTURE_COORD_ARRAY:    a = &c->arrays.texture[tmu];    break;
 442     case GL_VERTEX_ARRAY:           a = &c->arrays.vertex;          break;
 443     default:
 444         ogles_error(c, GL_INVALID_ENUM);
 445         return;
 446     }
 447     a->enable = enable ? GL_TRUE : GL_FALSE;
 448 }
 449
 450 // ----------------------------------------------------------------------------
 451 #if 0
 452 #pragma mark -
 453 #pragma mark Vertex Cache
 454 #endif
 455
 456 static __attribute__((noinline))
 457 vertex_t* cache_vertex(ogles_context_t* c, vertex_t* v, uint32_t index)
 458 {
 459     #if VC_CACHE_STATISTICS
 460         c->vc.misses++;
 461     #endif
 462     if (ggl_unlikely(v->locked)) {
 463         // we're just looking for an entry in the cache that is not locked.
 464         // and we know that there cannot be more than 2 locked entries
 465         // because a triangle needs at most 3 vertices.
 466         // We never use the first and second entries because they might be in
 467         // use by the striper or faner. Any other entry will do as long as
 468         // it's not locked.
 469         // We compute directly the index of a "free" entry from the locked
 470         // state of v[2] and v[3].
 471         v = c->vc.vBuffer + 2;
 472         v += v[0].locked | (v[1].locked<<1);
 473     }
 474     // note: compileElement clears v->flags
 475     c->arrays.compileElement(c, v, index);
 476     v->locked = 1;
 477     return v;
 478 }
 479
 480 static __attribute__((noinline))
 481 vertex_t* fetch_vertex(ogles_context_t* c, size_t index)
 482 {
 483     index |= c->vc.sequence;
 484
 485 #if VC_CACHE_TYPE == VC_CACHE_TYPE_INDEXED
 486
 487     vertex_t* const v = c->vc.vCache +
 488             (index & (vertex_cache_t::VERTEX_CACHE_SIZE-1));
 489
 490     if (ggl_likely(v->index == index)) {
 491         v->locked = 1;
 492         return v;
 493     }
 494     return cache_vertex(c, v, index);
 495
 496 #elif VC_CACHE_TYPE == VC_CACHE_TYPE_LRU
 497
 498     vertex_t* v = c->vc.vCache +
 499             (index & ((vertex_cache_t::VERTEX_CACHE_SIZE-1)>>1))*2;
 500
 501     // always record LRU in v[0]
 502     if (ggl_likely(v[0].index == index)) {
 503         v[0].locked = 1;
 504         v[0].mru = 0;
 505         return &v[0];
 506     }
 507
 508     if (ggl_likely(v[1].index == index)) {
 509         v[1].locked = 1;
 510         v[0].mru = 1;
 511         return &v[1];
 512     }
 513
 514     const int lru = 1 - v[0].mru;
 515     v[0].mru = lru;
 516     return cache_vertex(c, &v[lru], index);
 517
 518 #elif VC_CACHE_TYPE == VC_CACHE_TYPE_NONE
 519
 520     // just for debugging...
 521     vertex_t* v = c->vc.vBuffer + 2;
 522     return cache_vertex(c, v, index);
 523
 524 #endif
 525 }
 526
 527 // ----------------------------------------------------------------------------
 528 #if 0
 529 #pragma mark -
 530 #pragma mark Primitive Assembly
 531 #endif
 532
 533 void drawPrimitivesPoints(ogles_context_t* c, GLint first, GLsizei count)
 534 {
 535     if (ggl_unlikely(count < 1))
 536         return;
 537
 538     // vertex cache size must be multiple of 1
 539     const GLsizei vcs =
 540             (vertex_cache_t::VERTEX_BUFFER_SIZE +
 541              vertex_cache_t::VERTEX_CACHE_SIZE);
 542     do {
 543         vertex_t* v = c->vc.vBuffer;
 544         GLsizei num = count > vcs ? vcs : count;
 545         c->arrays.cull = vertex_t::CLIP_ALL;
 546         c->arrays.compileElements(c, v, first, num);
 547         first += num;
 548         count -= num;
 549         if (!c->arrays.cull) {
 550             // quick/trivial reject of the whole batch
 551             do {
 552                 const uint32_t cc = v[0].flags;
 553                 if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
 554                     c->prims.renderPoint(c, v);
 555                 v++;
 556                 num--;
 557             } while (num);
 558         }
 559     } while (count);
 560 }
 561
 562 // ----------------------------------------------------------------------------
 563
 564 void drawPrimitivesLineStrip(ogles_context_t* c, GLint first, GLsizei count)
 565 {
 566     if (ggl_unlikely(count < 2))
 567         return;
 568
 569     vertex_t *v, *v0, *v1;
 570     c->arrays.cull = vertex_t::CLIP_ALL;
 571     c->arrays.compileElement(c, c->vc.vBuffer, first);
 572     first += 1;
 573     count -= 1;
 574
 575     // vertex cache size must be multiple of 1
 576     const GLsizei vcs =
 577         (vertex_cache_t::VERTEX_BUFFER_SIZE +
 578          vertex_cache_t::VERTEX_CACHE_SIZE - 1);
 579     do {
 580         v0 = c->vc.vBuffer + 0;
 581         v  = c->vc.vBuffer + 1;
 582         GLsizei num = count > vcs ? vcs : count;
 583         c->arrays.compileElements(c, v, first, num);
 584         first += num;
 585         count -= num;
 586         if (!c->arrays.cull) {
 587             // quick/trivial reject of the whole batch
 588             do {
 589                 v1 = v++;
 590                 const uint32_t cc = v0->flags & v1->flags;
 591                 if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
 592                     c->prims.renderLine(c, v0, v1);
 593                 v0 = v1;
 594                 num--;
 595             } while (num);
 596         }
 597         // copy back the last processed vertex
 598         c->vc.vBuffer[0] = *v0;
 599         c->arrays.cull = v0->flags & vertex_t::CLIP_ALL;
 600     } while (count);
 601 }
 602
 603 void drawPrimitivesLineLoop(ogles_context_t* c, GLint first, GLsizei count)
 604 {
 605     if (ggl_unlikely(count < 2))
 606         return;
 607     drawPrimitivesLineStrip(c, first, count);
 608     if (ggl_likely(count >= 3)) {
 609         vertex_t* v0 = c->vc.vBuffer;
 610         vertex_t* v1 = c->vc.vBuffer + 1;
 611         c->arrays.compileElement(c, v1, first);
 612         const uint32_t cc = v0->flags & v1->flags;
 613         if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
 614             c->prims.renderLine(c, v0, v1);
 615     }
 616 }
 617
 618 void drawPrimitivesLines(ogles_context_t* c, GLint first, GLsizei count)
 619 {
 620     if (ggl_unlikely(count < 2))
 621         return;
 622
 623     // vertex cache size must be multiple of 2
 624     const GLsizei vcs =
 625         ((vertex_cache_t::VERTEX_BUFFER_SIZE +
 626         vertex_cache_t::VERTEX_CACHE_SIZE) / 2) * 2;
 627     do {
 628         vertex_t* v = c->vc.vBuffer;
 629         GLsizei num = count > vcs ? vcs : count;
 630         c->arrays.cull = vertex_t::CLIP_ALL;
 631         c->arrays.compileElements(c, v, first, num);
 632         first += num;
 633         count -= num;
 634         if (!c->arrays.cull) {
 635             // quick/trivial reject of the whole batch
 636             num -= 2;
 637             do {
 638                 const uint32_t cc = v[0].flags & v[1].flags;
 639                 if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
 640                     c->prims.renderLine(c, v, v+1);
 641                 v += 2;
 642                 num -= 2;
 643             } while (num >= 0);
 644         }
 645     } while (count >= 2);
 646 }
 647
 648 // ----------------------------------------------------------------------------
 649
 650 static void drawPrimitivesTriangleFanOrStrip(ogles_context_t* c,
 651         GLint first, GLsizei count, int winding)
 652 {
 653     // winding == 2 : fan
 654     // winding == 1 : strip
 655
 656     if (ggl_unlikely(count < 3))
 657         return;
 658
 659     vertex_t *v, *v0, *v1, *v2;
 660     c->arrays.cull = vertex_t::CLIP_ALL;
 661     c->arrays.compileElements(c, c->vc.vBuffer, first, 2);
 662     first += 2;
 663     count -= 2;
 664
 665     // vertex cache size must be multiple of 2. This is extremely important
 666     // because it allows us to preserve the same winding when the whole
 667     // batch is culled. We also need 2 extra vertices in the array, because
 668     // we always keep the two first ones.
 669     const GLsizei vcs =
 670         ((vertex_cache_t::VERTEX_BUFFER_SIZE +
 671           vertex_cache_t::VERTEX_CACHE_SIZE - 2) / 2) * 2;
 672     do {
 673         v0 = c->vc.vBuffer + 0;
 674         v1 = c->vc.vBuffer + 1;
 675         v  = c->vc.vBuffer + 2;
 676         GLsizei num = count > vcs ? vcs : count;
 677         c->arrays.compileElements(c, v, first, num);
 678         first += num;
 679         count -= num;
 680         if (!c->arrays.cull) {
 681             // quick/trivial reject of the whole batch
 682             do {
 683                 v2 = v++;
 684                 const uint32_t cc = v0->flags & v1->flags & v2->flags;
 685                 if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
 686                     c->prims.renderTriangle(c, v0, v1, v2);
 687                 swap(((winding^=1) ? v1 : v0), v2);
 688                 num--;
 689             } while (num);
 690         }
 691         if (count) {
 692             v0 = c->vc.vBuffer + 2 + vcs - 2;
 693             v1 = c->vc.vBuffer + 2 + vcs - 1;
 694             if ((winding&2) == 0) {
 695                 // for strips copy back the two last compiled vertices
 696                 c->vc.vBuffer[0] = *v0;
 697             }
 698             c->vc.vBuffer[1] = *v1;
 699             c->arrays.cull = v0->flags & v1->flags & vertex_t::CLIP_ALL;
 700         }
 701     } while (count > 0);
 702 }
 703
 704 void drawPrimitivesTriangleStrip(ogles_context_t* c,
 705         GLint first, GLsizei count) {
 706     drawPrimitivesTriangleFanOrStrip(c, first, count, 1);
 707 }
 708
 709 void drawPrimitivesTriangleFan(ogles_context_t* c,
 710         GLint first, GLsizei count) {
 711     drawPrimitivesTriangleFanOrStrip(c, first, count, 2);
 712 }
 713
 714 void drawPrimitivesTriangles(ogles_context_t* c, GLint first, GLsizei count)
 715 {
 716     if (ggl_unlikely(count < 3))
 717         return;
 718
 719     // vertex cache size must be multiple of 3
 720     const GLsizei vcs =
 721         ((vertex_cache_t::VERTEX_BUFFER_SIZE +
 722         vertex_cache_t::VERTEX_CACHE_SIZE) / 3) * 3;
 723     do {
 724         vertex_t* v = c->vc.vBuffer;
 725         GLsizei num = count > vcs ? vcs : count;
 726         c->arrays.cull = vertex_t::CLIP_ALL;
 727         c->arrays.compileElements(c, v, first, num);
 728         first += num;
 729         count -= num;
 730         if (!c->arrays.cull) {
 731             // quick/trivial reject of the whole batch
 732             num -= 3;
 733             do {
 734                 const uint32_t cc = v[0].flags & v[1].flags & v[2].flags;
 735                 if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
 736                     c->prims.renderTriangle(c, v, v+1, v+2);
 737                 v += 3;
 738                 num -= 3;
 739             } while (num >= 0);
 740         }
 741     } while (count >= 3);
 742 }
 743
 744 // ----------------------------------------------------------------------------
 745 #if 0
 746 #pragma mark -
 747 #endif
 748
 749 // this looks goofy, but gcc does a great job with this...
 750 static inline unsigned int read_index(int type, const GLvoid*& p) {
 751     unsigned int r;
 752     if (type) {
 753         r = *(const GLubyte*)p;
 754         p = (const GLubyte*)p + 1;
 755     } else {
 756         r = *(const GLushort*)p;
 757         p = (const GLushort*)p + 1;
 758     }
 759     return r;
 760 }
 761
 762 // ----------------------------------------------------------------------------
 763
 764 void drawIndexedPrimitivesPoints(ogles_context_t* c,
 765         GLsizei count, const GLvoid *indices)
 766 {
 767     if (ggl_unlikely(count < 1))
 768         return;
 769     const int type = (c->arrays.indicesType == GL_UNSIGNED_BYTE);
 770     do {
 771         vertex_t * v = fetch_vertex(c, read_index(type, indices));
 772         if (ggl_likely(!(v->flags & vertex_t::CLIP_ALL)))
 773             c->prims.renderPoint(c, v);
 774         v->locked = 0;
 775         count--;
 776     } while(count);
 777 }
 778
 779 // ----------------------------------------------------------------------------
 780
 781 void drawIndexedPrimitivesLineStrip(ogles_context_t* c,
 782         GLsizei count, const GLvoid *indices)
 783 {
 784     if (ggl_unlikely(count < 2))
 785         return;
 786
 787     vertex_t * const v = c->vc.vBuffer;
 788     vertex_t* v0 = v;
 789     vertex_t* v1;
 790
 791     const int type = (c->arrays.indicesType == GL_UNSIGNED_BYTE);
 792     c->arrays.compileElement(c, v0, read_index(type, indices));
 793     count -= 1;
 794     do {
 795         v1 = fetch_vertex(c, read_index(type, indices));
 796         const uint32_t cc = v0->flags & v1->flags;
 797         if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
 798             c->prims.renderLine(c, v0, v1);
 799         v0->locked = 0;
 800         v0 = v1;
 801         count--;
 802     } while (count);
 803     v1->locked = 0;
 804 }
 805
 806 void drawIndexedPrimitivesLineLoop(ogles_context_t* c,
 807         GLsizei count, const GLvoid *indices)
 808 {
 809     if (ggl_unlikely(count <= 2)) {
 810         drawIndexedPrimitivesLines(c, count, indices);
 811         return;
 812     }
 813
 814     vertex_t * const v = c->vc.vBuffer;
 815     vertex_t* v0 = v;
 816     vertex_t* v1;
 817
 818     const int type = (c->arrays.indicesType == GL_UNSIGNED_BYTE);
 819     c->arrays.compileElement(c, v0, read_index(type, indices));
 820     count -= 1;
 821     do {
 822         v1 = fetch_vertex(c, read_index(type, indices));
 823         const uint32_t cc = v0->flags & v1->flags;
 824         if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
 825             c->prims.renderLine(c, v0, v1);
 826         v0->locked = 0;
 827         v0 = v1;
 828         count--;
 829     } while (count);
 830     v1->locked = 0;
 831
 832     v1 = c->vc.vBuffer;
 833     const uint32_t cc = v0->flags & v1->flags;
 834     if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
 835         c->prims.renderLine(c, v0, v1);
 836 }
 837
 838 void drawIndexedPrimitivesLines(ogles_context_t* c,
 839         GLsizei count, const GLvoid *indices)
 840 {
 841     if (ggl_unlikely(count < 2))
 842         return;
 843
 844     count -= 2;
 845     const int type = (c->arrays.indicesType == GL_UNSIGNED_BYTE);
 846     do {
 847         vertex_t* const v0 = fetch_vertex(c, read_index(type, indices));
 848         vertex_t* const v1 = fetch_vertex(c, read_index(type, indices));
 849         const uint32_t cc = v0->flags & v1->flags;
 850         if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
 851             c->prims.renderLine(c, v0, v1);
 852         v0->locked = 0;
 853         v1->locked = 0;
 854         count -= 2;
 855     } while (count >= 0);
 856 }
 857
 858 // ----------------------------------------------------------------------------
 859
 860 static void drawIndexedPrimitivesTriangleFanOrStrip(ogles_context_t* c,
 861         GLsizei count, const GLvoid *indices, int winding)
 862 {
 863     // winding == 2 : fan
 864     // winding == 1 : strip
 865
 866     if (ggl_unlikely(count < 3))
 867         return;
 868
 869     vertex_t * const v = c->vc.vBuffer;
 870     vertex_t* v0 = v;
 871     vertex_t* v1 = v+1;
 872     vertex_t* v2;
 873
 874     const int type = (c->arrays.indicesType == GL_UNSIGNED_BYTE);
 875     c->arrays.compileElement(c, v0, read_index(type, indices));
 876     c->arrays.compileElement(c, v1, read_index(type, indices));
 877     count -= 2;
 878
 879     // note: GCC 4.1.1 here makes a prety interesting optimization
 880     // where it duplicates the loop below based on c->arrays.indicesType
 881
 882     do {
 883         v2 = fetch_vertex(c, read_index(type, indices));
 884         const uint32_t cc = v0->flags & v1->flags & v2->flags;
 885         if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
 886             c->prims.renderTriangle(c, v0, v1, v2);
 887         vertex_t* & consumed = ((winding^=1) ? v1 : v0);
 888         consumed->locked = 0;
 889         consumed = v2;
 890         count--;
 891     } while (count);
 892     v0->locked = v1->locked = 0;
 893     v2->locked = 0;
 894 }
 895
 896 void drawIndexedPrimitivesTriangleStrip(ogles_context_t* c,
 897         GLsizei count, const GLvoid *indices) {
 898     drawIndexedPrimitivesTriangleFanOrStrip(c, count, indices, 1);
 899 }
 900
 901 void drawIndexedPrimitivesTriangleFan(ogles_context_t* c,
 902         GLsizei count, const GLvoid *indices) {
 903     drawIndexedPrimitivesTriangleFanOrStrip(c, count, indices, 2);
 904 }
 905
 906 void drawIndexedPrimitivesTriangles(ogles_context_t* c,
 907         GLsizei count, const GLvoid *indices)
 908 {
 909     if (ggl_unlikely(count < 3))
 910         return;
 911
 912     count -= 3;
 913     if (ggl_likely(c->arrays.indicesType == GL_UNSIGNED_SHORT)) {
 914         // This case is probably our most common case...
 915         uint16_t const * p = (uint16_t const *)indices;
 916         do {
 917             vertex_t* const v0 = fetch_vertex(c, *p++);
 918             vertex_t* const v1 = fetch_vertex(c, *p++);
 919             vertex_t* const v2 = fetch_vertex(c, *p++);
 920             const uint32_t cc = v0->flags & v1->flags & v2->flags;
 921             if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
 922                 c->prims.renderTriangle(c, v0, v1, v2);
 923             v0->locked = 0;
 924             v1->locked = 0;
 925             v2->locked = 0;
 926             count -= 3;
 927         } while (count >= 0);
 928     } else {
 929         uint8_t const * p = (uint8_t const *)indices;
 930         do {
 931             vertex_t* const v0 = fetch_vertex(c, *p++);
 932             vertex_t* const v1 = fetch_vertex(c, *p++);
 933             vertex_t* const v2 = fetch_vertex(c, *p++);
 934             const uint32_t cc = v0->flags & v1->flags & v2->flags;
 935             if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
 936                 c->prims.renderTriangle(c, v0, v1, v2);
 937             v0->locked = 0;
 938             v1->locked = 0;
 939             v2->locked = 0;
 940             count -= 3;
 941         } while (count >= 0);
 942     }
 943 }
 944
 945 // ----------------------------------------------------------------------------
 946 #if 0
 947 #pragma mark -
 948 #pragma mark Array compilers
 949 #endif
 950
 951 void compileElement__generic(ogles_context_t* c,
 952         vertex_t* v, GLint first)
 953 {
 954     v->flags = 0;
 955     v->index = first;
 956     first &= vertex_cache_t::INDEX_MASK;
 957     const GLubyte* vp = c->arrays.vertex.element(first);
 958     v->obj.z = 0;
 959     v->obj.w = 0x10000;
 960     c->arrays.vertex.fetch(c, v->obj.v, vp);
 961     c->arrays.mvp_transform(&c->transforms.mvp, &v->clip, &v->obj);
 962     c->arrays.perspective(c, v);
 963 }
 964
 965 void compileElements__generic(ogles_context_t* c,
 966         vertex_t* v, GLint first, GLsizei count)
 967 {
 968     const GLubyte* vp = c->arrays.vertex.element(
 969             first & vertex_cache_t::INDEX_MASK);
 970     const size_t stride = c->arrays.vertex.stride;
 971     transform_t const* const mvp = &c->transforms.mvp;
 972     do {
 973         v->flags = 0;
 974         v->index = first++;
 975         v->obj.z = 0;
 976         v->obj.w = 0x10000;
 977         c->arrays.vertex.fetch(c, v->obj.v, vp);
 978         c->arrays.mvp_transform(mvp, &v->clip, &v->obj);
 979         c->arrays.perspective(c, v);
 980         vp += stride;
 981         v++;
 982     } while (--count);
 983 }
 984
 985 /*
 986 void compileElements__3x_full(ogles_context_t* c,
 987         vertex_t* v, GLint first, GLsizei count)
 988 {
 989     const GLfixed* vp = (const GLfixed*)c->arrays.vertex.element(first);
 990     const size_t stride = c->arrays.vertex.stride / 4;
 991 //    const GLfixed* const& m = c->transforms.mvp.matrix.m;
 992
 993     GLfixed m[16];
 994     memcpy(&m, c->transforms.mvp.matrix.m, sizeof(m));
 995
 996     do {
 997         const GLfixed rx = vp[0];
 998         const GLfixed ry = vp[1];
 999         const GLfixed rz = vp[2];
1000         vp += stride;
1001         v->index = first++;
1002         v->clip.x = mla3a(rx, m[ 0], ry, m[ 4], rz, m[ 8], m[12]);
1003         v->clip.y = mla3a(rx, m[ 1], ry, m[ 5], rz, m[ 9], m[13]);
1004         v->clip.z = mla3a(rx, m[ 2], ry, m[ 6], rz, m[10], m[14]);
1005         v->clip.w = mla3a(rx, m[ 3], ry, m[ 7], rz, m[11], m[15]);
1006
1007         const GLfixed w = v->clip.w;
1008         uint32_t clip = 0;
1009         if (v->clip.x < -w)   clip |= vertex_t::CLIP_L;
1010         if (v->clip.x >  w)   clip |= vertex_t::CLIP_R;
1011         if (v->clip.y < -w)   clip |= vertex_t::CLIP_B;
1012         if (v->clip.y >  w)   clip |= vertex_t::CLIP_T;
1013         if (v->clip.z < -w)   clip |= vertex_t::CLIP_N;
1014         if (v->clip.z >  w)   clip |= vertex_t::CLIP_F;
1015         v->flags = clip;
1016         c->arrays.cull &= clip;
1017
1018         //c->arrays.perspective(c, v);
1019         v++;
1020     } while (--count);
1021 }
1022 */
1023
1024 // ----------------------------------------------------------------------------
1025 #if 0
1026 #pragma mark -
1027 #pragma mark clippers
1028 #endif
1029
1030 static void clipVec4(vec4_t& nv,
1031         GLfixed t, const vec4_t& s, const vec4_t& p)
1032 {
1033     for (int i=0; i<4 ; i++)
1034         nv.v[i] = gglMulAddx(t, s.v[i] - p.v[i], p.v[i], 28);
1035 }
1036
1037 static void clipVertex(ogles_context_t* c, vertex_t* nv,
1038         GLfixed t, const vertex_t* s, const vertex_t* p)
1039 {
1040     clipVec4(nv->clip, t, s->clip, p->clip);
1041     nv->fog = gglMulAddx(t, s->fog - p->fog, p->fog, 28);
1042     ogles_vertex_project(c, nv);
1043     nv->flags |=  vertex_t::LIT | vertex_t::EYE | vertex_t::TT;
1044     nv->flags &= ~vertex_t::CLIP_ALL;
1045 }
1046
1047 static void clipVertexC(ogles_context_t* c, vertex_t* nv,
1048         GLfixed t, const vertex_t* s, const vertex_t* p)
1049 {
1050     clipVec4(nv->color, t, s->color, p->color);
1051     clipVertex(c, nv, t, s, p);
1052 }
1053
1054 static void clipVertexT(ogles_context_t* c, vertex_t* nv,
1055         GLfixed t, const vertex_t* s, const vertex_t* p)
1056 {
1057     for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
1058         if (c->rasterizer.state.texture[i].enable)
1059             clipVec4(nv->texture[i], t, s->texture[i], p->texture[i]);
1060     }
1061     clipVertex(c, nv, t, s, p);
1062 }
1063
1064 static void clipVertexAll(ogles_context_t* c, vertex_t* nv,
1065         GLfixed t, const vertex_t* s, const vertex_t* p)
1066 {
1067     clipVec4(nv->color, t, s->color, p->color);
1068     clipVertexT(c, nv, t, s, p);
1069 }
1070
1071 static void clipEye(ogles_context_t* c, vertex_t* nv,
1072         GLfixed t, const vertex_t* s, const vertex_t* p)
1073 {
1074     nv->clear();
1075     c->arrays.clipVertex(c, nv, t, p, s);
1076     clipVec4(nv->eye, t, s->eye, p->eye);
1077 }
1078
1079 // ----------------------------------------------------------------------------
1080 #if 0
1081 #pragma mark -
1082 #endif
1083
1084 void validate_arrays(ogles_context_t* c, GLenum mode)
1085 {
1086     uint32_t enables = c->rasterizer.state.enables;
1087
1088     // Perspective correction is not need if Ortho transform, but
1089     // the user can still provide the w coordinate manually, so we can't
1090     // automatically turn it off (in fact we could when the 4th coordinate
1091     // is not spcified in the vertex array).
1092     // W interpolation is never needed for points.
1093     GLboolean perspective =
1094         c->perspective && mode!=GL_POINTS && (enables & GGL_ENABLE_TMUS);
1095     c->rasterizer.procs.enableDisable(c, GGL_W_LERP, perspective);
1096
1097     // set anti-aliasing
1098     GLboolean smooth = GL_FALSE;
1099     switch (mode) {
1100     case GL_POINTS:
1101         smooth = c->point.smooth;
1102         break;
1103     case GL_LINES:
1104     case GL_LINE_LOOP:
1105     case GL_LINE_STRIP:
1106         smooth = c->line.smooth;
1107         break;
1108     }
1109     if (((enables & GGL_ENABLE_AA)?1:0) != smooth)
1110         c->rasterizer.procs.enableDisable(c, GGL_AA, smooth);
1111
1112     // set the shade model for this primitive
1113     c->rasterizer.procs.shadeModel(c,
1114             (mode == GL_POINTS) ? GL_FLAT : c->lighting.shadeModel);
1115
1116     // compute all the matrices we'll need...
1117     uint32_t want =
1118             transform_state_t::MVP |
1119             transform_state_t::VIEWPORT;
1120     if (c->lighting.enable) { // needs normal transforms and eye coords
1121         want |= transform_state_t::MVUI;
1122         want |= transform_state_t::MODELVIEW;
1123     }
1124     if (enables & GGL_ENABLE_TMUS) { // needs texture transforms
1125         want |= transform_state_t::TEXTURE;
1126     }
1127     if (c->clipPlanes.enable || (enables & GGL_ENABLE_FOG)) {
1128         want |= transform_state_t::MODELVIEW; // needs eye coords
1129     }
1130     ogles_validate_transform(c, want);
1131
1132     // textures...
1133     if (enables & GGL_ENABLE_TMUS)
1134         ogles_validate_texture(c);
1135
1136     // vertex compilers
1137     c->arrays.compileElement = compileElement__generic;
1138     c->arrays.compileElements = compileElements__generic;
1139
1140     // vertex transform
1141     c->arrays.mvp_transform =
1142         c->transforms.mvp.pointv[c->arrays.vertex.size - 2];
1143
1144     c->arrays.mv_transform =
1145         c->transforms.modelview.transform.pointv[c->arrays.vertex.size - 2];
1146
1147     /*
1148      * ***********************************************************************
1149      *  pick fetchers
1150      * ***********************************************************************
1151      */
1152
1153     array_machine_t& am = c->arrays;
1154     am.vertex.fetch = fetchNop;
1155     am.normal.fetch = currentNormal;
1156     am.color.fetch = currentColor;
1157
1158     if (am.vertex.enable) {
1159         am.vertex.resolve();
1160         if (am.vertex.bo || am.vertex.pointer) {
1161             am.vertex.fetch = vertex_fct[am.vertex.size-2][am.vertex.type & 0xF];
1162         }
1163     }
1164
1165     if (am.normal.enable) {
1166         am.normal.resolve();
1167         if (am.normal.bo || am.normal.pointer) {
1168             am.normal.fetch = normal_fct[am.normal.size-3][am.normal.type & 0xF];
1169         }
1170     }
1171
1172     if (am.color.enable) {
1173         am.color.resolve();
1174         if (c->lighting.enable) {
1175             if (am.color.bo || am.color.pointer) {
1176                 am.color.fetch = color_fct[am.color.size-3][am.color.type & 0xF];
1177             }
1178         } else {
1179             if (am.color.bo || am.color.pointer) {
1180                 am.color.fetch = color_clamp_fct[am.color.size-3][am.color.type & 0xF];
1181             }
1182         }
1183     }
1184
1185     int activeTmuCount = 0;
1186     for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
1187         am.texture[i].fetch = currentTexCoord;
1188         if (c->rasterizer.state.texture[i].enable) {
1189
1190             // texture fetchers...
1191             if (am.texture[i].enable) {
1192                 am.texture[i].resolve();
1193                 if (am.texture[i].bo || am.texture[i].pointer) {
1194                     am.texture[i].fetch = texture_fct[am.texture[i].size-2][am.texture[i].type & 0xF];
1195                 }
1196             }
1197
1198             // texture transform...
1199             const int index = c->arrays.texture[i].size - 2;
1200             c->arrays.tex_transform[i] =
1201                 c->transforms.texture[i].transform.pointv[index];
1202
1203             am.tmu = i;
1204             activeTmuCount++;
1205         }
1206     }
1207
1208     // pick the vertex-clipper
1209     uint32_t clipper = 0;
1210     // we must reload 'enables' here
1211     enables = c->rasterizer.state.enables;
1212     if (enables & GGL_ENABLE_SMOOTH)
1213         clipper |= 1;   // we need to interpolate colors
1214     if (enables & GGL_ENABLE_TMUS)
1215         clipper |= 2;   // we need to interpolate textures
1216     switch (clipper) {
1217     case 0: c->arrays.clipVertex = clipVertex;      break;
1218     case 1: c->arrays.clipVertex = clipVertexC;     break;
1219     case 2: c->arrays.clipVertex = clipVertexT;     break;
1220     case 3: c->arrays.clipVertex = clipVertexAll;   break;
1221     }
1222     c->arrays.clipEye = clipEye;
1223
1224     // pick the primitive rasterizer
1225     ogles_validate_primitives(c);
1226 }
1227
1228 // ----------------------------------------------------------------------------
1229 }; // namespace android
1230 // ----------------------------------------------------------------------------
1231
1232 using namespace android;
1233
1234 #if 0
1235 #pragma mark -
1236 #pragma mark array API
1237 #endif
1238
1239 void glVertexPointer(
1240     GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
1241 {
1242     ogles_context_t* c = ogles_context_t::get();
1243     if (size<2 || size>4 || stride<0) {
1244         ogles_error(c, GL_INVALID_VALUE);
1245         return;
1246     }
1247     switch (type) {
1248     case GL_BYTE:
1249     case GL_SHORT:
1250     case GL_FIXED:
1251     case GL_FLOAT:
1252         break;
1253     default:
1254         ogles_error(c, GL_INVALID_ENUM);
1255         return;
1256     }
1257     c->arrays.vertex.init(size, type, stride, pointer, c->arrays.array_buffer, 0);
1258 }
1259
1260 void glColorPointer(
1261     GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
1262 {
1263     ogles_context_t* c = ogles_context_t::get();
1264     if (size!=4 || stride<0) {
1265         ogles_error(c, GL_INVALID_VALUE);
1266         return;
1267     }
1268     switch (type) {
1269     case GL_UNSIGNED_BYTE:
1270     case GL_FIXED:
1271     case GL_FLOAT:
1272         break;
1273     default:
1274         ogles_error(c, GL_INVALID_ENUM);
1275         return;
1276     }
1277     c->arrays.color.init(size, type, stride, pointer, c->arrays.array_buffer, 0);
1278 }
1279
1280 void glNormalPointer(
1281     GLenum type, GLsizei stride, const GLvoid *pointer)
1282 {
1283     ogles_context_t* c = ogles_context_t::get();
1284     if (stride<0) {
1285         ogles_error(c, GL_INVALID_VALUE);
1286         return;
1287     }
1288     switch (type) {
1289     case GL_BYTE:
1290     case GL_SHORT:
1291     case GL_FIXED:
1292     case GL_FLOAT:
1293         break;
1294     default:
1295         ogles_error(c, GL_INVALID_ENUM);
1296         return;
1297     }
1298     c->arrays.normal.init(3, type, stride, pointer, c->arrays.array_buffer, 0);
1299 }
1300
1301 void glTexCoordPointer(
1302     GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
1303 {
1304     ogles_context_t* c = ogles_context_t::get();
1305     if (size<2 || size>4 || stride<0) {
1306         ogles_error(c, GL_INVALID_VALUE);
1307         return;
1308     }
1309     switch (type) {
1310     case GL_BYTE:
1311     case GL_SHORT:
1312     case GL_FIXED:
1313     case GL_FLOAT:
1314         break;
1315     default:
1316         ogles_error(c, GL_INVALID_ENUM);
1317         return;
1318     }
1319     const int tmu = c->arrays.activeTexture;
1320     c->arrays.texture[tmu].init(size, type, stride, pointer,
1321             c->arrays.array_buffer, 0);
1322 }
1323
1324
1325 void glEnableClientState(GLenum array) {
1326     ogles_context_t* c = ogles_context_t::get();
1327     enableDisableClientState(c, array, true);
1328 }
1329
1330 void glDisableClientState(GLenum array) {
1331     ogles_context_t* c = ogles_context_t::get();
1332     enableDisableClientState(c, array, false);
1333 }
1334
1335 void glClientActiveTexture(GLenum texture)
1336 {
1337     ogles_context_t* c = ogles_context_t::get();
1338     if (texture<GL_TEXTURE0 || texture>=GL_TEXTURE0+GGL_TEXTURE_UNIT_COUNT) {
1339         ogles_error(c, GL_INVALID_ENUM);
1340         return;
1341     }
1342     c->arrays.activeTexture = texture - GL_TEXTURE0;
1343 }
1344
1345 void glDrawArrays(GLenum mode, GLint first, GLsizei count)
1346 {
1347     ogles_context_t* c = ogles_context_t::get();
1348     if (count<0) {
1349         ogles_error(c, GL_INVALID_VALUE);
1350         return;
1351     }
1352     switch (mode) {
1353     case GL_POINTS:
1354     case GL_LINE_STRIP:
1355     case GL_LINE_LOOP:
1356     case GL_LINES:
1357     case GL_TRIANGLE_STRIP:
1358     case GL_TRIANGLE_FAN:
1359     case GL_TRIANGLES:
1360         break;
1361     default:
1362         ogles_error(c, GL_INVALID_ENUM);
1363         return;
1364     }
1365
1366     if (count == 0 || !c->arrays.vertex.enable)
1367         return;
1368     if ((c->cull.enable) && (c->cull.cullFace == GL_FRONT_AND_BACK))
1369         return; // all triangles are culled
1370
1371
1372     validate_arrays(c, mode);
1373
1374     const uint32_t enables = c->rasterizer.state.enables;
1375     if (enables & GGL_ENABLE_TMUS)
1376         ogles_lock_textures(c);
1377
1378     drawArraysPrims[mode](c, first, count);
1379
1380     if (enables & GGL_ENABLE_TMUS)
1381         ogles_unlock_textures(c);
1382
1383 #if VC_CACHE_STATISTICS
1384     c->vc.total = count;
1385     c->vc.dump_stats(mode);
1386 #endif
1387 }
1388
1389 void glDrawElements(
1390     GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
1391 {
1392     ogles_context_t* c = ogles_context_t::get();
1393     if (count<0) {
1394         ogles_error(c, GL_INVALID_VALUE);
1395         return;
1396     }
1397     switch (mode) {
1398     case GL_POINTS:
1399     case GL_LINE_STRIP:
1400     case GL_LINE_LOOP:
1401     case GL_LINES:
1402     case GL_TRIANGLE_STRIP:
1403     case GL_TRIANGLE_FAN:
1404     case GL_TRIANGLES:
1405         break;
1406     default:
1407         ogles_error(c, GL_INVALID_ENUM);
1408         return;
1409     }
1410     switch (type) {
1411     case GL_UNSIGNED_BYTE:
1412     case GL_UNSIGNED_SHORT:
1413         c->arrays.indicesType = type;
1414         break;
1415     default:
1416         ogles_error(c, GL_INVALID_ENUM);
1417         return;
1418     }
1419     if (count == 0 || !c->arrays.vertex.enable)
1420         return;
1421     if ((c->cull.enable) && (c->cull.cullFace == GL_FRONT_AND_BACK))
1422         return; // all triangles are culled
1423
1424     // clear the vertex-cache
1425     c->vc.clear();
1426     validate_arrays(c, mode);
1427
1428     // if indices are in a buffer object, the pointer is treated as an
1429     // offset in that buffer.
1430     if (c->arrays.element_array_buffer) {
1431         indices = c->arrays.element_array_buffer->data + uintptr_t(indices);
1432     }
1433
1434     const uint32_t enables = c->rasterizer.state.enables;
1435     if (enables & GGL_ENABLE_TMUS)
1436         ogles_lock_textures(c);
1437
1438     drawElementsPrims[mode](c, count, indices);
1439
1440     if (enables & GGL_ENABLE_TMUS)
1441         ogles_unlock_textures(c);
1442
1443
1444 #if VC_CACHE_STATISTICS
1445     c->vc.total = count;
1446     c->vc.dump_stats(mode);
1447 #endif
1448 }
1449
1450 // ----------------------------------------------------------------------------
1451 // buffers
1452 // ----------------------------------------------------------------------------
1453
1454 void glBindBuffer(GLenum target, GLuint buffer)
1455 {
1456     ogles_context_t* c = ogles_context_t::get();
1457     if ((target!=GL_ARRAY_BUFFER) && (target!=GL_ELEMENT_ARRAY_BUFFER)) {
1458         ogles_error(c, GL_INVALID_ENUM);
1459         return;
1460     }
1461     // create a buffer object, or bind an existing one
1462     buffer_t const* bo = 0;
1463     if (buffer) {
1464         bo = c->bufferObjectManager->bind(buffer);
1465         if (!bo) {
1466             ogles_error(c, GL_OUT_OF_MEMORY);
1467             return;
1468         }
1469     }
1470     ((target == GL_ARRAY_BUFFER) ?
1471             c->arrays.array_buffer : c->arrays.element_array_buffer) = bo;
1472 }
1473
1474 void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
1475 {
1476     ogles_context_t* c = ogles_context_t::get();
1477     if ((target!=GL_ARRAY_BUFFER) && (target!=GL_ELEMENT_ARRAY_BUFFER)) {
1478         ogles_error(c, GL_INVALID_ENUM);
1479         return;
1480     }
1481     if (size<0) {
1482         ogles_error(c, GL_INVALID_VALUE);
1483         return;
1484     }
1485     if ((usage!=GL_STATIC_DRAW) && (usage!=GL_DYNAMIC_DRAW)) {
1486         ogles_error(c, GL_INVALID_ENUM);
1487         return;
1488     }
1489     buffer_t const* bo = ((target == GL_ARRAY_BUFFER) ?
1490             c->arrays.array_buffer : c->arrays.element_array_buffer);
1491
1492     if (bo == 0) {
1493         // can't modify buffer 0
1494         ogles_error(c, GL_INVALID_OPERATION);
1495         return;
1496     }
1497
1498     buffer_t* edit_bo = const_cast<buffer_t*>(bo);
1499     if (c->bufferObjectManager->allocateStore(edit_bo, size, usage) != 0) {
1500         ogles_error(c, GL_OUT_OF_MEMORY);
1501         return;
1502     }
1503     if (data) {
1504         memcpy(bo->data, data, size);
1505     }
1506 }
1507
1508 void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
1509 {
1510     ogles_context_t* c = ogles_context_t::get();
1511     if ((target!=GL_ARRAY_BUFFER) && (target!=GL_ELEMENT_ARRAY_BUFFER)) {
1512         ogles_error(c, GL_INVALID_ENUM);
1513         return;
1514     }
1515     if (offset<0 || size<0 || data==0) {
1516         ogles_error(c, GL_INVALID_VALUE);
1517         return;
1518     }
1519     buffer_t const* bo = ((target == GL_ARRAY_BUFFER) ?
1520             c->arrays.array_buffer : c->arrays.element_array_buffer);
1521
1522     if (bo == 0) {
1523         // can't modify buffer 0
1524         ogles_error(c, GL_INVALID_OPERATION);
1525         return;
1526     }
1527     if (offset+size > bo->size) {
1528         ogles_error(c, GL_INVALID_VALUE);
1529         return;
1530     }
1531     memcpy(bo->data + offset, data, size);
1532 }
1533
1534 void glDeleteBuffers(GLsizei n, const GLuint* buffers)
1535 {
1536     ogles_context_t* c = ogles_context_t::get();
1537     if (n<0) {
1538         ogles_error(c, GL_INVALID_VALUE);
1539         return;
1540     }
1541
1542     for (int i=0 ; i<n ; i++) {
1543         GLuint name = buffers[i];
1544         if (name) {
1545             // unbind bound deleted buffers...
1546             if (c->arrays.element_array_buffer) {
1547                 if (c->arrays.element_array_buffer->name == name) {
1548                     c->arrays.element_array_buffer = 0;
1549                 }
1550             }
1551             if (c->arrays.array_buffer) {
1552                 if (c->arrays.array_buffer->name == name) {
1553                     c->arrays.array_buffer = 0;
1554                 }
1555             }
1556             if (c->arrays.vertex.bo) {
1557                 if (c->arrays.vertex.bo->name == name) {
1558                     c->arrays.vertex.bo = 0;
1559                 }
1560             }
1561             if (c->arrays.normal.bo) {
1562                 if (c->arrays.normal.bo->name == name) {
1563                     c->arrays.normal.bo = 0;
1564                 }
1565             }
1566             if (c->arrays.color.bo) {
1567                 if (c->arrays.color.bo->name == name) {
1568                     c->arrays.color.bo = 0;
1569                 }
1570             }
1571             for (int t=0 ; t<GGL_TEXTURE_UNIT_COUNT ; t++) {
1572                 if (c->arrays.texture[t].bo) {
1573                     if (c->arrays.texture[t].bo->name == name) {
1574                         c->arrays.texture[t].bo = 0;
1575                     }
1576                 }
1577             }
1578         }
1579     }
1580     c->bufferObjectManager->deleteBuffers(n, buffers);
1581     c->bufferObjectManager->recycleTokens(n, buffers);
1582 }
1583
1584 void glGenBuffers(GLsizei n, GLuint* buffers)
1585 {
1586     ogles_context_t* c = ogles_context_t::get();
1587     if (n<0) {
1588         ogles_error(c, GL_INVALID_VALUE);
1589         return;
1590     }
1591     c->bufferObjectManager->getToken(n, buffers);
1592 }