source/gles2glide64/src/Glide64/turbo3D.h

   1 /*
   2 * Glide64 - Glide video plugin for Nintendo 64 emulators.
   3 * Copyright (c) 2002  Dave2001
   4 * Copyright (c) 2003-2009  Sergey 'Gonetz' Lipski
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation; either version 2 of the License, or
   9 * any later version.
  10 *
  11 * This program is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with this program; if not, write to the Free Software
  18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21 //****************************************************************
  22 //
  23 // Glide64 - Glide Plugin for Nintendo 64 emulators
  24 // Project started on December 29th, 2001
  25 //
  26 // Authors:
  27 // Dave2001, original author, founded the project in 2001, left it in 2002
  28 // Gugaman, joined the project in 2002, left it in 2002
  29 // Sergey 'Gonetz' Lipski, joined the project in 2002, main author since fall of 2002
  30 // Hiroshi 'KoolSmoky' Morii, joined the project in 2007
  31 //
  32 //****************************************************************
  33 //
  34 // To modify Glide64:
  35 // * Write your name and (optional)email, commented by your work, so I know who did it, and so that you can find which parts you modified when it comes time to send it to me.
  36 // * Do NOT send me the whole project or file that you modified.  Take out your modified code sections, and tell me where to put them.  If people sent the whole thing, I would have many different versions, but no idea how to combine them all.
  37 //
  38 //****************************************************************
  39 //
  40 // Created by Gonetz, 2008
  41 //
  42 //****************************************************************
  43
  44 /******************Turbo3D microcode*************************/
  45
  46 struct t3dGlobState {
  47   wxUint16              pad0;
  48   wxUint16              perspNorm;
  49   wxUint32              flag;
  50   wxUint32              othermode0;
  51   wxUint32              othermode1;
  52   wxUint32              segBases[16];
  53   /* the viewport to use */
  54   short     vsacle1;
  55   short     vsacle0;
  56   short     vsacle3;
  57   short     vsacle2;
  58   short     vtrans1;
  59   short     vtrans0;
  60   short     vtrans3;
  61   short     vtrans2;
  62   wxUint32  rdpCmds;
  63 };
  64
  65 struct t3dState {
  66     wxUint32    renderState;    /* render state */
  67     wxUint32    textureState;   /* texture state */
  68     wxUint8     flag;
  69     wxUint8     triCount;       /* how many tris? */
  70     wxUint8     vtxV0;          /* where to load verts? */
  71     wxUint8     vtxCount;       /* how many verts? */
  72     wxUint32    rdpCmds;        /* ptr (segment address) to RDP DL */
  73     wxUint32    othermode0;
  74     wxUint32    othermode1;
  75 };
  76
  77
  78 struct t3dTriN{
  79    wxUint8      flag, v2, v1, v0;       /* flag is which one for flat shade */
  80 };
  81
  82
  83 static void t3dProcessRDP(wxUint32 a)
  84 {
  85   if (a)
  86   {
  87     rdp.LLE = 1;
  88     rdp.cmd0 = ((wxUint32*)gfx.RDRAM)[a++];
  89     rdp.cmd1 = ((wxUint32*)gfx.RDRAM)[a++];
  90     while (rdp.cmd0 + rdp.cmd1) {
  91       gfx_instruction[0][rdp.cmd0>>24] ();
  92       rdp.cmd0 = ((wxUint32*)gfx.RDRAM)[a++];
  93       rdp.cmd1 = ((wxUint32*)gfx.RDRAM)[a++];
  94       wxUint32 cmd = rdp.cmd0>>24;
  95       if (cmd == 0xE4 || cmd == 0xE5)
  96       {
  97         rdp.cmd2 = ((wxUint32*)gfx.RDRAM)[a++];
  98         rdp.cmd3 = ((wxUint32*)gfx.RDRAM)[a++];
  99       }
 100     }
 101     rdp.LLE = 0;
 102   }
 103 }
 104
 105 static void t3dLoadGlobState(wxUint32 pgstate)
 106 {
 107   t3dGlobState *gstate = (t3dGlobState*)&gfx.RDRAM[segoffset(pgstate)];
 108   FRDP ("Global state. pad0: %04lx, perspNorm: %04lx, flag: %08lx\n", gstate->pad0, gstate->perspNorm, gstate->flag);
 109   rdp.cmd0 = gstate->othermode0;
 110   rdp.cmd1 = gstate->othermode1;
 111   rdp_setothermode();
 112
 113   for (int s = 0; s < 16; s++)
 114   {
 115     rdp.segment[s] = gstate->segBases[s];
 116     FRDP ("segment: %08lx -> seg%d\n", rdp.segment[s], s);
 117   }
 118
 119   short scale_x = gstate->vsacle0 / 4;
 120   short scale_y = gstate->vsacle1 / 4;;
 121   short scale_z = gstate->vsacle2;
 122   short trans_x = gstate->vtrans0 / 4;
 123   short trans_y = gstate->vtrans1 / 4;
 124   short trans_z = gstate->vtrans2;
 125   rdp.view_scale[0] = scale_x * rdp.scale_x;
 126   rdp.view_scale[1] = -scale_y * rdp.scale_y;
 127   rdp.view_scale[2] = 32.0f * scale_z;
 128   rdp.view_trans[0] = trans_x * rdp.scale_x;
 129   rdp.view_trans[1] = trans_y * rdp.scale_y;
 130   rdp.view_trans[2] = 32.0f * trans_z;
 131   rdp.update |= UPDATE_VIEWPORT;
 132   FRDP ("viewport scale(%d, %d, %d), trans(%d, %d, %d)\n", scale_x, scale_y, scale_z,
 133     trans_x, trans_y, trans_z);
 134
 135   t3dProcessRDP(segoffset(gstate->rdpCmds) >> 2);
 136 }
 137
 138 static void t3d_vertex(wxUint32 addr, wxUint32 v0, wxUint32 n)
 139 {
 140     float x, y, z;
 141
 142     rdp.v0 = v0; // Current vertex
 143     rdp.vn = n; // Number of vertices to copy
 144     n <<= 4;
 145
 146     for (wxUint32 i=0; i < n; i+=16)
 147     {
 148       VERTEX *v = &rdp.vtx[v0 + (i>>4)];
 149       x   = (float)((short*)gfx.RDRAM)[(((addr+i) >> 1) + 0)^1];
 150       y   = (float)((short*)gfx.RDRAM)[(((addr+i) >> 1) + 1)^1];
 151       z   = (float)((short*)gfx.RDRAM)[(((addr+i) >> 1) + 2)^1];
 152       v->flags  = ((wxUint16*)gfx.RDRAM)[(((addr+i) >> 1) + 3)^1];
 153       v->ou   = 2.0f * (float)((short*)gfx.RDRAM)[(((addr+i) >> 1) + 4)^1];
 154       v->ov   = 2.0f * (float)((short*)gfx.RDRAM)[(((addr+i) >> 1) + 5)^1];
 155       v->uv_scaled = 0;
 156       v->r = ((wxUint8*)gfx.RDRAM)[(addr+i + 12)^3];
 157       v->g = ((wxUint8*)gfx.RDRAM)[(addr+i + 13)^3];
 158       v->b = ((wxUint8*)gfx.RDRAM)[(addr+i + 14)^3];
 159       v->a    = ((wxUint8*)gfx.RDRAM)[(addr+i + 15)^3];
 160
 161       v->x = x*rdp.combined[0][0] + y*rdp.combined[1][0] + z*rdp.combined[2][0] + rdp.combined[3][0];
 162       v->y = x*rdp.combined[0][1] + y*rdp.combined[1][1] + z*rdp.combined[2][1] + rdp.combined[3][1];
 163       v->z = x*rdp.combined[0][2] + y*rdp.combined[1][2] + z*rdp.combined[2][2] + rdp.combined[3][2];
 164       v->w = x*rdp.combined[0][3] + y*rdp.combined[1][3] + z*rdp.combined[2][3] + rdp.combined[3][3];
 165
 166       if (fabs(v->w) < 0.001) v->w = 0.001f;
 167       v->oow = 1.0f / v->w;
 168       v->x_w = v->x * v->oow;
 169       v->y_w = v->y * v->oow;
 170       v->z_w = v->z * v->oow;
 171
 172       v->uv_calculated = 0xFFFFFFFF;
 173       v->screen_translated = 0;
 174       v->shade_mod = 0;
 175
 176       v->scr_off = 0;
 177       if (v->x < -v->w) v->scr_off |= 1;
 178       if (v->x > v->w) v->scr_off |= 2;
 179       if (v->y < -v->w) v->scr_off |= 4;
 180       if (v->y > v->w) v->scr_off |= 8;
 181       if (v->w < 0.1f) v->scr_off |= 16;
 182 #ifdef EXTREME_LOGGING
 183     FRDP ("v%d - x: %f, y: %f, z: %f, w: %f, u: %f, v: %f, f: %f, z_w: %f, r=%d, g=%d, b=%d, a=%d\n", i>>4, v->x, v->y, v->z, v->w, v->ou*rdp.tiles[rdp.cur_tile].s_scale, v->ov*rdp.tiles[rdp.cur_tile].t_scale, v->f, v->z_w, v->r, v->g, v->b, v->a);
 184 #endif
 185     }
 186 }
 187
 188 static void t3dLoadObject(wxUint32 pstate, wxUint32 pvtx, wxUint32 ptri)
 189 {
 190   LRDP("Loading Turbo3D object\n");
 191   t3dState *ostate = (t3dState*)&gfx.RDRAM[segoffset(pstate)];
 192   rdp.cur_tile = (ostate->textureState)&7;
 193   FRDP("tile: %d\n", rdp.cur_tile);
 194   if (rdp.tiles[rdp.cur_tile].s_scale < 0.001f)
 195     rdp.tiles[rdp.cur_tile].s_scale = 0.015625;
 196   if (rdp.tiles[rdp.cur_tile].t_scale < 0.001f)
 197     rdp.tiles[rdp.cur_tile].t_scale = 0.015625;
 198
 199 #ifdef EXTREME_LOGGING
 200   FRDP("renderState: %08lx, textureState: %08lx, othermode0: %08lx, othermode1: %08lx, rdpCmds: %08lx, triCount : %d, v0: %d, vn: %d\n", ostate->renderState, ostate->textureState,
 201      ostate->othermode0, ostate->othermode1, ostate->rdpCmds, ostate->triCount, ostate->vtxV0, ostate->vtxCount);
 202 #endif
 203
 204   rdp.cmd0 = ostate->othermode0;
 205   rdp.cmd1 = ostate->othermode1;
 206   rdp_setothermode();
 207
 208   rdp.cmd1 = ostate->renderState;
 209   uc0_setgeometrymode();
 210
 211   if (!(ostate->flag&1)) //load matrix
 212   {
 213     wxUint32 addr = segoffset(pstate+sizeof(t3dState)) & BMASK;
 214     load_matrix(rdp.combined, addr);
 215 #ifdef EXTREME_LOGGING
 216       FRDP ("{%f,%f,%f,%f}\n", rdp.combined[0][0], rdp.combined[0][1], rdp.combined[0][2], rdp.combined[0][3]);
 217       FRDP ("{%f,%f,%f,%f}\n", rdp.combined[1][0], rdp.combined[1][1], rdp.combined[1][2], rdp.combined[1][3]);
 218       FRDP ("{%f,%f,%f,%f}\n", rdp.combined[2][0], rdp.combined[2][1], rdp.combined[2][2], rdp.combined[2][3]);
 219       FRDP ("{%f,%f,%f,%f}\n", rdp.combined[3][0], rdp.combined[3][1], rdp.combined[3][2], rdp.combined[3][3]);
 220 #endif
 221   }
 222
 223   rdp.geom_mode &= ~0x00020000;
 224   rdp.geom_mode |= 0x00000200;
 225   if (pvtx) //load vtx
 226     t3d_vertex(segoffset(pvtx) & BMASK, ostate->vtxV0, ostate->vtxCount);
 227
 228   t3dProcessRDP(segoffset(ostate->rdpCmds) >> 2);
 229
 230   if (ptri)
 231   {
 232     update ();
 233     wxUint32 a = segoffset(ptri);
 234     for (int t=0; t < ostate->triCount; t++)
 235     {
 236       t3dTriN * tri = (t3dTriN*)&gfx.RDRAM[a];
 237       a += 4;
 238       FRDP("tri #%d - %d, %d, %d\n", t, tri->v0, tri->v1, tri->v2);
 239       VERTEX *v[3] = { &rdp.vtx[tri->v0], &rdp.vtx[tri->v1], &rdp.vtx[tri->v2] };
 240       if (cull_tri(v))
 241         rdp.tri_n ++;
 242       else
 243       {
 244         draw_tri (v);
 245         rdp.tri_n ++;
 246       }
 247     }
 248   }
 249 }
 250
 251 static void Turbo3D()
 252 {
 253   LRDP("Start Turbo3D microcode\n");
 254   settings.ucode = ucode_Fast3D;
 255   wxUint32 a = 0, pgstate = 0, pstate = 0, pvtx = 0, ptri = 0;
 256   do {
 257     a = rdp.pc[rdp.pc_i] & BMASK;
 258     pgstate = ((wxUint32*)gfx.RDRAM)[a>>2];
 259     pstate = ((wxUint32*)gfx.RDRAM)[(a>>2)+1];
 260     pvtx = ((wxUint32*)gfx.RDRAM)[(a>>2)+2];
 261     ptri = ((wxUint32*)gfx.RDRAM)[(a>>2)+3];
 262     FRDP("GlobalState: %08lx, Object: %08lx, Vertices: %08lx, Triangles: %08lx\n", pgstate, pstate, pvtx, ptri);
 263     if (!pstate)
 264     {
 265       rdp.halt = 1;
 266       break;
 267     }
 268     if (pgstate)
 269       t3dLoadGlobState(pgstate);
 270     t3dLoadObject(pstate, pvtx, ptri);
 271    // Go to the next instruction
 272     rdp.pc[rdp.pc_i] += 16;
 273  } while (pstate);
 274 // rdp_fullsync();
 275  settings.ucode = ucode_Turbo3d;
 276 }