system/core/libpixelflinger/pixelflinger.cpp

   1 /* libs/pixelflinger/pixelflinger.cpp
   2 **
   3 ** Copyright 2006, The Android Open Source Project
   4 **
   5 ** Licensed under the Apache License, Version 2.0 (the "License");
   6 ** you may not use this file except in compliance with the License.
   7 ** You may obtain a copy of the License at
   8 **
   9 **     http://www.apache.org/licenses/LICENSE-2.0
  10 **
  11 ** Unless required by applicable law or agreed to in writing, software
  12 ** distributed under the License is distributed on an "AS IS" BASIS,
  13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 ** See the License for the specific language governing permissions and
  15 ** limitations under the License.
  16 */
  17
  18
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <assert.h>
  22
  23 #include <sys/time.h>
  24
  25 #include <pixelflinger/pixelflinger.h>
  26 #include <private/pixelflinger/ggl_context.h>
  27
  28 #include "buffer.h"
  29 #include "clear.h"
  30 #include "picker.h"
  31 #include "raster.h"
  32 #include "scanline.h"
  33 #include "trap.h"
  34
  35 #include "codeflinger/GGLAssembler.h"
  36 #include "codeflinger/CodeCache.h"
  37
  38 #include <stdio.h>
  39
  40
  41 namespace android {
  42
  43 // ----------------------------------------------------------------------------
  44
  45 // 8x8 Bayer dither matrix
  46 static const uint8_t gDitherMatrix[GGL_DITHER_SIZE] = {
  47      0, 32,  8, 40,  2, 34, 10, 42,
  48     48, 16, 56, 24, 50, 18, 58, 26,
  49     12, 44,  4, 36, 14, 46,  6, 38,
  50     60, 28, 52, 20, 62, 30, 54, 22,
  51      3, 35, 11, 43,  1, 33,  9, 41,
  52     51, 19, 59, 27, 49, 17, 57, 25,
  53     15, 47,  7, 39, 13, 45,  5, 37,
  54     63, 31, 55, 23, 61, 29, 53, 21
  55 };
  56
  57 static void ggl_init_procs(context_t* c);
  58 static void ggl_set_scissor(context_t* c);
  59
  60 static void ggl_enable_blending(context_t* c, int enable);
  61 static void ggl_enable_scissor_test(context_t* c, int enable);
  62 static void ggl_enable_alpha_test(context_t* c, int enable);
  63 static void ggl_enable_logic_op(context_t* c, int enable);
  64 static void ggl_enable_dither(context_t* c, int enable);
  65 static void ggl_enable_stencil_test(context_t* c, int enable);
  66 static void ggl_enable_depth_test(context_t* c, int enable);
  67 static void ggl_enable_aa(context_t* c, int enable);
  68 static void ggl_enable_point_aa_nice(context_t* c, int enable);
  69 static void ggl_enable_texture2d(context_t* c, int enable);
  70 static void ggl_enable_w_lerp(context_t* c, int enable);
  71 static void ggl_enable_fog(context_t* c, int enable);
  72
  73 static inline int min(int a, int b) CONST;
  74 static inline int min(int a, int b) {
  75     return a < b ? a : b;
  76 }
  77
  78 static inline int max(int a, int b) CONST;
  79 static inline int max(int a, int b) {
  80     return a < b ? b : a;
  81 }
  82
  83 // ----------------------------------------------------------------------------
  84
  85 void ggl_error(context_t* c, GGLenum error)
  86 {
  87     if (c->error == GGL_NO_ERROR)
  88         c->error = error;
  89 }
  90
  91 // ----------------------------------------------------------------------------
  92
  93 static void ggl_bindTexture(void* con, const GGLSurface* surface)
  94 {
  95     GGL_CONTEXT(c, con);
  96     if (surface->format != c->activeTMU->surface.format)
  97         ggl_state_changed(c, GGL_TMU_STATE);
  98     ggl_set_surface(c, &(c->activeTMU->surface), surface);
  99 }
 100
 101
 102 static void ggl_bindTextureLod(void* con, GGLuint tmu,const GGLSurface* surface)
 103 {
 104     GGL_CONTEXT(c, con);
 105     // All LODs must have the same format
 106     ggl_set_surface(c, &c->state.texture[tmu].surface, surface);
 107 }
 108
 109 static void ggl_colorBuffer(void* con, const GGLSurface* surface)
 110 {
 111     GGL_CONTEXT(c, con);
 112     if (surface->format != c->state.buffers.color.format)
 113         ggl_state_changed(c, GGL_CB_STATE);
 114
 115     if (surface->width > c->state.buffers.coverageBufferSize) {
 116         // allocate the coverage factor buffer
 117         free(c->state.buffers.coverage);
 118         c->state.buffers.coverage = (int16_t*)malloc(surface->width * 2);
 119         c->state.buffers.coverageBufferSize =
 120                 c->state.buffers.coverage ? surface->width : 0;
 121     }
 122     ggl_set_surface(c, &(c->state.buffers.color), surface);
 123     if (c->state.buffers.read.format == 0) {
 124         ggl_set_surface(c, &(c->state.buffers.read), surface);
 125     }
 126     ggl_set_scissor(c);
 127 }
 128
 129 static void ggl_readBuffer(void* con, const GGLSurface* surface)
 130 {
 131     GGL_CONTEXT(c, con);
 132     ggl_set_surface(c, &(c->state.buffers.read), surface);
 133 }
 134
 135 static void ggl_depthBuffer(void* con, const GGLSurface* surface)
 136 {
 137     GGL_CONTEXT(c, con);
 138     if (surface->format == GGL_PIXEL_FORMAT_Z_16) {
 139         ggl_set_surface(c, &(c->state.buffers.depth), surface);
 140     } else {
 141         c->state.buffers.depth.format = GGL_PIXEL_FORMAT_NONE;
 142         ggl_enable_depth_test(c, 0);
 143     }
 144 }
 145
 146 static void ggl_scissor(void* con, GGLint x, GGLint y,
 147         GGLsizei width, GGLsizei height)
 148 {
 149     GGL_CONTEXT(c, con);
 150     c->state.scissor.user_left = x;
 151     c->state.scissor.user_top = y;
 152     c->state.scissor.user_right = x + width;
 153     c->state.scissor.user_bottom = y + height;
 154     ggl_set_scissor(c);
 155 }
 156
 157 // ----------------------------------------------------------------------------
 158
 159 static void enable_disable(context_t* c, GGLenum name, int en)
 160 {
 161     switch (name) {
 162     case GGL_BLEND:             ggl_enable_blending(c, en);      break;
 163     case GGL_SCISSOR_TEST:      ggl_enable_scissor_test(c, en);  break;
 164     case GGL_ALPHA_TEST:        ggl_enable_alpha_test(c, en);    break;
 165     case GGL_COLOR_LOGIC_OP:    ggl_enable_logic_op(c, en);      break;
 166     case GGL_DITHER:            ggl_enable_dither(c, en);        break;
 167     case GGL_STENCIL_TEST:      ggl_enable_stencil_test(c, en);  break;
 168     case GGL_DEPTH_TEST:        ggl_enable_depth_test(c, en);    break;
 169     case GGL_AA:                ggl_enable_aa(c, en);            break;
 170     case GGL_TEXTURE_2D:        ggl_enable_texture2d(c, en);     break;
 171     case GGL_W_LERP:            ggl_enable_w_lerp(c, en);        break;
 172     case GGL_FOG:               ggl_enable_fog(c, en);           break;
 173     case GGL_POINT_SMOOTH_NICE: ggl_enable_point_aa_nice(c, en); break;
 174     }
 175 }
 176
 177 static void ggl_enable(void* con, GGLenum name)
 178 {
 179     GGL_CONTEXT(c, con);
 180     enable_disable(c, name, 1);
 181 }
 182
 183 static void ggl_disable(void* con, GGLenum name)
 184 {
 185     GGL_CONTEXT(c, con);
 186     enable_disable(c, name, 0);
 187 }
 188
 189 static void ggl_enableDisable(void* con, GGLenum name, GGLboolean en)
 190 {
 191     GGL_CONTEXT(c, con);
 192     enable_disable(c, name, en ? 1 : 0);
 193 }
 194
 195 // ----------------------------------------------------------------------------
 196
 197 static void ggl_shadeModel(void* con, GGLenum mode)
 198 {
 199     GGL_CONTEXT(c, con);
 200     switch (mode) {
 201     case GGL_FLAT:
 202         if (c->state.enables & GGL_ENABLE_SMOOTH) {
 203             c->state.enables &= ~GGL_ENABLE_SMOOTH;
 204             ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 205         }
 206         break;
 207     case GGL_SMOOTH:
 208         if (!(c->state.enables & GGL_ENABLE_SMOOTH)) {
 209             c->state.enables |= GGL_ENABLE_SMOOTH;
 210             ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 211         }
 212         break;
 213     default:
 214         ggl_error(c, GGL_INVALID_ENUM);
 215     }
 216 }
 217
 218 static void ggl_color4xv(void* con, const GGLclampx* color)
 219 {
 220     GGL_CONTEXT(c, con);
 221         c->shade.r0 = gglFixedToIteratedColor(color[0]);
 222         c->shade.g0 = gglFixedToIteratedColor(color[1]);
 223         c->shade.b0 = gglFixedToIteratedColor(color[2]);
 224         c->shade.a0 = gglFixedToIteratedColor(color[3]);
 225 }
 226
 227 static void ggl_colorGrad12xv(void* con, const GGLcolor* grad)
 228 {
 229     GGL_CONTEXT(c, con);
 230     // it is very important to round the iterated value here because
 231     // the rasterizer doesn't clamp them, therefore the iterated value
 232     //must absolutely be correct.
 233     // GGLColor is encoded as 8.16 value
 234     const int32_t round = 0x8000;
 235         c->shade.r0   = grad[ 0] + round;
 236         c->shade.drdx = grad[ 1];
 237         c->shade.drdy = grad[ 2];
 238         c->shade.g0   = grad[ 3] + round;
 239         c->shade.dgdx = grad[ 4];
 240         c->shade.dgdy = grad[ 5];
 241         c->shade.b0   = grad[ 6] + round;
 242         c->shade.dbdx = grad[ 7];
 243         c->shade.dbdy = grad[ 8];
 244         c->shade.a0   = grad[ 9] + round;
 245         c->shade.dadx = grad[10];
 246         c->shade.dady = grad[11];
 247 }
 248
 249 static void ggl_zGrad3xv(void* con, const GGLfixed32* grad)
 250 {
 251     GGL_CONTEXT(c, con);
 252     // z iterators are encoded as 0.32 fixed point and the z-buffer
 253     // holds 16 bits, the rounding value is 0x8000.
 254     const uint32_t round = 0x8000;
 255         c->shade.z0   = grad[0] + round;
 256         c->shade.dzdx = grad[1];
 257         c->shade.dzdy = grad[2];
 258 }
 259
 260 static void ggl_wGrad3xv(void* con, const GGLfixed* grad)
 261 {
 262     GGL_CONTEXT(c, con);
 263         c->shade.w0   = grad[0];
 264         c->shade.dwdx = grad[1];
 265         c->shade.dwdy = grad[2];
 266 }
 267
 268 // ----------------------------------------------------------------------------
 269
 270 static void ggl_fogGrad3xv(void* con, const GGLfixed* grad)
 271 {
 272     GGL_CONTEXT(c, con);
 273         c->shade.f0     = grad[0];
 274         c->shade.dfdx   = grad[1];
 275         c->shade.dfdy   = grad[2];
 276 }
 277
 278 static void ggl_fogColor3xv(void* con, const GGLclampx* color)
 279 {
 280     GGL_CONTEXT(c, con);
 281     const int32_t r = gglClampx(color[0]);
 282     const int32_t g = gglClampx(color[1]);
 283     const int32_t b = gglClampx(color[2]);
 284     c->state.fog.color[GGLFormat::ALPHA]= 0xFF; // unused
 285         c->state.fog.color[GGLFormat::RED]  = (r - (r>>8))>>8;
 286         c->state.fog.color[GGLFormat::GREEN]= (g - (g>>8))>>8;
 287         c->state.fog.color[GGLFormat::BLUE] = (b - (b>>8))>>8;
 288 }
 289
 290 static void ggl_enable_fog(context_t* c, int enable)
 291 {
 292     const int e = (c->state.enables & GGL_ENABLE_FOG)?1:0;
 293     if (e != enable) {
 294         if (enable) c->state.enables |= GGL_ENABLE_FOG;
 295         else        c->state.enables &= ~GGL_ENABLE_FOG;
 296         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 297     }
 298 }
 299
 300 // ----------------------------------------------------------------------------
 301
 302 static void ggl_blendFunc(void* con, GGLenum src, GGLenum dst)
 303 {
 304     GGL_CONTEXT(c, con);
 305     c->state.blend.src = src;
 306     c->state.blend.src_alpha = src;
 307     c->state.blend.dst = dst;
 308     c->state.blend.dst_alpha = dst;
 309     c->state.blend.alpha_separate = 0;
 310     if (c->state.enables & GGL_ENABLE_BLENDING) {
 311         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 312     }
 313 }
 314
 315 static void ggl_blendFuncSeparate(void* con,
 316         GGLenum src, GGLenum dst,
 317         GGLenum srcAlpha, GGLenum dstAplha)
 318 {
 319     GGL_CONTEXT(c, con);
 320     c->state.blend.src = src;
 321     c->state.blend.src_alpha = srcAlpha;
 322     c->state.blend.dst = dst;
 323     c->state.blend.dst_alpha = dstAplha;
 324     c->state.blend.alpha_separate = 1;
 325     if (c->state.enables & GGL_ENABLE_BLENDING) {
 326         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 327     }
 328 }
 329
 330 // ----------------------------------------------------------------------------
 331
 332 static void ggl_texEnvi(void* con,      GGLenum target,
 333                                                         GGLenum pname,
 334                                                         GGLint param)
 335 {
 336     GGL_CONTEXT(c, con);
 337     if (target != GGL_TEXTURE_ENV || pname != GGL_TEXTURE_ENV_MODE) {
 338         ggl_error(c, GGL_INVALID_ENUM);
 339         return;
 340     }
 341     switch (param) {
 342     case GGL_REPLACE:
 343     case GGL_MODULATE:
 344     case GGL_DECAL:
 345     case GGL_BLEND:
 346     case GGL_ADD:
 347         if (c->activeTMU->env != param) {
 348             c->activeTMU->env = param;
 349             ggl_state_changed(c, GGL_TMU_STATE);
 350         }
 351         break;
 352     default:
 353         ggl_error(c, GGL_INVALID_ENUM);
 354     }
 355 }
 356
 357 static void ggl_texEnvxv(void* con, GGLenum target,
 358         GGLenum pname, const GGLfixed* params)
 359 {
 360     GGL_CONTEXT(c, con);
 361     if (target != GGL_TEXTURE_ENV) {
 362         ggl_error(c, GGL_INVALID_ENUM);
 363         return;
 364     }
 365     switch (pname) {
 366     case GGL_TEXTURE_ENV_MODE:
 367         ggl_texEnvi(con, target, pname, params[0]);
 368         break;
 369     case GGL_TEXTURE_ENV_COLOR: {
 370         uint8_t* const color = c->activeTMU->env_color;
 371         const GGLclampx r = gglClampx(params[0]);
 372         const GGLclampx g = gglClampx(params[1]);
 373         const GGLclampx b = gglClampx(params[2]);
 374         const GGLclampx a = gglClampx(params[3]);
 375         color[0] = (a-(a>>8))>>8;
 376         color[1] = (r-(r>>8))>>8;
 377         color[2] = (g-(g>>8))>>8;
 378         color[3] = (b-(b>>8))>>8;
 379         break;
 380     }
 381     default:
 382         ggl_error(c, GGL_INVALID_ENUM);
 383         return;
 384     }
 385 }
 386
 387
 388 static void ggl_texParameteri(void* con,
 389         GGLenum target,
 390         GGLenum pname,
 391         GGLint param)
 392 {
 393     GGL_CONTEXT(c, con);
 394     if (target != GGL_TEXTURE_2D) {
 395         ggl_error(c, GGL_INVALID_ENUM);
 396         return;
 397     }
 398
 399     if (param == GGL_CLAMP_TO_EDGE)
 400         param = GGL_CLAMP;
 401
 402     uint16_t* what = 0;
 403     switch (pname) {
 404     case GGL_TEXTURE_WRAP_S:
 405         if ((param == GGL_CLAMP) ||
 406             (param == GGL_REPEAT)) {
 407             what = &c->activeTMU->s_wrap;
 408         }
 409         break;
 410     case GGL_TEXTURE_WRAP_T:
 411         if ((param == GGL_CLAMP) ||
 412             (param == GGL_REPEAT)) {
 413             what = &c->activeTMU->t_wrap;
 414         }
 415         break;
 416     case GGL_TEXTURE_MIN_FILTER:
 417         if ((param == GGL_NEAREST) ||
 418             (param == GGL_NEAREST_MIPMAP_NEAREST) ||
 419             (param == GGL_NEAREST_MIPMAP_LINEAR)) {
 420             what = &c->activeTMU->min_filter;
 421             param = GGL_NEAREST;
 422         }
 423         if ((param == GGL_LINEAR) ||
 424             (param == GGL_LINEAR_MIPMAP_NEAREST) ||
 425             (param == GGL_LINEAR_MIPMAP_LINEAR)) {
 426             what = &c->activeTMU->min_filter;
 427             param = GGL_LINEAR;
 428         }
 429         break;
 430     case GGL_TEXTURE_MAG_FILTER:
 431         if ((param == GGL_NEAREST) ||
 432             (param == GGL_LINEAR)) {
 433             what = &c->activeTMU->mag_filter;
 434         }
 435         break;
 436     }
 437
 438     if (!what) {
 439         ggl_error(c, GGL_INVALID_ENUM);
 440         return;
 441     }
 442
 443     if (*what != param) {
 444         *what = param;
 445         ggl_state_changed(c, GGL_TMU_STATE);
 446     }
 447 }
 448
 449 static void ggl_texCoordGradScale8xv(void* con, GGLint tmu, const int32_t* grad)
 450 {
 451     GGL_CONTEXT(c, con);
 452     texture_t& u = c->state.texture[tmu];
 453         u.shade.is0   = grad[0];
 454         u.shade.idsdx = grad[1];
 455         u.shade.idsdy = grad[2];
 456         u.shade.it0   = grad[3];
 457         u.shade.idtdx = grad[4];
 458         u.shade.idtdy = grad[5];
 459     u.shade.sscale= grad[6];
 460     u.shade.tscale= grad[7];
 461 }
 462
 463 static void ggl_texCoord2x(void* con, GGLfixed s, GGLfixed t)
 464 {
 465     GGL_CONTEXT(c, con);
 466         c->activeTMU->shade.is0 = s;
 467         c->activeTMU->shade.it0 = t;
 468     c->activeTMU->shade.sscale= 0;
 469     c->activeTMU->shade.tscale= 0;
 470 }
 471
 472 static void ggl_texCoord2i(void* con, GGLint s, GGLint t)
 473 {
 474     ggl_texCoord2x(con, s<<16, t<<16);
 475 }
 476
 477 static void ggl_texGeni(void* con, GGLenum coord, GGLenum pname, GGLint param)
 478 {
 479     GGL_CONTEXT(c, con);
 480     if (pname != GGL_TEXTURE_GEN_MODE) {
 481         ggl_error(c, GGL_INVALID_ENUM);
 482         return;
 483     }
 484
 485     uint32_t* coord_ptr = 0;
 486     if (coord == GGL_S)         coord_ptr = &(c->activeTMU->s_coord);
 487     else if (coord == GGL_T)    coord_ptr = &(c->activeTMU->t_coord);
 488
 489     if (coord_ptr) {
 490         if (*coord_ptr != uint32_t(param)) {
 491             *coord_ptr = uint32_t(param);
 492             ggl_state_changed(c, GGL_TMU_STATE);
 493         }
 494     } else {
 495         ggl_error(c, GGL_INVALID_ENUM);
 496     }
 497 }
 498
 499 static void ggl_activeTexture(void* con, GGLuint tmu)
 500 {
 501     GGL_CONTEXT(c, con);
 502     if (tmu >= GGLuint(GGL_TEXTURE_UNIT_COUNT)) {
 503         ggl_error(c, GGL_INVALID_ENUM);
 504         return;
 505     }
 506     c->activeTMUIndex = tmu;
 507     c->activeTMU = &(c->state.texture[tmu]);
 508 }
 509
 510 // ----------------------------------------------------------------------------
 511
 512 static void ggl_colorMask(void* con, GGLboolean r,
 513                                      GGLboolean g,
 514                                      GGLboolean b,
 515                                      GGLboolean a)
 516 {
 517     GGL_CONTEXT(c, con);
 518     int mask = 0;
 519     if (a)  mask |= 1 << GGLFormat::ALPHA;
 520     if (r)  mask |= 1 << GGLFormat::RED;
 521     if (g)  mask |= 1 << GGLFormat::GREEN;
 522     if (b)  mask |= 1 << GGLFormat::BLUE;
 523     if (c->state.mask.color != mask) {
 524         c->state.mask.color = mask;
 525         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 526     }
 527 }
 528
 529 static void ggl_depthMask(void* con, GGLboolean flag)
 530 {
 531     GGL_CONTEXT(c, con);
 532     if (c->state.mask.depth != flag?1:0) {
 533         c->state.mask.depth = flag?1:0;
 534         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 535     }
 536 }
 537
 538 static void ggl_stencilMask(void* con, GGLuint mask)
 539 {
 540     GGL_CONTEXT(c, con);
 541     if (c->state.mask.stencil != mask) {
 542         c->state.mask.stencil = mask;
 543         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 544     }
 545 }
 546
 547 // ----------------------------------------------------------------------------
 548
 549 static void ggl_alphaFuncx(void* con, GGLenum func, GGLclampx ref)
 550 {
 551     GGL_CONTEXT(c, con);
 552     if ((func < GGL_NEVER) || (func > GGL_ALWAYS)) {
 553         ggl_error(c, GGL_INVALID_ENUM);
 554         return;
 555     }
 556     c->state.alpha_test.ref = gglFixedToIteratedColor(gglClampx(ref));
 557     if (c->state.alpha_test.func != func) {
 558         c->state.alpha_test.func = func;
 559         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 560     }
 561 }
 562
 563 // ----------------------------------------------------------------------------
 564
 565 static void ggl_depthFunc(void* con, GGLenum func)
 566 {
 567     GGL_CONTEXT(c, con);
 568     if ((func < GGL_NEVER) || (func > GGL_ALWAYS)) {
 569         ggl_error(c, GGL_INVALID_ENUM);
 570         return;
 571     }
 572     if (c->state.depth_test.func != func) {
 573         c->state.depth_test.func = func;
 574         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 575     }
 576 }
 577
 578 // ----------------------------------------------------------------------------
 579
 580 static void ggl_logicOp(void* con, GGLenum opcode)
 581 {
 582     GGL_CONTEXT(c, con);
 583     if ((opcode < GGL_CLEAR) || (opcode > GGL_SET)) {
 584         ggl_error(c, GGL_INVALID_ENUM);
 585         return;
 586     }
 587     if (c->state.logic_op.opcode != opcode) {
 588         c->state.logic_op.opcode = opcode;
 589         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 590     }
 591 }
 592
 593
 594 // ----------------------------------------------------------------------------
 595
 596 void ggl_set_scissor(context_t* c)
 597 {
 598     if (c->state.enables & GGL_ENABLE_SCISSOR_TEST) {
 599         const int32_t l = c->state.scissor.user_left;
 600         const int32_t t = c->state.scissor.user_top;
 601         const int32_t r = c->state.scissor.user_right;
 602         const int32_t b = c->state.scissor.user_bottom;
 603         c->state.scissor.left   = max(0, l);
 604         c->state.scissor.right  = min(c->state.buffers.color.width, r);
 605         c->state.scissor.top    = max(0, t);
 606         c->state.scissor.bottom = min(c->state.buffers.color.height, b);
 607     } else {
 608         c->state.scissor.left   = 0;
 609         c->state.scissor.top    = 0;
 610         c->state.scissor.right  = c->state.buffers.color.width;
 611         c->state.scissor.bottom = c->state.buffers.color.height;
 612     }
 613 }
 614
 615 void ggl_enable_blending(context_t* c, int enable)
 616 {
 617     const int e = (c->state.enables & GGL_ENABLE_BLENDING)?1:0;
 618     if (e != enable) {
 619         if (enable) c->state.enables |= GGL_ENABLE_BLENDING;
 620         else        c->state.enables &= ~GGL_ENABLE_BLENDING;
 621         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 622     }
 623 }
 624
 625 void ggl_enable_scissor_test(context_t* c, int enable)
 626 {
 627     const int e = (c->state.enables & GGL_ENABLE_SCISSOR_TEST)?1:0;
 628     if (e != enable) {
 629         if (enable) c->state.enables |= GGL_ENABLE_SCISSOR_TEST;
 630         else        c->state.enables &= ~GGL_ENABLE_SCISSOR_TEST;
 631         ggl_set_scissor(c);
 632     }
 633 }
 634
 635 void ggl_enable_alpha_test(context_t* c, int enable)
 636 {
 637     const int e = (c->state.enables & GGL_ENABLE_ALPHA_TEST)?1:0;
 638     if (e != enable) {
 639         if (enable) c->state.enables |= GGL_ENABLE_ALPHA_TEST;
 640         else        c->state.enables &= ~GGL_ENABLE_ALPHA_TEST;
 641         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 642     }
 643 }
 644
 645 void ggl_enable_logic_op(context_t* c, int enable)
 646 {
 647     const int e = (c->state.enables & GGL_ENABLE_LOGIC_OP)?1:0;
 648     if (e != enable) {
 649         if (enable) c->state.enables |= GGL_ENABLE_LOGIC_OP;
 650         else        c->state.enables &= ~GGL_ENABLE_LOGIC_OP;
 651         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 652     }
 653 }
 654
 655 void ggl_enable_dither(context_t* c, int enable)
 656 {
 657     const int e = (c->state.enables & GGL_ENABLE_DITHER)?1:0;
 658     if (e != enable) {
 659         if (enable) c->state.enables |= GGL_ENABLE_DITHER;
 660         else        c->state.enables &= ~GGL_ENABLE_DITHER;
 661         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 662     }
 663 }
 664
 665 void ggl_enable_stencil_test(context_t* c, int enable)
 666 {
 667 }
 668
 669 void ggl_enable_depth_test(context_t* c, int enable)
 670 {
 671     if (c->state.buffers.depth.format == 0)
 672         enable = 0;
 673     const int e = (c->state.enables & GGL_ENABLE_DEPTH_TEST)?1:0;
 674     if (e != enable) {
 675         if (enable) c->state.enables |= GGL_ENABLE_DEPTH_TEST;
 676         else        c->state.enables &= ~GGL_ENABLE_DEPTH_TEST;
 677         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 678     }
 679 }
 680
 681 void ggl_enable_aa(context_t* c, int enable)
 682 {
 683     const int e = (c->state.enables & GGL_ENABLE_AA)?1:0;
 684     if (e != enable) {
 685         if (enable) c->state.enables |= GGL_ENABLE_AA;
 686         else        c->state.enables &= ~GGL_ENABLE_AA;
 687         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 688     }
 689 }
 690
 691 void ggl_enable_point_aa_nice(context_t* c, int enable)
 692 {
 693     const int e = (c->state.enables & GGL_ENABLE_POINT_AA_NICE)?1:0;
 694     if (e != enable) {
 695         if (enable) c->state.enables |= GGL_ENABLE_POINT_AA_NICE;
 696         else        c->state.enables &= ~GGL_ENABLE_POINT_AA_NICE;
 697         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 698     }
 699 }
 700
 701 void ggl_enable_w_lerp(context_t* c, int enable)
 702 {
 703     const int e = (c->state.enables & GGL_ENABLE_W)?1:0;
 704     if (e != enable) {
 705         if (enable) c->state.enables |= GGL_ENABLE_W;
 706         else        c->state.enables &= ~GGL_ENABLE_W;
 707         ggl_state_changed(c, GGL_PIXEL_PIPELINE_STATE);
 708     }
 709 }
 710
 711 void ggl_enable_texture2d(context_t* c, int enable)
 712 {
 713     if (c->activeTMU->enable != enable) {
 714         const uint32_t tmu = c->activeTMUIndex;
 715         c->activeTMU->enable = enable;
 716         const uint32_t mask = 1UL << tmu;
 717         if (enable)                 c->state.enabled_tmu |= mask;
 718         else                        c->state.enabled_tmu &= ~mask;
 719         if (c->state.enabled_tmu)   c->state.enables |= GGL_ENABLE_TMUS;
 720         else                        c->state.enables &= ~GGL_ENABLE_TMUS;
 721         ggl_state_changed(c, GGL_TMU_STATE);
 722     }
 723 }
 724
 725
 726 // ----------------------------------------------------------------------------
 727
 728 int64_t ggl_system_time()
 729 {
 730 #if defined(HAVE_POSIX_CLOCKS)
 731     struct timespec t;
 732     t.tv_sec = t.tv_nsec = 0;
 733     clock_gettime(CLOCK_THREAD_CPUTIME_ID, &t);
 734     return int64_t(t.tv_sec)*1000000000LL + t.tv_nsec;
 735 #else
 736     // we don't support the clocks here.
 737     struct timeval t;
 738     t.tv_sec = t.tv_usec = 0;
 739     gettimeofday(&t, NULL);
 740     return int64_t(t.tv_sec)*1000000000LL + int64_t(t.tv_usec)*1000LL;
 741 #endif
 742 }
 743
 744 // ----------------------------------------------------------------------------
 745
 746 void ggl_init_procs(context_t* c)
 747 {
 748     GGLContext& procs = *(GGLContext*)c;
 749     GGL_INIT_PROC(procs, scissor);
 750     GGL_INIT_PROC(procs, activeTexture);
 751     GGL_INIT_PROC(procs, bindTexture);
 752     GGL_INIT_PROC(procs, bindTextureLod);
 753     GGL_INIT_PROC(procs, colorBuffer);
 754     GGL_INIT_PROC(procs, readBuffer);
 755     GGL_INIT_PROC(procs, depthBuffer);
 756     GGL_INIT_PROC(procs, enable);
 757     GGL_INIT_PROC(procs, disable);
 758     GGL_INIT_PROC(procs, enableDisable);
 759     GGL_INIT_PROC(procs, shadeModel);
 760     GGL_INIT_PROC(procs, color4xv);
 761     GGL_INIT_PROC(procs, colorGrad12xv);
 762     GGL_INIT_PROC(procs, zGrad3xv);
 763     GGL_INIT_PROC(procs, wGrad3xv);
 764     GGL_INIT_PROC(procs, fogGrad3xv);
 765     GGL_INIT_PROC(procs, fogColor3xv);
 766     GGL_INIT_PROC(procs, blendFunc);
 767     GGL_INIT_PROC(procs, blendFuncSeparate);
 768     GGL_INIT_PROC(procs, texEnvi);
 769     GGL_INIT_PROC(procs, texEnvxv);
 770     GGL_INIT_PROC(procs, texParameteri);
 771     GGL_INIT_PROC(procs, texCoord2i);
 772     GGL_INIT_PROC(procs, texCoord2x);
 773     GGL_INIT_PROC(procs, texCoordGradScale8xv);
 774     GGL_INIT_PROC(procs, texGeni);
 775     GGL_INIT_PROC(procs, colorMask);
 776     GGL_INIT_PROC(procs, depthMask);
 777     GGL_INIT_PROC(procs, stencilMask);
 778     GGL_INIT_PROC(procs, alphaFuncx);
 779     GGL_INIT_PROC(procs, depthFunc);
 780     GGL_INIT_PROC(procs, logicOp);
 781     ggl_init_clear(c);
 782 }
 783
 784 void ggl_init_context(context_t* c)
 785 {
 786     memset(c, 0, sizeof(context_t));
 787     ggl_init_procs(c);
 788     ggl_init_trap(c);
 789     ggl_init_scanline(c);
 790     ggl_init_texture(c);
 791     ggl_init_picker(c);
 792     ggl_init_raster(c);
 793     c->formats = gglGetPixelFormatTable();
 794     c->state.blend.src = GGL_ONE;
 795     c->state.blend.dst = GGL_ZERO;
 796     c->state.blend.src_alpha = GGL_ONE;
 797     c->state.blend.dst_alpha = GGL_ZERO;
 798     c->state.mask.color = 0xF;
 799     c->state.mask.depth = 0;
 800     c->state.mask.stencil = 0xFFFFFFFF;
 801     c->state.logic_op.opcode = GGL_COPY;
 802     c->state.alpha_test.func = GGL_ALWAYS;
 803     c->state.depth_test.func = GGL_LESS;
 804     c->state.depth_test.clearValue = FIXED_ONE;
 805     c->shade.w0 = FIXED_ONE;
 806     memcpy(c->ditherMatrix, gDitherMatrix, sizeof(gDitherMatrix));
 807 }
 808
 809 void ggl_uninit_context(context_t* c)
 810 {
 811     ggl_uninit_scanline(c);
 812 }
 813
 814 // ----------------------------------------------------------------------------
 815 }; // namespace android
 816 // ----------------------------------------------------------------------------
 817
 818
 819
 820 using namespace android;
 821
 822 ssize_t gglInit(GGLContext** context)
 823 {
 824     void* const base = malloc(sizeof(context_t) + 32);
 825         if (base) {
 826         // always align the context on cache lines
 827         context_t *c = (context_t *)((ptrdiff_t(base)+31) & ~0x1FL);
 828         ggl_init_context(c);
 829         c->base = base;
 830                 *context = (GGLContext*)c;
 831         } else {
 832                 return -1;
 833         }
 834         return 0;
 835 }
 836
 837 ssize_t gglUninit(GGLContext* con)
 838 {
 839     GGL_CONTEXT(c, (void*)con);
 840     ggl_uninit_context(c);
 841         free(c->base);
 842         return 0;
 843 }
 844