Home | History | Annotate | Download | only in libagl
      1 /* libs/opengles/matrix.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 #include <stdlib.h>
     19 #include <stdio.h>
     20 
     21 #include "context.h"
     22 #include "fp.h"
     23 #include "state.h"
     24 #include "matrix.h"
     25 #include "vertex.h"
     26 #include "light.h"
     27 
     28 #if defined(__arm__) && defined(__thumb__)
     29 #warning "matrix.cpp should not be compiled in thumb on ARM."
     30 #endif
     31 
     32 #define I(_i, _j) ((_j)+ 4*(_i))
     33 
     34 namespace android {
     35 
     36 // ----------------------------------------------------------------------------
     37 
     38 static const GLfloat gIdentityf[16] = { 1,0,0,0,
     39                                         0,1,0,0,
     40                                         0,0,1,0,
     41                                         0,0,0,1 };
     42 
     43 static const matrixx_t gIdentityx = {
     44             {   0x10000,0,0,0,
     45                 0,0x10000,0,0,
     46                 0,0,0x10000,0,
     47                 0,0,0,0x10000
     48             }
     49         };
     50 
     51 static void point2__nop(transform_t const*, vec4_t* c, vec4_t const* o);
     52 static void point3__nop(transform_t const*, vec4_t* c, vec4_t const* o);
     53 static void point4__nop(transform_t const*, vec4_t* c, vec4_t const* o);
     54 static void normal__nop(transform_t const*, vec4_t* c, vec4_t const* o);
     55 static void point2__generic(transform_t const*, vec4_t* c, vec4_t const* o);
     56 static void point3__generic(transform_t const*, vec4_t* c, vec4_t const* o);
     57 static void point4__generic(transform_t const*, vec4_t* c, vec4_t const* o);
     58 static void point3__mvui(transform_t const*, vec4_t* c, vec4_t const* o);
     59 static void point4__mvui(transform_t const*, vec4_t* c, vec4_t const* o);
     60 
     61 // ----------------------------------------------------------------------------
     62 #if 0
     63 #pragma mark -
     64 #endif
     65 
     66 void ogles_init_matrix(ogles_context_t* c)
     67 {
     68     c->transforms.modelview.init(OGLES_MODELVIEW_STACK_DEPTH);
     69     c->transforms.projection.init(OGLES_PROJECTION_STACK_DEPTH);
     70     for (int i=0; i<GGL_TEXTURE_UNIT_COUNT ; i++)
     71         c->transforms.texture[i].init(OGLES_TEXTURE_STACK_DEPTH);
     72 
     73     c->transforms.current = &c->transforms.modelview;
     74     c->transforms.matrixMode = GL_MODELVIEW;
     75     c->transforms.dirty =   transform_state_t::VIEWPORT |
     76                             transform_state_t::MVUI |
     77                             transform_state_t::MVIT |
     78                             transform_state_t::MVP;
     79     c->transforms.mvp.loadIdentity();
     80     c->transforms.mvp4.loadIdentity();
     81     c->transforms.mvit4.loadIdentity();
     82     c->transforms.mvui.loadIdentity();
     83     c->transforms.vpt.loadIdentity();
     84     c->transforms.vpt.zNear = 0.0f;
     85     c->transforms.vpt.zFar  = 1.0f;
     86 }
     87 
     88 void ogles_uninit_matrix(ogles_context_t* c)
     89 {
     90     c->transforms.modelview.uninit();
     91     c->transforms.projection.uninit();
     92     for (int i=0; i<GGL_TEXTURE_UNIT_COUNT ; i++)
     93         c->transforms.texture[i].uninit();
     94 }
     95 
     96 static void validate_perspective(ogles_context_t* c, vertex_t* v)
     97 {
     98     const uint32_t enables = c->rasterizer.state.enables;
     99     c->arrays.perspective = (c->clipPlanes.enable) ?
    100         ogles_vertex_clipAllPerspective3D : ogles_vertex_perspective3D;
    101     if (enables & (GGL_ENABLE_DEPTH_TEST|GGL_ENABLE_FOG)) {
    102         c->arrays.perspective = ogles_vertex_perspective3DZ;
    103         if (c->clipPlanes.enable || (enables&GGL_ENABLE_FOG))
    104             c->arrays.perspective = ogles_vertex_clipAllPerspective3DZ;
    105     }
    106     if ((c->arrays.vertex.size != 4) &&
    107         (c->transforms.mvp4.flags & transform_t::FLAGS_2D_PROJECTION)) {
    108         c->arrays.perspective = ogles_vertex_perspective2D;
    109     }
    110     c->arrays.perspective(c, v);
    111 }
    112 
    113 void ogles_invalidate_perspective(ogles_context_t* c)
    114 {
    115     c->arrays.perspective = validate_perspective;
    116 }
    117 
    118 void ogles_validate_transform_impl(ogles_context_t* c, uint32_t want)
    119 {
    120     int dirty = c->transforms.dirty & want;
    121 
    122     // Validate the modelview
    123     if (dirty & transform_state_t::MODELVIEW) {
    124         c->transforms.modelview.validate();
    125     }
    126 
    127     // Validate the projection stack (in fact, it's never needed)
    128     if (dirty & transform_state_t::PROJECTION) {
    129         c->transforms.projection.validate();
    130     }
    131 
    132     // Validate the viewport transformation
    133     if (dirty & transform_state_t::VIEWPORT) {
    134         vp_transform_t& vpt = c->transforms.vpt;
    135         vpt.transform.matrix.load(vpt.matrix);
    136         vpt.transform.picker();
    137     }
    138 
    139     // We need to update the mvp (used to transform each vertex)
    140     if (dirty & transform_state_t::MVP) {
    141         c->transforms.update_mvp();
    142         // invalidate perspective (divide by W) and view volume clipping
    143         ogles_invalidate_perspective(c);
    144     }
    145 
    146     // Validate the mvui (for normal transformation)
    147     if (dirty & transform_state_t::MVUI) {
    148         c->transforms.update_mvui();
    149         ogles_invalidate_lighting_mvui(c);
    150     }
    151 
    152     // Validate the texture stack
    153     if (dirty & transform_state_t::TEXTURE) {
    154         for (int i=0; i<GGL_TEXTURE_UNIT_COUNT ; i++)
    155             c->transforms.texture[i].validate();
    156     }
    157 
    158     // Validate the mvit4 (user-clip planes)
    159     if (dirty & transform_state_t::MVIT) {
    160         c->transforms.update_mvit();
    161     }
    162 
    163     c->transforms.dirty &= ~want;
    164 }
    165 
    166 // ----------------------------------------------------------------------------
    167 #if 0
    168 #pragma mark -
    169 #pragma mark transform_t
    170 #endif
    171 
    172 void transform_t::loadIdentity() {
    173     matrix = gIdentityx;
    174     flags = 0;
    175     ops = OP_IDENTITY;
    176     point2 = point2__nop;
    177     point3 = point3__nop;
    178     point4 = point4__nop;
    179 }
    180 
    181 
    182 static inline
    183 int notZero(GLfixed v) {
    184     return abs(v) & ~0x3;
    185 }
    186 
    187 static inline
    188 int notOne(GLfixed v) {
    189     return notZero(v - 0x10000);
    190 }
    191 
    192 void transform_t::picker()
    193 {
    194     const GLfixed* const m = matrix.m;
    195 
    196     // XXX: picker needs to be smarter
    197     flags = 0;
    198     ops = OP_ALL;
    199     point2 = point2__generic;
    200     point3 = point3__generic;
    201     point4 = point4__generic;
    202 
    203     // find out if this is a 2D projection
    204     if (!(notZero(m[3]) | notZero(m[7]) | notZero(m[11]) | notOne(m[15]))) {
    205         flags |= FLAGS_2D_PROJECTION;
    206     }
    207 }
    208 
    209 void mvui_transform_t::picker()
    210 {
    211     flags = 0;
    212     ops = OP_ALL;
    213     point3 = point3__mvui;
    214     point4 = point4__mvui;
    215 }
    216 
    217 void transform_t::dump(const char* what)
    218 {
    219     GLfixed const * const m = matrix.m;
    220     LOGD("%s:", what);
    221     for (int i=0 ; i<4 ; i++)
    222         LOGD("[%08x %08x %08x %08x] [%f %f %f %f]\n",
    223             m[I(0,i)], m[I(1,i)], m[I(2,i)], m[I(3,i)],
    224             fixedToFloat(m[I(0,i)]),
    225             fixedToFloat(m[I(1,i)]),
    226             fixedToFloat(m[I(2,i)]),
    227             fixedToFloat(m[I(3,i)]));
    228 }
    229 
    230 // ----------------------------------------------------------------------------
    231 #if 0
    232 #pragma mark -
    233 #pragma mark matrixx_t
    234 #endif
    235 
    236 void matrixx_t::load(const matrixf_t& rhs) {
    237     GLfixed* xp = m;
    238     GLfloat const* fp = rhs.elements();
    239     unsigned int i = 16;
    240     do {
    241         const GLfloat f = *fp++;
    242         *xp++ = isZerof(f) ? 0 : gglFloatToFixed(f);
    243     } while (--i);
    244 }
    245 
    246 // ----------------------------------------------------------------------------
    247 #if 0
    248 #pragma mark -
    249 #pragma mark matrixf_t
    250 #endif
    251 
    252 void matrixf_t::multiply(matrixf_t& r, const matrixf_t& lhs, const matrixf_t& rhs)
    253 {
    254     GLfloat const* const m = lhs.m;
    255     for (int i=0 ; i<4 ; i++) {
    256         register const float rhs_i0 = rhs.m[ I(i,0) ];
    257         register float ri0 = m[ I(0,0) ] * rhs_i0;
    258         register float ri1 = m[ I(0,1) ] * rhs_i0;
    259         register float ri2 = m[ I(0,2) ] * rhs_i0;
    260         register float ri3 = m[ I(0,3) ] * rhs_i0;
    261         for (int j=1 ; j<4 ; j++) {
    262             register const float rhs_ij = rhs.m[ I(i,j) ];
    263             ri0 += m[ I(j,0) ] * rhs_ij;
    264             ri1 += m[ I(j,1) ] * rhs_ij;
    265             ri2 += m[ I(j,2) ] * rhs_ij;
    266             ri3 += m[ I(j,3) ] * rhs_ij;
    267         }
    268         r.m[ I(i,0) ] = ri0;
    269         r.m[ I(i,1) ] = ri1;
    270         r.m[ I(i,2) ] = ri2;
    271         r.m[ I(i,3) ] = ri3;
    272     }
    273 }
    274 
    275 void matrixf_t::dump(const char* what) {
    276     LOGD("%s", what);
    277     LOGD("[ %9f %9f %9f %9f ]", m[I(0,0)], m[I(1,0)], m[I(2,0)], m[I(3,0)]);
    278     LOGD("[ %9f %9f %9f %9f ]", m[I(0,1)], m[I(1,1)], m[I(2,1)], m[I(3,1)]);
    279     LOGD("[ %9f %9f %9f %9f ]", m[I(0,2)], m[I(1,2)], m[I(2,2)], m[I(3,2)]);
    280     LOGD("[ %9f %9f %9f %9f ]", m[I(0,3)], m[I(1,3)], m[I(2,3)], m[I(3,3)]);
    281 }
    282 
    283 void matrixf_t::loadIdentity() {
    284     memcpy(m, gIdentityf, sizeof(m));
    285 }
    286 
    287 void matrixf_t::set(const GLfixed* rhs) {
    288     load(rhs);
    289 }
    290 
    291 void matrixf_t::set(const GLfloat* rhs) {
    292     load(rhs);
    293 }
    294 
    295 void matrixf_t::load(const GLfixed* rhs) {
    296     GLfloat* fp = m;
    297     unsigned int i = 16;
    298     do {
    299         *fp++ = fixedToFloat(*rhs++);
    300     } while (--i);
    301 }
    302 
    303 void matrixf_t::load(const GLfloat* rhs) {
    304     memcpy(m, rhs, sizeof(m));
    305 }
    306 
    307 void matrixf_t::load(const matrixf_t& rhs) {
    308     operator = (rhs);
    309 }
    310 
    311 void matrixf_t::multiply(const matrixf_t& rhs) {
    312     matrixf_t r;
    313     multiply(r, *this, rhs);
    314     operator = (r);
    315 }
    316 
    317 void matrixf_t::translate(GLfloat x, GLfloat y, GLfloat z) {
    318     for (int i=0 ; i<4 ; i++) {
    319         m[12+i] += m[i]*x + m[4+i]*y + m[8+i]*z;
    320     }
    321 }
    322 
    323 void matrixf_t::scale(GLfloat x, GLfloat y, GLfloat z) {
    324     for (int i=0 ; i<4 ; i++) {
    325         m[  i] *= x;
    326         m[4+i] *= y;
    327         m[8+i] *= z;
    328     }
    329 }
    330 
    331 void matrixf_t::rotate(GLfloat a, GLfloat x, GLfloat y, GLfloat z)
    332 {
    333     matrixf_t rotation;
    334     GLfloat* r = rotation.m;
    335     GLfloat c, s;
    336     r[3] = 0;   r[7] = 0;   r[11]= 0;
    337     r[12]= 0;   r[13]= 0;   r[14]= 0;   r[15]= 1;
    338     a *= GLfloat(M_PI / 180.0f);
    339     sincosf(a, &s, &c);
    340     if (isOnef(x) && isZerof(y) && isZerof(z)) {
    341         r[5] = c;   r[10]= c;
    342         r[6] = s;   r[9] = -s;
    343         r[1] = 0;   r[2] = 0;
    344         r[4] = 0;   r[8] = 0;
    345         r[0] = 1;
    346     } else if (isZerof(x) && isOnef(y) && isZerof(z)) {
    347         r[0] = c;   r[10]= c;
    348         r[8] = s;   r[2] = -s;
    349         r[1] = 0;   r[4] = 0;
    350         r[6] = 0;   r[9] = 0;
    351         r[5] = 1;
    352     } else if (isZerof(x) && isZerof(y) && isOnef(z)) {
    353         r[0] = c;   r[5] = c;
    354         r[1] = s;   r[4] = -s;
    355         r[2] = 0;   r[6] = 0;
    356         r[8] = 0;   r[9] = 0;
    357         r[10]= 1;
    358     } else {
    359         const GLfloat len = sqrtf(x*x + y*y + z*z);
    360         if (!isOnef(len)) {
    361             const GLfloat recipLen = reciprocalf(len);
    362             x *= recipLen;
    363             y *= recipLen;
    364             z *= recipLen;
    365         }
    366         const GLfloat nc = 1.0f - c;
    367         const GLfloat xy = x * y;
    368         const GLfloat yz = y * z;
    369         const GLfloat zx = z * x;
    370         const GLfloat xs = x * s;
    371         const GLfloat ys = y * s;
    372         const GLfloat zs = z * s;
    373         r[ 0] = x*x*nc +  c;    r[ 4] =  xy*nc - zs;    r[ 8] =  zx*nc + ys;
    374         r[ 1] =  xy*nc + zs;    r[ 5] = y*y*nc +  c;    r[ 9] =  yz*nc - xs;
    375         r[ 2] =  zx*nc - ys;    r[ 6] =  yz*nc + xs;    r[10] = z*z*nc +  c;
    376     }
    377     multiply(rotation);
    378 }
    379 
    380 // ----------------------------------------------------------------------------
    381 #if 0
    382 #pragma mark -
    383 #pragma mark matrix_stack_t
    384 #endif
    385 
    386 void matrix_stack_t::init(int depth) {
    387     stack = new matrixf_t[depth];
    388     ops = new uint8_t[depth];
    389     maxDepth = depth;
    390     depth = 0;
    391     dirty = 0;
    392     loadIdentity();
    393 }
    394 
    395 void matrix_stack_t::uninit() {
    396     delete [] stack;
    397     delete [] ops;
    398 }
    399 
    400 void matrix_stack_t::loadIdentity() {
    401     transform.loadIdentity();
    402     stack[depth].loadIdentity();
    403     ops[depth] = OP_IDENTITY;
    404 }
    405 
    406 void matrix_stack_t::load(const GLfixed* rhs)
    407 {
    408     memcpy(transform.matrix.m, rhs, sizeof(transform.matrix.m));
    409     stack[depth].load(rhs);
    410     ops[depth] = OP_ALL;    // TODO: we should look at the matrix
    411 }
    412 
    413 void matrix_stack_t::load(const GLfloat* rhs)
    414 {
    415     stack[depth].load(rhs);
    416     ops[depth] = OP_ALL;    // TODO: we should look at the matrix
    417 }
    418 
    419 void matrix_stack_t::multiply(const matrixf_t& rhs)
    420 {
    421     stack[depth].multiply(rhs);
    422     ops[depth] = OP_ALL;    // TODO: we should look at the matrix
    423 }
    424 
    425 void matrix_stack_t::translate(GLfloat x, GLfloat y, GLfloat z)
    426 {
    427     stack[depth].translate(x,y,z);
    428     ops[depth] |= OP_TRANSLATE;
    429 }
    430 
    431 void matrix_stack_t::scale(GLfloat x, GLfloat y, GLfloat z)
    432 {
    433     stack[depth].scale(x,y,z);
    434     if (x==y && y==z) {
    435         ops[depth] |= OP_UNIFORM_SCALE;
    436     } else {
    437         ops[depth] |= OP_SCALE;
    438     }
    439 }
    440 
    441 void matrix_stack_t::rotate(GLfloat a, GLfloat x, GLfloat y, GLfloat z)
    442 {
    443     stack[depth].rotate(a,x,y,z);
    444     ops[depth] |= OP_ROTATE;
    445 }
    446 
    447 void matrix_stack_t::validate()
    448 {
    449     if (dirty & DO_FLOAT_TO_FIXED) {
    450         transform.matrix.load(top());
    451     }
    452     if (dirty & DO_PICKER) {
    453         transform.picker();
    454     }
    455     dirty = 0;
    456 }
    457 
    458 GLint matrix_stack_t::push()
    459 {
    460     if (depth >= (maxDepth-1)) {
    461         return GL_STACK_OVERFLOW;
    462     }
    463     stack[depth+1] = stack[depth];
    464     ops[depth+1] = ops[depth];
    465     depth++;
    466     return 0;
    467 }
    468 
    469 GLint matrix_stack_t::pop()
    470 {
    471     if (depth == 0) {
    472         return GL_STACK_UNDERFLOW;
    473     }
    474     depth--;
    475     return 0;
    476 }
    477 
    478 // ----------------------------------------------------------------------------
    479 #if 0
    480 #pragma mark -
    481 #pragma mark vp_transform_t
    482 #endif
    483 
    484 void vp_transform_t::loadIdentity() {
    485     transform.loadIdentity();
    486     matrix.loadIdentity();
    487 }
    488 
    489 // ----------------------------------------------------------------------------
    490 #if 0
    491 #pragma mark -
    492 #pragma mark transform_state_t
    493 #endif
    494 
    495 void transform_state_t::invalidate()
    496 {
    497     switch (matrixMode) {
    498     case GL_MODELVIEW:  dirty |= MODELVIEW  | MVP | MVUI | MVIT;    break;
    499     case GL_PROJECTION: dirty |= PROJECTION | MVP;                  break;
    500     case GL_TEXTURE:    dirty |= TEXTURE    | MVP;                  break;
    501     }
    502     current->dirty =    matrix_stack_t::DO_PICKER |
    503                         matrix_stack_t::DO_FLOAT_TO_FIXED;
    504 }
    505 
    506 void transform_state_t::update_mvp()
    507 {
    508     matrixf_t temp_mvp;
    509     matrixf_t::multiply(temp_mvp, projection.top(), modelview.top());
    510     mvp4.matrix.load(temp_mvp);
    511     mvp4.picker();
    512 
    513     if (mvp4.flags & transform_t::FLAGS_2D_PROJECTION) {
    514         // the mvp matrix doesn't transform W, in this case we can
    515         // premultiply it with the viewport transformation. In addition to
    516         // being more efficient, this is also much more accurate and in fact
    517         // is needed for 2D drawing with a resulting 1:1 mapping.
    518         matrixf_t mvpv;
    519         matrixf_t::multiply(mvpv, vpt.matrix, temp_mvp);
    520         mvp.matrix.load(mvpv);
    521         mvp.picker();
    522     } else {
    523         mvp = mvp4;
    524     }
    525 }
    526 
    527 static inline
    528 GLfloat det22(GLfloat a, GLfloat b, GLfloat c, GLfloat d) {
    529     return a*d - b*c;
    530 }
    531 
    532 static inline
    533 GLfloat ndet22(GLfloat a, GLfloat b, GLfloat c, GLfloat d) {
    534     return b*c - a*d;
    535 }
    536 
    537 static __attribute__((noinline))
    538 void invert(GLfloat* inverse, const GLfloat* src)
    539 {
    540     double t;
    541     int i, j, k, swap;
    542     GLfloat tmp[4][4];
    543 
    544     memcpy(inverse, gIdentityf, sizeof(gIdentityf));
    545     memcpy(tmp, src, sizeof(GLfloat)*16);
    546 
    547     for (i = 0; i < 4; i++) {
    548         // look for largest element in column
    549         swap = i;
    550         for (j = i + 1; j < 4; j++) {
    551             if (fabs(tmp[j][i]) > fabs(tmp[i][i])) {
    552                 swap = j;
    553             }
    554         }
    555 
    556         if (swap != i) {
    557             /* swap rows. */
    558             for (k = 0; k < 4; k++) {
    559                 t = tmp[i][k];
    560                 tmp[i][k] = tmp[swap][k];
    561                 tmp[swap][k] = t;
    562 
    563                 t = inverse[i*4+k];
    564                 inverse[i*4+k] = inverse[swap*4+k];
    565                 inverse[swap*4+k] = t;
    566             }
    567         }
    568 
    569         t = 1.0f / tmp[i][i];
    570         for (k = 0; k < 4; k++) {
    571             tmp[i][k] *= t;
    572             inverse[i*4+k] *= t;
    573         }
    574         for (j = 0; j < 4; j++) {
    575             if (j != i) {
    576                 t = tmp[j][i];
    577                 for (k = 0; k < 4; k++) {
    578                     tmp[j][k] -= tmp[i][k]*t;
    579                     inverse[j*4+k] -= inverse[i*4+k]*t;
    580                 }
    581             }
    582         }
    583     }
    584 }
    585 
    586 void transform_state_t::update_mvit()
    587 {
    588     GLfloat r[16];
    589     const GLfloat* const mv = modelview.top().elements();
    590     invert(r, mv);
    591     // convert to fixed-point and transpose
    592     GLfixed* const x = mvit4.matrix.m;
    593     for (int i=0 ; i<4 ; i++)
    594         for (int j=0 ; j<4 ; j++)
    595             x[I(i,j)] = gglFloatToFixed(r[I(j,i)]);
    596     mvit4.picker();
    597 }
    598 
    599 void transform_state_t::update_mvui()
    600 {
    601     GLfloat r[16];
    602     const GLfloat* const mv = modelview.top().elements();
    603 
    604     /*
    605     When evaluating the lighting equation in eye-space, normals
    606     are transformed by the upper 3x3 modelview inverse-transpose.
    607     http://www.opengl.org/documentation/specs/version1.1/glspec1.1/node26.html
    608 
    609     (note that inverse-transpose is distributive).
    610     Also note that:
    611         l(obj) = inv(modelview).l(eye) for local light
    612         l(obj) =  tr(modelview).l(eye) for infinite light
    613     */
    614 
    615     invert(r, mv);
    616 
    617     GLfixed* const x = mvui.matrix.m;
    618 
    619 #if OBJECT_SPACE_LIGHTING
    620     for (int i=0 ; i<4 ; i++)
    621         for (int j=0 ; j<4 ; j++)
    622             x[I(i,j)] = gglFloatToFixed(r[I(i,j)]);
    623 #else
    624     for (int i=0 ; i<4 ; i++)
    625         for (int j=0 ; j<4 ; j++)
    626             x[I(i,j)] = gglFloatToFixed(r[I(j,i)]);
    627 #endif
    628 
    629     mvui.picker();
    630 }
    631 
    632 
    633 // ----------------------------------------------------------------------------
    634 // transformation and matrices API
    635 // ----------------------------------------------------------------------------
    636 #if 0
    637 #pragma mark -
    638 #pragma mark transformation and matrices API
    639 #endif
    640 
    641 int ogles_surfaceport(ogles_context_t* c, GLint x, GLint y)
    642 {
    643     c->viewport.surfaceport.x = x;
    644     c->viewport.surfaceport.y = y;
    645 
    646     ogles_viewport(c,
    647             c->viewport.x,
    648             c->viewport.y,
    649             c->viewport.w,
    650             c->viewport.h);
    651 
    652     ogles_scissor(c,
    653             c->viewport.scissor.x,
    654             c->viewport.scissor.y,
    655             c->viewport.scissor.w,
    656             c->viewport.scissor.h);
    657 
    658     return 0;
    659 }
    660 
    661 void ogles_scissor(ogles_context_t* c,
    662         GLint x, GLint y, GLsizei w, GLsizei h)
    663 {
    664     if ((w|h) < 0) {
    665         ogles_error(c, GL_INVALID_VALUE);
    666         return;
    667     }
    668     c->viewport.scissor.x = x;
    669     c->viewport.scissor.y = y;
    670     c->viewport.scissor.w = w;
    671     c->viewport.scissor.h = h;
    672 
    673     x += c->viewport.surfaceport.x;
    674     y += c->viewport.surfaceport.y;
    675 
    676     y = c->rasterizer.state.buffers.color.height - (y + h);
    677     c->rasterizer.procs.scissor(c, x, y, w, h);
    678 }
    679 
    680 void ogles_viewport(ogles_context_t* c,
    681         GLint x, GLint y, GLsizei w, GLsizei h)
    682 {
    683     if ((w|h)<0) {
    684         ogles_error(c, GL_INVALID_VALUE);
    685         return;
    686     }
    687 
    688     c->viewport.x = x;
    689     c->viewport.y = y;
    690     c->viewport.w = w;
    691     c->viewport.h = h;
    692 
    693     x += c->viewport.surfaceport.x;
    694     y += c->viewport.surfaceport.y;
    695 
    696     GLint H = c->rasterizer.state.buffers.color.height;
    697     GLfloat sx = div2f(w);
    698     GLfloat ox = sx + x;
    699     GLfloat sy = div2f(h);
    700     GLfloat oy = sy - y + (H - h);
    701 
    702     GLfloat near = c->transforms.vpt.zNear;
    703     GLfloat far  = c->transforms.vpt.zFar;
    704     GLfloat A = div2f(far - near);
    705     GLfloat B = div2f(far + near);
    706 
    707     // compute viewport matrix
    708     GLfloat* const f = c->transforms.vpt.matrix.editElements();
    709     f[0] = sx;  f[4] = 0;   f[ 8] = 0;  f[12] = ox;
    710     f[1] = 0;   f[5] =-sy;  f[ 9] = 0;  f[13] = oy;
    711     f[2] = 0;   f[6] = 0;   f[10] = A;  f[14] = B;
    712     f[3] = 0;   f[7] = 0;   f[11] = 0;  f[15] = 1;
    713     c->transforms.dirty |= transform_state_t::VIEWPORT;
    714     if (c->transforms.mvp4.flags & transform_t::FLAGS_2D_PROJECTION)
    715         c->transforms.dirty |= transform_state_t::MVP;
    716 }
    717 
    718 // ----------------------------------------------------------------------------
    719 #if 0
    720 #pragma mark -
    721 #pragma mark matrix * vertex
    722 #endif
    723 
    724 void point2__generic(transform_t const* mx, vec4_t* lhs, vec4_t const* rhs) {
    725     const GLfixed* const m = mx->matrix.m;
    726     const GLfixed rx = rhs->x;
    727     const GLfixed ry = rhs->y;
    728     lhs->x = mla2a(rx, m[ 0], ry, m[ 4], m[12]);
    729     lhs->y = mla2a(rx, m[ 1], ry, m[ 5], m[13]);
    730     lhs->z = mla2a(rx, m[ 2], ry, m[ 6], m[14]);
    731     lhs->w = mla2a(rx, m[ 3], ry, m[ 7], m[15]);
    732 }
    733 
    734 void point3__generic(transform_t const* mx, vec4_t* lhs, vec4_t const* rhs) {
    735     const GLfixed* const m = mx->matrix.m;
    736     const GLfixed rx = rhs->x;
    737     const GLfixed ry = rhs->y;
    738     const GLfixed rz = rhs->z;
    739     lhs->x = mla3a(rx, m[ 0], ry, m[ 4], rz, m[ 8], m[12]);
    740     lhs->y = mla3a(rx, m[ 1], ry, m[ 5], rz, m[ 9], m[13]);
    741     lhs->z = mla3a(rx, m[ 2], ry, m[ 6], rz, m[10], m[14]);
    742     lhs->w = mla3a(rx, m[ 3], ry, m[ 7], rz, m[11], m[15]);
    743 }
    744 
    745 void point4__generic(transform_t const* mx, vec4_t* lhs, vec4_t const* rhs) {
    746     const GLfixed* const m = mx->matrix.m;
    747     const GLfixed rx = rhs->x;
    748     const GLfixed ry = rhs->y;
    749     const GLfixed rz = rhs->z;
    750     const GLfixed rw = rhs->w;
    751     lhs->x = mla4(rx, m[ 0], ry, m[ 4], rz, m[ 8], rw, m[12]);
    752     lhs->y = mla4(rx, m[ 1], ry, m[ 5], rz, m[ 9], rw, m[13]);
    753     lhs->z = mla4(rx, m[ 2], ry, m[ 6], rz, m[10], rw, m[14]);
    754     lhs->w = mla4(rx, m[ 3], ry, m[ 7], rz, m[11], rw, m[15]);
    755 }
    756 
    757 void point3__mvui(transform_t const* mx, vec4_t* lhs, vec4_t const* rhs) {
    758     // this is used for transforming light positions back to object space.
    759     // w is used as a switch for directional lights, so we need
    760     // to preserve it.
    761     const GLfixed* const m = mx->matrix.m;
    762     const GLfixed rx = rhs->x;
    763     const GLfixed ry = rhs->y;
    764     const GLfixed rz = rhs->z;
    765     lhs->x = mla3(rx, m[ 0], ry, m[ 4], rz, m[ 8]);
    766     lhs->y = mla3(rx, m[ 1], ry, m[ 5], rz, m[ 9]);
    767     lhs->z = mla3(rx, m[ 2], ry, m[ 6], rz, m[10]);
    768     lhs->w = 0;
    769 }
    770 
    771 void point4__mvui(transform_t const* mx, vec4_t* lhs, vec4_t const* rhs) {
    772     // this is used for transforming light positions back to object space.
    773     // w is used as a switch for directional lights, so we need
    774     // to preserve it.
    775     const GLfixed* const m = mx->matrix.m;
    776     const GLfixed rx = rhs->x;
    777     const GLfixed ry = rhs->y;
    778     const GLfixed rz = rhs->z;
    779     const GLfixed rw = rhs->w;
    780     lhs->x = mla4(rx, m[ 0], ry, m[ 4], rz, m[ 8], rw, m[12]);
    781     lhs->y = mla4(rx, m[ 1], ry, m[ 5], rz, m[ 9], rw, m[13]);
    782     lhs->z = mla4(rx, m[ 2], ry, m[ 6], rz, m[10], rw, m[14]);
    783     lhs->w = rw;
    784 }
    785 
    786 void point2__nop(transform_t const*, vec4_t* lhs, vec4_t const* rhs) {
    787     lhs->z = 0;
    788     lhs->w = 0x10000;
    789     if (lhs != rhs) {
    790         lhs->x = rhs->x;
    791         lhs->y = rhs->y;
    792     }
    793 }
    794 
    795 void point3__nop(transform_t const*, vec4_t* lhs, vec4_t const* rhs) {
    796     lhs->w = 0x10000;
    797     if (lhs != rhs) {
    798         lhs->x = rhs->x;
    799         lhs->y = rhs->y;
    800         lhs->z = rhs->z;
    801     }
    802 }
    803 
    804 void point4__nop(transform_t const*, vec4_t* lhs, vec4_t const* rhs) {
    805     if (lhs != rhs)
    806         *lhs = *rhs;
    807 }
    808 
    809 
    810 static void frustumf(
    811             GLfloat left, GLfloat right,
    812             GLfloat bottom, GLfloat top,
    813             GLfloat zNear, GLfloat zFar,
    814             ogles_context_t* c)
    815     {
    816     if (cmpf(left,right) ||
    817         cmpf(top, bottom) ||
    818         cmpf(zNear, zFar) ||
    819         isZeroOrNegativef(zNear) ||
    820         isZeroOrNegativef(zFar))
    821     {
    822         ogles_error(c, GL_INVALID_VALUE);
    823         return;
    824     }
    825     const GLfloat r_width  = reciprocalf(right - left);
    826     const GLfloat r_height = reciprocalf(top - bottom);
    827     const GLfloat r_depth  = reciprocalf(zNear - zFar);
    828     const GLfloat x = mul2f(zNear * r_width);
    829     const GLfloat y = mul2f(zNear * r_height);
    830     const GLfloat A = mul2f((right + left) * r_width);
    831     const GLfloat B = (top + bottom) * r_height;
    832     const GLfloat C = (zFar + zNear) * r_depth;
    833     const GLfloat D = mul2f(zFar * zNear * r_depth);
    834     GLfloat f[16];
    835     f[ 0] = x;
    836     f[ 5] = y;
    837     f[ 8] = A;
    838     f[ 9] = B;
    839     f[10] = C;
    840     f[14] = D;
    841     f[11] = -1.0f;
    842     f[ 1] = f[ 2] = f[ 3] =
    843     f[ 4] = f[ 6] = f[ 7] =
    844     f[12] = f[13] = f[15] = 0.0f;
    845 
    846     matrixf_t rhs;
    847     rhs.set(f);
    848     c->transforms.current->multiply(rhs);
    849     c->transforms.invalidate();
    850 }
    851 
    852 static void orthof(
    853         GLfloat left, GLfloat right,
    854         GLfloat bottom, GLfloat top,
    855         GLfloat zNear, GLfloat zFar,
    856         ogles_context_t* c)
    857 {
    858     if (cmpf(left,right) ||
    859         cmpf(top, bottom) ||
    860         cmpf(zNear, zFar))
    861     {
    862         ogles_error(c, GL_INVALID_VALUE);
    863         return;
    864     }
    865     const GLfloat r_width  = reciprocalf(right - left);
    866     const GLfloat r_height = reciprocalf(top - bottom);
    867     const GLfloat r_depth  = reciprocalf(zFar - zNear);
    868     const GLfloat x =  mul2f(r_width);
    869     const GLfloat y =  mul2f(r_height);
    870     const GLfloat z = -mul2f(r_depth);
    871     const GLfloat tx = -(right + left) * r_width;
    872     const GLfloat ty = -(top + bottom) * r_height;
    873     const GLfloat tz = -(zFar + zNear) * r_depth;
    874     GLfloat f[16];
    875     f[ 0] = x;
    876     f[ 5] = y;
    877     f[10] = z;
    878     f[12] = tx;
    879     f[13] = ty;
    880     f[14] = tz;
    881     f[15] = 1.0f;
    882     f[ 1] = f[ 2] = f[ 3] =
    883     f[ 4] = f[ 6] = f[ 7] =
    884     f[ 8] = f[ 9] = f[11] = 0.0f;
    885     matrixf_t rhs;
    886     rhs.set(f);
    887     c->transforms.current->multiply(rhs);
    888     c->transforms.invalidate();
    889 }
    890 
    891 static void depthRangef(GLclampf zNear, GLclampf zFar, ogles_context_t* c)
    892 {
    893     zNear = clampToZerof(zNear > 1 ? 1 : zNear);
    894     zFar  = clampToZerof(zFar  > 1 ? 1 : zFar);
    895     GLfloat* const f = c->transforms.vpt.matrix.editElements();
    896     f[10] = div2f(zFar - zNear);
    897     f[14] = div2f(zFar + zNear);
    898     c->transforms.dirty |= transform_state_t::VIEWPORT;
    899     c->transforms.vpt.zNear = zNear;
    900     c->transforms.vpt.zFar  = zFar;
    901 }
    902 
    903 
    904 // ----------------------------------------------------------------------------
    905 }; // namespace android
    906 
    907 using namespace android;
    908 
    909 void glMatrixMode(GLenum mode)
    910 {
    911     ogles_context_t* c = ogles_context_t::get();
    912     matrix_stack_t* stack = 0;
    913     switch (mode) {
    914     case GL_MODELVIEW:
    915         stack = &c->transforms.modelview;
    916         break;
    917     case GL_PROJECTION:
    918         stack = &c->transforms.projection;
    919         break;
    920     case GL_TEXTURE:
    921         stack = &c->transforms.texture[c->textures.active];
    922         break;
    923     default:
    924         ogles_error(c, GL_INVALID_ENUM);
    925         return;
    926     }
    927     c->transforms.matrixMode = mode;
    928     c->transforms.current = stack;
    929 }
    930 
    931 void glLoadIdentity()
    932 {
    933     ogles_context_t* c = ogles_context_t::get();
    934     c->transforms.current->loadIdentity(); // also loads the GLfixed transform
    935     c->transforms.invalidate();
    936     c->transforms.current->dirty = 0;
    937 }
    938 
    939 void glLoadMatrixf(const GLfloat* m)
    940 {
    941     ogles_context_t* c = ogles_context_t::get();
    942     c->transforms.current->load(m);
    943     c->transforms.invalidate();
    944 }
    945 
    946 void glLoadMatrixx(const GLfixed* m)
    947 {
    948     ogles_context_t* c = ogles_context_t::get();
    949     c->transforms.current->load(m); // also loads the GLfixed transform
    950     c->transforms.invalidate();
    951     c->transforms.current->dirty &= ~matrix_stack_t::DO_FLOAT_TO_FIXED;
    952 }
    953 
    954 void glMultMatrixf(const GLfloat* m)
    955 {
    956     ogles_context_t* c = ogles_context_t::get();
    957     matrixf_t rhs;
    958     rhs.set(m);
    959     c->transforms.current->multiply(rhs);
    960     c->transforms.invalidate();
    961 }
    962 
    963 void glMultMatrixx(const GLfixed* m)
    964 {
    965     ogles_context_t* c = ogles_context_t::get();
    966     matrixf_t rhs;
    967     rhs.set(m);
    968     c->transforms.current->multiply(rhs);
    969     c->transforms.invalidate();
    970 }
    971 
    972 void glPopMatrix()
    973 {
    974     ogles_context_t* c = ogles_context_t::get();
    975     GLint err = c->transforms.current->pop();
    976     if (ggl_unlikely(err)) {
    977         ogles_error(c, err);
    978         return;
    979     }
    980     c->transforms.invalidate();
    981 }
    982 
    983 void glPushMatrix()
    984 {
    985     ogles_context_t* c = ogles_context_t::get();
    986     GLint err = c->transforms.current->push();
    987     if (ggl_unlikely(err)) {
    988         ogles_error(c, err);
    989         return;
    990     }
    991     c->transforms.invalidate();
    992 }
    993 
    994 void glFrustumf(
    995         GLfloat left, GLfloat right,
    996         GLfloat bottom, GLfloat top,
    997         GLfloat zNear, GLfloat zFar)
    998 {
    999     ogles_context_t* c = ogles_context_t::get();
   1000     frustumf(left, right, bottom, top, zNear, zFar, c);
   1001 }
   1002 
   1003 void glFrustumx(
   1004         GLfixed left, GLfixed right,
   1005         GLfixed bottom, GLfixed top,
   1006         GLfixed zNear, GLfixed zFar)
   1007 {
   1008     ogles_context_t* c = ogles_context_t::get();
   1009     frustumf( fixedToFloat(left), fixedToFloat(right),
   1010               fixedToFloat(bottom), fixedToFloat(top),
   1011               fixedToFloat(zNear), fixedToFloat(zFar),
   1012               c);
   1013 }
   1014 
   1015 void glOrthof(
   1016         GLfloat left, GLfloat right,
   1017         GLfloat bottom, GLfloat top,
   1018         GLfloat zNear, GLfloat zFar)
   1019 {
   1020     ogles_context_t* c = ogles_context_t::get();
   1021     orthof(left, right, bottom, top, zNear, zFar, c);
   1022 }
   1023 
   1024 void glOrthox(
   1025         GLfixed left, GLfixed right,
   1026         GLfixed bottom, GLfixed top,
   1027         GLfixed zNear, GLfixed zFar)
   1028 {
   1029     ogles_context_t* c = ogles_context_t::get();
   1030     orthof( fixedToFloat(left), fixedToFloat(right),
   1031             fixedToFloat(bottom), fixedToFloat(top),
   1032             fixedToFloat(zNear), fixedToFloat(zFar),
   1033             c);
   1034 }
   1035 
   1036 void glRotatef(GLfloat a, GLfloat x, GLfloat y, GLfloat z)
   1037 {
   1038     ogles_context_t* c = ogles_context_t::get();
   1039     c->transforms.current->rotate(a, x, y, z);
   1040     c->transforms.invalidate();
   1041 }
   1042 
   1043 void glRotatex(GLfixed a, GLfixed x, GLfixed y, GLfixed z)
   1044 {
   1045     ogles_context_t* c = ogles_context_t::get();
   1046     c->transforms.current->rotate(
   1047             fixedToFloat(a), fixedToFloat(x),
   1048             fixedToFloat(y), fixedToFloat(z));
   1049     c->transforms.invalidate();
   1050 }
   1051 
   1052 void glScalef(GLfloat x, GLfloat y, GLfloat z)
   1053 {
   1054     ogles_context_t* c = ogles_context_t::get();
   1055     c->transforms.current->scale(x, y, z);
   1056     c->transforms.invalidate();
   1057 }
   1058 
   1059 void glScalex(GLfixed x, GLfixed y, GLfixed z)
   1060 {
   1061     ogles_context_t* c = ogles_context_t::get();
   1062     c->transforms.current->scale(
   1063             fixedToFloat(x), fixedToFloat(y), fixedToFloat(z));
   1064     c->transforms.invalidate();
   1065 }
   1066 
   1067 void glTranslatef(GLfloat x, GLfloat y, GLfloat z)
   1068 {
   1069     ogles_context_t* c = ogles_context_t::get();
   1070     c->transforms.current->translate(x, y, z);
   1071     c->transforms.invalidate();
   1072 }
   1073 
   1074 void glTranslatex(GLfixed x, GLfixed y, GLfixed z)
   1075 {
   1076     ogles_context_t* c = ogles_context_t::get();
   1077     c->transforms.current->translate(
   1078             fixedToFloat(x), fixedToFloat(y), fixedToFloat(z));
   1079     c->transforms.invalidate();
   1080 }
   1081 
   1082 void glScissor(GLint x, GLint y, GLsizei w, GLsizei h)
   1083 {
   1084     ogles_context_t* c = ogles_context_t::get();
   1085     ogles_scissor(c, x, y, w, h);
   1086 }
   1087 
   1088 void glViewport(GLint x, GLint y, GLsizei w, GLsizei h)
   1089 {
   1090     ogles_context_t* c = ogles_context_t::get();
   1091     ogles_viewport(c, x, y, w, h);
   1092 }
   1093 
   1094 void glDepthRangef(GLclampf zNear, GLclampf zFar)
   1095 {
   1096     ogles_context_t* c = ogles_context_t::get();
   1097     depthRangef(zNear, zFar, c);
   1098 }
   1099 
   1100 void glDepthRangex(GLclampx zNear, GLclampx zFar)
   1101 {
   1102     ogles_context_t* c = ogles_context_t::get();
   1103     depthRangef(fixedToFloat(zNear), fixedToFloat(zFar), c);
   1104 }
   1105 
   1106 void glPolygonOffsetx(GLfixed factor, GLfixed units)
   1107 {
   1108     ogles_context_t* c = ogles_context_t::get();
   1109     c->polygonOffset.factor = factor;
   1110     c->polygonOffset.units = units;
   1111 }
   1112 
   1113 void glPolygonOffset(GLfloat factor, GLfloat units)
   1114 {
   1115     ogles_context_t* c = ogles_context_t::get();
   1116     c->polygonOffset.factor = gglFloatToFixed(factor);
   1117     c->polygonOffset.units = gglFloatToFixed(units);
   1118 }
   1119 
   1120 GLbitfield glQueryMatrixxOES(GLfixed* m, GLint* e)
   1121 {
   1122     ogles_context_t* c = ogles_context_t::get();
   1123     GLbitfield status = 0;
   1124     GLfloat const* f = c->transforms.current->top().elements();
   1125     for  (int i=0 ; i<16 ; i++) {
   1126         if (isnan(f[i]) || isinf(f[i])) {
   1127             status |= 1<<i;
   1128             continue;
   1129         }
   1130         e[i] = exponent(f[i]) - 7;
   1131         m[i] = mantissa(f[i]);
   1132     }
   1133     return status;
   1134 }
   1135