libpcsxcore/gte.c

   1 /***************************************************************************
   2  *   PCSX-Revolution - PlayStation Emulator for Nintendo Wii               *
   3  *   Copyright (C) 2009-2010  PCSX-Revolution Dev Team                     *
   4  *   <http://code.google.com/p/pcsx-revolution/>                           *
   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  *   (at your option) 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                         *
  18  *   Free Software Foundation, Inc.,                                       *
  19  *   51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA.           *
  20  ***************************************************************************/
  21
  22 /*
  23 * GTE functions.
  24 */
  25
  26 #include "gte.h"
  27 #include "psxmem.h"
  28
  29 #define VX(n) (n < 3 ? regs->CP2D.p[n << 1].sw.l : regs->CP2D.p[9].sw.l)
  30 #define VY(n) (n < 3 ? regs->CP2D.p[n << 1].sw.h : regs->CP2D.p[10].sw.l)
  31 #define VZ(n) (n < 3 ? regs->CP2D.p[(n << 1) + 1].sw.l : regs->CP2D.p[11].sw.l)
  32 #define MX11(n) (n < 3 ? regs->CP2C.p[(n << 3)].sw.l : 0)
  33 #define MX12(n) (n < 3 ? regs->CP2C.p[(n << 3)].sw.h : 0)
  34 #define MX13(n) (n < 3 ? regs->CP2C.p[(n << 3) + 1].sw.l : 0)
  35 #define MX21(n) (n < 3 ? regs->CP2C.p[(n << 3) + 1].sw.h : 0)
  36 #define MX22(n) (n < 3 ? regs->CP2C.p[(n << 3) + 2].sw.l : 0)
  37 #define MX23(n) (n < 3 ? regs->CP2C.p[(n << 3) + 2].sw.h : 0)
  38 #define MX31(n) (n < 3 ? regs->CP2C.p[(n << 3) + 3].sw.l : 0)
  39 #define MX32(n) (n < 3 ? regs->CP2C.p[(n << 3) + 3].sw.h : 0)
  40 #define MX33(n) (n < 3 ? regs->CP2C.p[(n << 3) + 4].sw.l : 0)
  41 #define CV1(n) (n < 3 ? (s32)regs->CP2C.r[(n << 3) + 5] : 0)
  42 #define CV2(n) (n < 3 ? (s32)regs->CP2C.r[(n << 3) + 6] : 0)
  43 #define CV3(n) (n < 3 ? (s32)regs->CP2C.r[(n << 3) + 7] : 0)
  44
  45 #define fSX(n) ((regs->CP2D.p)[((n) + 12)].sw.l)
  46 #define fSY(n) ((regs->CP2D.p)[((n) + 12)].sw.h)
  47 #define fSZ(n) ((regs->CP2D.p)[((n) + 17)].w.l) /* (n == 0) => SZ1; */
  48
  49 #define gteVXY0 (regs->CP2D.r[0])
  50 #define gteVX0  (regs->CP2D.p[0].sw.l)
  51 #define gteVY0  (regs->CP2D.p[0].sw.h)
  52 #define gteVZ0  (regs->CP2D.p[1].sw.l)
  53 #define gteVXY1 (regs->CP2D.r[2])
  54 #define gteVX1  (regs->CP2D.p[2].sw.l)
  55 #define gteVY1  (regs->CP2D.p[2].sw.h)
  56 #define gteVZ1  (regs->CP2D.p[3].sw.l)
  57 #define gteVXY2 (regs->CP2D.r[4])
  58 #define gteVX2  (regs->CP2D.p[4].sw.l)
  59 #define gteVY2  (regs->CP2D.p[4].sw.h)
  60 #define gteVZ2  (regs->CP2D.p[5].sw.l)
  61 #define gteRGB  (regs->CP2D.r[6])
  62 #define gteR    (regs->CP2D.p[6].b.l)
  63 #define gteG    (regs->CP2D.p[6].b.h)
  64 #define gteB    (regs->CP2D.p[6].b.h2)
  65 #define gteCODE (regs->CP2D.p[6].b.h3)
  66 #define gteOTZ  (regs->CP2D.p[7].w.l)
  67 #define gteIR0  (regs->CP2D.p[8].sw.l)
  68 #define gteIR1  (regs->CP2D.p[9].sw.l)
  69 #define gteIR2  (regs->CP2D.p[10].sw.l)
  70 #define gteIR3  (regs->CP2D.p[11].sw.l)
  71 #define gteSXY0 (regs->CP2D.r[12])
  72 #define gteSX0  (regs->CP2D.p[12].sw.l)
  73 #define gteSY0  (regs->CP2D.p[12].sw.h)
  74 #define gteSXY1 (regs->CP2D.r[13])
  75 #define gteSX1  (regs->CP2D.p[13].sw.l)
  76 #define gteSY1  (regs->CP2D.p[13].sw.h)
  77 #define gteSXY2 (regs->CP2D.r[14])
  78 #define gteSX2  (regs->CP2D.p[14].sw.l)
  79 #define gteSY2  (regs->CP2D.p[14].sw.h)
  80 #define gteSXYP (regs->CP2D.r[15])
  81 #define gteSXP  (regs->CP2D.p[15].sw.l)
  82 #define gteSYP  (regs->CP2D.p[15].sw.h)
  83 #define gteSZ0  (regs->CP2D.p[16].w.l)
  84 #define gteSZ1  (regs->CP2D.p[17].w.l)
  85 #define gteSZ2  (regs->CP2D.p[18].w.l)
  86 #define gteSZ3  (regs->CP2D.p[19].w.l)
  87 #define gteRGB0  (regs->CP2D.r[20])
  88 #define gteR0    (regs->CP2D.p[20].b.l)
  89 #define gteG0    (regs->CP2D.p[20].b.h)
  90 #define gteB0    (regs->CP2D.p[20].b.h2)
  91 #define gteCODE0 (regs->CP2D.p[20].b.h3)
  92 #define gteRGB1  (regs->CP2D.r[21])
  93 #define gteR1    (regs->CP2D.p[21].b.l)
  94 #define gteG1    (regs->CP2D.p[21].b.h)
  95 #define gteB1    (regs->CP2D.p[21].b.h2)
  96 #define gteCODE1 (regs->CP2D.p[21].b.h3)
  97 #define gteRGB2  (regs->CP2D.r[22])
  98 #define gteR2    (regs->CP2D.p[22].b.l)
  99 #define gteG2    (regs->CP2D.p[22].b.h)
 100 #define gteB2    (regs->CP2D.p[22].b.h2)
 101 #define gteCODE2 (regs->CP2D.p[22].b.h3)
 102 #define gteRES1  (regs->CP2D.r[23])
 103 #define gteMAC0  (((s32 *)regs->CP2D.r)[24])
 104 #define gteMAC1  (((s32 *)regs->CP2D.r)[25])
 105 #define gteMAC2  (((s32 *)regs->CP2D.r)[26])
 106 #define gteMAC3  (((s32 *)regs->CP2D.r)[27])
 107 #define gteIRGB  (regs->CP2D.r[28])
 108 #define gteORGB  (regs->CP2D.r[29])
 109 #define gteLZCS  (regs->CP2D.r[30])
 110 #define gteLZCR  (regs->CP2D.r[31])
 111
 112 #define gteR11R12 (((s32 *)regs->CP2C.r)[0])
 113 #define gteR22R23 (((s32 *)regs->CP2C.r)[2])
 114 #define gteR11 (regs->CP2C.p[0].sw.l)
 115 #define gteR12 (regs->CP2C.p[0].sw.h)
 116 #define gteR13 (regs->CP2C.p[1].sw.l)
 117 #define gteR21 (regs->CP2C.p[1].sw.h)
 118 #define gteR22 (regs->CP2C.p[2].sw.l)
 119 #define gteR23 (regs->CP2C.p[2].sw.h)
 120 #define gteR31 (regs->CP2C.p[3].sw.l)
 121 #define gteR32 (regs->CP2C.p[3].sw.h)
 122 #define gteR33 (regs->CP2C.p[4].sw.l)
 123 #define gteTRX (((s32 *)regs->CP2C.r)[5])
 124 #define gteTRY (((s32 *)regs->CP2C.r)[6])
 125 #define gteTRZ (((s32 *)regs->CP2C.r)[7])
 126 #define gteL11 (regs->CP2C.p[8].sw.l)
 127 #define gteL12 (regs->CP2C.p[8].sw.h)
 128 #define gteL13 (regs->CP2C.p[9].sw.l)
 129 #define gteL21 (regs->CP2C.p[9].sw.h)
 130 #define gteL22 (regs->CP2C.p[10].sw.l)
 131 #define gteL23 (regs->CP2C.p[10].sw.h)
 132 #define gteL31 (regs->CP2C.p[11].sw.l)
 133 #define gteL32 (regs->CP2C.p[11].sw.h)
 134 #define gteL33 (regs->CP2C.p[12].sw.l)
 135 #define gteRBK (((s32 *)regs->CP2C.r)[13])
 136 #define gteGBK (((s32 *)regs->CP2C.r)[14])
 137 #define gteBBK (((s32 *)regs->CP2C.r)[15])
 138 #define gteLR1 (regs->CP2C.p[16].sw.l)
 139 #define gteLR2 (regs->CP2C.p[16].sw.h)
 140 #define gteLR3 (regs->CP2C.p[17].sw.l)
 141 #define gteLG1 (regs->CP2C.p[17].sw.h)
 142 #define gteLG2 (regs->CP2C.p[18].sw.l)
 143 #define gteLG3 (regs->CP2C.p[18].sw.h)
 144 #define gteLB1 (regs->CP2C.p[19].sw.l)
 145 #define gteLB2 (regs->CP2C.p[19].sw.h)
 146 #define gteLB3 (regs->CP2C.p[20].sw.l)
 147 #define gteRFC (((s32 *)regs->CP2C.r)[21])
 148 #define gteGFC (((s32 *)regs->CP2C.r)[22])
 149 #define gteBFC (((s32 *)regs->CP2C.r)[23])
 150 #define gteOFX (((s32 *)regs->CP2C.r)[24])
 151 #define gteOFY (((s32 *)regs->CP2C.r)[25])
 152 // senquack - gteH register is u16, not s16, and used in GTE that way.
 153 //  HOWEVER when read back by CPU using CFC2, it will be incorrectly
 154 //  sign-extended by bug in original hardware, according to Nocash docs
 155 //  GTE section 'Screen Offset and Distance'. The emulator does this
 156 //  sign extension when it is loaded to GTE by CTC2.
 157 //#define gteH   (psxRegs.CP2C.p[26].sw.l)
 158 #define gteH   (psxRegs.CP2C.p[26].w.l)
 159 #define gteDQA (regs->CP2C.p[27].sw.l)
 160 #define gteDQB (((s32 *)regs->CP2C.r)[28])
 161 #define gteZSF3 (regs->CP2C.p[29].sw.l)
 162 #define gteZSF4 (regs->CP2C.p[30].sw.l)
 163 #define gteFLAG (regs->CP2C.r[31])
 164
 165 #define GTE_OP(op) ((op >> 20) & 31)
 166 #define GTE_SF(op) ((op >> 19) & 1)
 167 #define GTE_MX(op) ((op >> 17) & 3)
 168 #define GTE_V(op) ((op >> 15) & 3)
 169 #define GTE_CV(op) ((op >> 13) & 3)
 170 #define GTE_CD(op) ((op >> 11) & 3) /* not used */
 171 #define GTE_LM(op) ((op >> 10) & 1)
 172 #define GTE_CT(op) ((op >> 6) & 15) /* not used */
 173 #define GTE_FUNCT(op) (op & 63)
 174
 175 #define gteop (psxRegs.code & 0x1ffffff)
 176
 177 #ifndef FLAGLESS
 178
 179 static inline s64 BOUNDS_(psxCP2Regs *regs, s64 n_value, s64 n_max, int n_maxflag, s64 n_min, int n_minflag) {
 180         if (n_value > n_max) {
 181                 gteFLAG |= n_maxflag;
 182         } else if (n_value < n_min) {
 183                 gteFLAG |= n_minflag;
 184         }
 185         return n_value;
 186 }
 187
 188 static inline s32 LIM_(psxCP2Regs *regs, s32 value, s32 max, s32 min, u32 flag) {
 189         s32 ret = value;
 190         if (value > max) {
 191                 gteFLAG |= flag;
 192                 ret = max;
 193         } else if (value < min) {
 194                 gteFLAG |= flag;
 195                 ret = min;
 196         }
 197         return ret;
 198 }
 199
 200 static inline u32 limE_(psxCP2Regs *regs, u32 result) {
 201         if (result > 0x1ffff) {
 202                 gteFLAG |= (1 << 31) | (1 << 17);
 203                 return 0x1ffff;
 204         }
 205         return result;
 206 }
 207
 208 #else
 209
 210 #define BOUNDS_(regs, a, ...) (a)
 211
 212 static inline s32 LIM_(psxCP2Regs *regs, s32 value, s32 max, s32 min, u32 flag_unused) {
 213         s32 ret = value;
 214         if (value > max)
 215                 ret = max;
 216         else if (value < min)
 217                 ret = min;
 218         return ret;
 219 }
 220
 221 static inline u32 limE_(psxCP2Regs *regs, u32 result) {
 222         if (result > 0x1ffff)
 223                 return 0x1ffff;
 224         return result;
 225 }
 226
 227 #endif
 228
 229 #define BOUNDS(n_value,n_max,n_maxflag,n_min,n_minflag) \
 230         BOUNDS_(regs,n_value,n_max,n_maxflag,n_min,n_minflag)
 231 #define LIM(value,max,min,flag) \
 232         LIM_(regs,value,max,min,flag)
 233 #define limE(result) \
 234         limE_(regs,result)
 235
 236 #define A1(a) BOUNDS((a), 0x7fffffff, (1 << 30), -(s64)0x80000000, (1 << 31) | (1 << 27))
 237 #define A2(a) BOUNDS((a), 0x7fffffff, (1 << 29), -(s64)0x80000000, (1 << 31) | (1 << 26))
 238 #define A3(a) BOUNDS((a), 0x7fffffff, (1 << 28), -(s64)0x80000000, (1 << 31) | (1 << 25))
 239 #define limB1(a, l) LIM((a), 0x7fff, -0x8000 * !l, (1 << 31) | (1 << 24))
 240 #define limB2(a, l) LIM((a), 0x7fff, -0x8000 * !l, (1 << 31) | (1 << 23))
 241 #define limB3(a, l) LIM((a), 0x7fff, -0x8000 * !l, (1 << 22))
 242 #define limC1(a) LIM((a), 0x00ff, 0x0000, (1 << 21))
 243 #define limC2(a) LIM((a), 0x00ff, 0x0000, (1 << 20))
 244 #define limC3(a) LIM((a), 0x00ff, 0x0000, (1 << 19))
 245 #define limD(a) LIM((a), 0xffff, 0x0000, (1 << 31) | (1 << 18))
 246
 247 #define F(a) BOUNDS((a), 0x7fffffff, (1 << 31) | (1 << 16), -(s64)0x80000000, (1 << 31) | (1 << 15))
 248 #define limG1(a) LIM((a), 0x3ff, -0x400, (1 << 31) | (1 << 14))
 249 #define limG2(a) LIM((a), 0x3ff, -0x400, (1 << 31) | (1 << 13))
 250 #define limH(a) LIM((a), 0x1000, 0x0000, (1 << 12))
 251
 252 #ifndef __arm__
 253 #define A1U A1
 254 #define A2U A2
 255 #define A3U A3
 256 #else
 257 /* these are unlikely to be hit and usually waste cycles, don't want them on ARM */
 258 #define A1U(x) (x)
 259 #define A2U(x) (x)
 260 #define A3U(x) (x)
 261 #endif
 262
 263
 264 //senquack - n param should be unsigned (will be 'gteH' reg which is u16)
 265 #ifdef GTE_USE_NATIVE_DIVIDE
 266 INLINE u32 DIVIDE(u16 n, u16 d) {
 267         if (n < d * 2) {
 268                 return ((u32)n << 16) / d;
 269         }
 270         return 0xffffffff;
 271 }
 272 #else
 273 #include "gte_divider.h"
 274 #endif // GTE_USE_NATIVE_DIVIDE
 275
 276 #ifndef FLAGLESS
 277
 278 const unsigned char gte_cycletab[64] = {
 279         /*   1   2   3   4   5   6   7   8   9   a   b   c   d   e   f */
 280          0, 15,  0,  0,  0,  0,  8,  0,  0,  0,  0,  0,  6,  0,  0,  0,
 281          8,  8,  8, 19, 13,  0, 44,  0,  0,  0,  0, 17, 11,  0, 14,  0,
 282         30,  0,  0,  0,  0,  0,  0,  0,  5,  8, 17,  0,  0,  5,  6,  0,
 283         23,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  5,  5, 39,
 284 };
 285
 286 // warning: called by the dynarec
 287 int gteCheckStallRaw(u32 op_cycles, psxRegisters *regs) {
 288         u32 left = regs->gteBusyCycle - regs->cycle;
 289         int stall = 0;
 290
 291         if (left <= 44) {
 292                 //printf("c %2u stall %2u %u\n", op_cycles, left, regs->cycle);
 293                 regs->cycle = regs->gteBusyCycle;
 294                 stall = left;
 295         }
 296         regs->gteBusyCycle = regs->cycle + op_cycles;
 297         return stall;
 298 }
 299
 300 void gteCheckStall(u32 op) {
 301         gteCheckStallRaw(gte_cycletab[op], &psxRegs);
 302 }
 303
 304 static inline u32 MFC2(int reg) {
 305         psxCP2Regs *regs = &psxRegs.CP2;
 306         switch (reg) {
 307                 case 1:
 308                 case 3:
 309                 case 5:
 310                 case 8:
 311                 case 9:
 312                 case 10:
 313                 case 11:
 314                         psxRegs.CP2D.r[reg] = (s32)psxRegs.CP2D.p[reg].sw.l;
 315                         break;
 316
 317                 case 7:
 318                 case 16:
 319                 case 17:
 320                 case 18:
 321                 case 19:
 322                         psxRegs.CP2D.r[reg] = (u32)psxRegs.CP2D.p[reg].w.l;
 323                         break;
 324
 325                 case 15:
 326                         psxRegs.CP2D.r[reg] = gteSXY2;
 327                         break;
 328
 329                 case 28:
 330                 case 29:
 331                         psxRegs.CP2D.r[reg] = LIM(gteIR1 >> 7, 0x1f, 0, 0) |
 332                                                                         (LIM(gteIR2 >> 7, 0x1f, 0, 0) << 5) |
 333                                                                         (LIM(gteIR3 >> 7, 0x1f, 0, 0) << 10);
 334                         break;
 335         }
 336         return psxRegs.CP2D.r[reg];
 337 }
 338
 339 static inline void MTC2(u32 value, int reg) {
 340         psxCP2Regs *regs = &psxRegs.CP2;
 341         switch (reg) {
 342                 case 15:
 343                         gteSXY0 = gteSXY1;
 344                         gteSXY1 = gteSXY2;
 345                         gteSXY2 = value;
 346                         gteSXYP = value;
 347                         break;
 348
 349                 case 28:
 350                         gteIRGB = value;
 351                         // not gteIR1 etc. just to be consistent with dynarec
 352                         regs->CP2D.n.ir1 = (value & 0x1f) << 7;
 353                         regs->CP2D.n.ir2 = (value & 0x3e0) << 2;
 354                         regs->CP2D.n.ir3 = (value & 0x7c00) >> 3;
 355                         break;
 356
 357                 case 30:
 358                         {
 359                                 int a;
 360                                 gteLZCS = value;
 361
 362                                 a = gteLZCS;
 363                                 if (a > 0) {
 364                                         int i;
 365                                         for (i = 31; (a & (1 << i)) == 0 && i >= 0; i--);
 366                                         gteLZCR = 31 - i;
 367                                 } else if (a < 0) {
 368                                         int i;
 369                                         a ^= 0xffffffff;
 370                                         for (i = 31; (a & (1 << i)) == 0 && i >= 0; i--);
 371                                         gteLZCR = 31 - i;
 372                                 } else {
 373                                         gteLZCR = 32;
 374                                 }
 375                         }
 376                         break;
 377
 378                 case 31:
 379                         return;
 380
 381                 default:
 382                         psxRegs.CP2D.r[reg] = value;
 383         }
 384 }
 385
 386 static inline void CTC2(u32 value, int reg) {
 387         switch (reg) {
 388                 case 4:
 389                 case 12:
 390                 case 20:
 391                 case 26:
 392                 case 27:
 393                 case 29:
 394                 case 30:
 395                         value = (s32)(s16)value;
 396                         break;
 397
 398                 case 31:
 399                         value = value & 0x7ffff000;
 400                         if (value & 0x7f87e000) value |= 0x80000000;
 401                         break;
 402         }
 403
 404         psxRegs.CP2C.r[reg] = value;
 405 }
 406
 407 void gteMFC2() {
 408         if (!_Rt_) return;
 409         psxRegs.GPR.r[_Rt_] = MFC2(_Rd_);
 410 }
 411
 412 void gteCFC2() {
 413         if (!_Rt_) return;
 414         psxRegs.GPR.r[_Rt_] = psxRegs.CP2C.r[_Rd_];
 415 }
 416
 417 void gteMTC2() {
 418         MTC2(psxRegs.GPR.r[_Rt_], _Rd_);
 419 }
 420
 421 void gteCTC2() {
 422         CTC2(psxRegs.GPR.r[_Rt_], _Rd_);
 423 }
 424
 425 #define _oB_ (psxRegs.GPR.r[_Rs_] + _Imm_)
 426
 427 void gteLWC2() {
 428         MTC2(psxMemRead32(_oB_), _Rt_);
 429 }
 430
 431 void gteSWC2() {
 432         psxMemWrite32(_oB_, MFC2(_Rt_));
 433 }
 434
 435 void gteLWC2_stall() {
 436         gteCheckStall(0);
 437         gteLWC2();
 438 }
 439
 440 void gteSWC2_stall() {
 441         gteCheckStall(0);
 442         gteSWC2();
 443 }
 444
 445 #endif // FLAGLESS
 446
 447 #if 0
 448 #define DIVIDE DIVIDE_
 449 static u32 DIVIDE_(s16 n, u16 d) {
 450         if (n >= 0 && n < d * 2) {
 451                 s32 n_ = n;
 452                 return ((n_ << 16) + d / 2) / d;
 453                 //return (u32)((float)(n_ << 16) / (float)d + (float)0.5);
 454         }
 455         return 0xffffffff;
 456 }
 457 #endif
 458
 459 void gteRTPS(psxCP2Regs *regs) {
 460         int quotient;
 461         s64 tmp;
 462
 463 #ifdef GTE_LOG
 464         GTE_LOG("GTE RTPS\n");
 465 #endif
 466         gteFLAG = 0;
 467
 468         gteMAC1 = A1((((s64)gteTRX << 12) + (gteR11 * gteVX0) + (gteR12 * gteVY0) + (gteR13 * gteVZ0)) >> 12);
 469         gteMAC2 = A2((((s64)gteTRY << 12) + (gteR21 * gteVX0) + (gteR22 * gteVY0) + (gteR23 * gteVZ0)) >> 12);
 470         gteMAC3 = A3((((s64)gteTRZ << 12) + (gteR31 * gteVX0) + (gteR32 * gteVY0) + (gteR33 * gteVZ0)) >> 12);
 471         gteIR1 = limB1(gteMAC1, 0);
 472         gteIR2 = limB2(gteMAC2, 0);
 473         gteIR3 = limB3(gteMAC3, 0);
 474         gteSZ0 = gteSZ1;
 475         gteSZ1 = gteSZ2;
 476         gteSZ2 = gteSZ3;
 477         gteSZ3 = limD(gteMAC3);
 478         quotient = limE(DIVIDE(gteH, gteSZ3));
 479         gteSXY0 = gteSXY1;
 480         gteSXY1 = gteSXY2;
 481         gteSX2 = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
 482         gteSY2 = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
 483
 484         tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
 485         gteMAC0 = F(tmp);
 486         gteIR0 = limH(tmp >> 12);
 487 }
 488
 489 void gteRTPT(psxCP2Regs *regs) {
 490         int quotient;
 491         int v;
 492         s32 vx, vy, vz;
 493         s64 tmp;
 494
 495 #ifdef GTE_LOG
 496         GTE_LOG("GTE RTPT\n");
 497 #endif
 498         gteFLAG = 0;
 499
 500         gteSZ0 = gteSZ3;
 501         for (v = 0; v < 3; v++) {
 502                 vx = VX(v);
 503                 vy = VY(v);
 504                 vz = VZ(v);
 505                 gteMAC1 = A1((((s64)gteTRX << 12) + (gteR11 * vx) + (gteR12 * vy) + (gteR13 * vz)) >> 12);
 506                 gteMAC2 = A2((((s64)gteTRY << 12) + (gteR21 * vx) + (gteR22 * vy) + (gteR23 * vz)) >> 12);
 507                 gteMAC3 = A3((((s64)gteTRZ << 12) + (gteR31 * vx) + (gteR32 * vy) + (gteR33 * vz)) >> 12);
 508                 gteIR1 = limB1(gteMAC1, 0);
 509                 gteIR2 = limB2(gteMAC2, 0);
 510                 gteIR3 = limB3(gteMAC3, 0);
 511                 fSZ(v) = limD(gteMAC3);
 512                 quotient = limE(DIVIDE(gteH, fSZ(v)));
 513                 fSX(v) = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
 514                 fSY(v) = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
 515         }
 516
 517         tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
 518         gteMAC0 = F(tmp);
 519         gteIR0 = limH(tmp >> 12);
 520 }
 521
 522 void gteMVMVA(psxCP2Regs *regs) {
 523         int shift = 12 * GTE_SF(gteop);
 524         int mx = GTE_MX(gteop);
 525         int v = GTE_V(gteop);
 526         int cv = GTE_CV(gteop);
 527         int lm = GTE_LM(gteop);
 528         s32 vx = VX(v);
 529         s32 vy = VY(v);
 530         s32 vz = VZ(v);
 531
 532 #ifdef GTE_LOG
 533         GTE_LOG("GTE MVMVA\n");
 534 #endif
 535         gteFLAG = 0;
 536
 537         gteMAC1 = A1((((s64)CV1(cv) << 12) + (MX11(mx) * vx) + (MX12(mx) * vy) + (MX13(mx) * vz)) >> shift);
 538         gteMAC2 = A2((((s64)CV2(cv) << 12) + (MX21(mx) * vx) + (MX22(mx) * vy) + (MX23(mx) * vz)) >> shift);
 539         gteMAC3 = A3((((s64)CV3(cv) << 12) + (MX31(mx) * vx) + (MX32(mx) * vy) + (MX33(mx) * vz)) >> shift);
 540
 541         gteIR1 = limB1(gteMAC1, lm);
 542         gteIR2 = limB2(gteMAC2, lm);
 543         gteIR3 = limB3(gteMAC3, lm);
 544 }
 545
 546 void gteNCLIP(psxCP2Regs *regs) {
 547 #ifdef GTE_LOG
 548         GTE_LOG("GTE NCLIP\n");
 549 #endif
 550         gteFLAG = 0;
 551
 552         gteMAC0 = F((s64)gteSX0 * (gteSY1 - gteSY2) +
 553                                 gteSX1 * (gteSY2 - gteSY0) +
 554                                 gteSX2 * (gteSY0 - gteSY1));
 555 }
 556
 557 void gteAVSZ3(psxCP2Regs *regs) {
 558 #ifdef GTE_LOG
 559         GTE_LOG("GTE AVSZ3\n");
 560 #endif
 561         gteFLAG = 0;
 562
 563         gteMAC0 = F((s64)gteZSF3 * (gteSZ1 + gteSZ2 + gteSZ3));
 564         gteOTZ = limD(gteMAC0 >> 12);
 565 }
 566
 567 void gteAVSZ4(psxCP2Regs *regs) {
 568 #ifdef GTE_LOG
 569         GTE_LOG("GTE AVSZ4\n");
 570 #endif
 571         gteFLAG = 0;
 572
 573         gteMAC0 = F((s64)gteZSF4 * (gteSZ0 + gteSZ1 + gteSZ2 + gteSZ3));
 574         gteOTZ = limD(gteMAC0 >> 12);
 575 }
 576
 577 void gteSQR(psxCP2Regs *regs) {
 578         int shift = 12 * GTE_SF(gteop);
 579         int lm = GTE_LM(gteop);
 580
 581 #ifdef GTE_LOG
 582         GTE_LOG("GTE SQR\n");
 583 #endif
 584         gteFLAG = 0;
 585
 586         gteMAC1 = (gteIR1 * gteIR1) >> shift;
 587         gteMAC2 = (gteIR2 * gteIR2) >> shift;
 588         gteMAC3 = (gteIR3 * gteIR3) >> shift;
 589         gteIR1 = limB1(gteMAC1, lm);
 590         gteIR2 = limB2(gteMAC2, lm);
 591         gteIR3 = limB3(gteMAC3, lm);
 592 }
 593
 594 void gteNCCS(psxCP2Regs *regs) {
 595 #ifdef GTE_LOG
 596         GTE_LOG("GTE NCCS\n");
 597 #endif
 598         gteFLAG = 0;
 599
 600         gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
 601         gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
 602         gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
 603         gteIR1 = limB1(gteMAC1, 1);
 604         gteIR2 = limB2(gteMAC2, 1);
 605         gteIR3 = limB3(gteMAC3, 1);
 606         gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 607         gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 608         gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 609         gteIR1 = limB1(gteMAC1, 1);
 610         gteIR2 = limB2(gteMAC2, 1);
 611         gteIR3 = limB3(gteMAC3, 1);
 612         gteMAC1 = ((s32)gteR * gteIR1) >> 8;
 613         gteMAC2 = ((s32)gteG * gteIR2) >> 8;
 614         gteMAC3 = ((s32)gteB * gteIR3) >> 8;
 615         gteIR1 = gteMAC1;
 616         gteIR2 = gteMAC2;
 617         gteIR3 = gteMAC3;
 618
 619         gteRGB0 = gteRGB1;
 620         gteRGB1 = gteRGB2;
 621         gteCODE2 = gteCODE;
 622         gteR2 = limC1(gteMAC1 >> 4);
 623         gteG2 = limC2(gteMAC2 >> 4);
 624         gteB2 = limC3(gteMAC3 >> 4);
 625 }
 626
 627 void gteNCCT(psxCP2Regs *regs) {
 628         int v;
 629         s32 vx, vy, vz;
 630
 631 #ifdef GTE_LOG
 632         GTE_LOG("GTE NCCT\n");
 633 #endif
 634         gteFLAG = 0;
 635
 636         for (v = 0; v < 3; v++) {
 637                 vx = VX(v);
 638                 vy = VY(v);
 639                 vz = VZ(v);
 640                 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
 641                 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
 642                 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 12;
 643                 gteIR1 = limB1(gteMAC1, 1);
 644                 gteIR2 = limB2(gteMAC2, 1);
 645                 gteIR3 = limB3(gteMAC3, 1);
 646                 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 647                 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 648                 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 649                 gteIR1 = limB1(gteMAC1, 1);
 650                 gteIR2 = limB2(gteMAC2, 1);
 651                 gteIR3 = limB3(gteMAC3, 1);
 652                 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
 653                 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
 654                 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
 655
 656                 gteRGB0 = gteRGB1;
 657                 gteRGB1 = gteRGB2;
 658                 gteCODE2 = gteCODE;
 659                 gteR2 = limC1(gteMAC1 >> 4);
 660                 gteG2 = limC2(gteMAC2 >> 4);
 661                 gteB2 = limC3(gteMAC3 >> 4);
 662         }
 663         gteIR1 = gteMAC1;
 664         gteIR2 = gteMAC2;
 665         gteIR3 = gteMAC3;
 666 }
 667
 668 void gteNCDS(psxCP2Regs *regs) {
 669 #ifdef GTE_LOG
 670         GTE_LOG("GTE NCDS\n");
 671 #endif
 672         gteFLAG = 0;
 673
 674         gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
 675         gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
 676         gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
 677         gteIR1 = limB1(gteMAC1, 1);
 678         gteIR2 = limB2(gteMAC2, 1);
 679         gteIR3 = limB3(gteMAC3, 1);
 680         gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 681         gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 682         gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 683         gteIR1 = limB1(gteMAC1, 1);
 684         gteIR2 = limB2(gteMAC2, 1);
 685         gteIR3 = limB3(gteMAC3, 1);
 686         gteMAC1 = (((gteR << 4) * gteIR1) + (gteIR0 * limB1(A1U((s64)gteRFC - ((gteR * gteIR1) >> 8)), 0))) >> 12;
 687         gteMAC2 = (((gteG << 4) * gteIR2) + (gteIR0 * limB2(A2U((s64)gteGFC - ((gteG * gteIR2) >> 8)), 0))) >> 12;
 688         gteMAC3 = (((gteB << 4) * gteIR3) + (gteIR0 * limB3(A3U((s64)gteBFC - ((gteB * gteIR3) >> 8)), 0))) >> 12;
 689         gteIR1 = limB1(gteMAC1, 1);
 690         gteIR2 = limB2(gteMAC2, 1);
 691         gteIR3 = limB3(gteMAC3, 1);
 692
 693         gteRGB0 = gteRGB1;
 694         gteRGB1 = gteRGB2;
 695         gteCODE2 = gteCODE;
 696         gteR2 = limC1(gteMAC1 >> 4);
 697         gteG2 = limC2(gteMAC2 >> 4);
 698         gteB2 = limC3(gteMAC3 >> 4);
 699 }
 700
 701 void gteNCDT(psxCP2Regs *regs) {
 702         int v;
 703         s32 vx, vy, vz;
 704
 705 #ifdef GTE_LOG
 706         GTE_LOG("GTE NCDT\n");
 707 #endif
 708         gteFLAG = 0;
 709
 710         for (v = 0; v < 3; v++) {
 711                 vx = VX(v);
 712                 vy = VY(v);
 713                 vz = VZ(v);
 714                 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
 715                 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
 716                 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 12;
 717                 gteIR1 = limB1(gteMAC1, 1);
 718                 gteIR2 = limB2(gteMAC2, 1);
 719                 gteIR3 = limB3(gteMAC3, 1);
 720                 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 721                 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 722                 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 723                 gteIR1 = limB1(gteMAC1, 1);
 724                 gteIR2 = limB2(gteMAC2, 1);
 725                 gteIR3 = limB3(gteMAC3, 1);
 726                 gteMAC1 = (((gteR << 4) * gteIR1) + (gteIR0 * limB1(A1U((s64)gteRFC - ((gteR * gteIR1) >> 8)), 0))) >> 12;
 727                 gteMAC2 = (((gteG << 4) * gteIR2) + (gteIR0 * limB2(A2U((s64)gteGFC - ((gteG * gteIR2) >> 8)), 0))) >> 12;
 728                 gteMAC3 = (((gteB << 4) * gteIR3) + (gteIR0 * limB3(A3U((s64)gteBFC - ((gteB * gteIR3) >> 8)), 0))) >> 12;
 729
 730                 gteRGB0 = gteRGB1;
 731                 gteRGB1 = gteRGB2;
 732                 gteCODE2 = gteCODE;
 733                 gteR2 = limC1(gteMAC1 >> 4);
 734                 gteG2 = limC2(gteMAC2 >> 4);
 735                 gteB2 = limC3(gteMAC3 >> 4);
 736         }
 737         gteIR1 = limB1(gteMAC1, 1);
 738         gteIR2 = limB2(gteMAC2, 1);
 739         gteIR3 = limB3(gteMAC3, 1);
 740 }
 741
 742 void gteOP(psxCP2Regs *regs) {
 743         int shift = 12 * GTE_SF(gteop);
 744         int lm = GTE_LM(gteop);
 745
 746 #ifdef GTE_LOG
 747         GTE_LOG("GTE OP\n");
 748 #endif
 749         gteFLAG = 0;
 750
 751         gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> shift;
 752         gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> shift;
 753         gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> shift;
 754         gteIR1 = limB1(gteMAC1, lm);
 755         gteIR2 = limB2(gteMAC2, lm);
 756         gteIR3 = limB3(gteMAC3, lm);
 757 }
 758
 759 void gteDCPL(psxCP2Regs *regs) {
 760         int lm = GTE_LM(gteop);
 761
 762         s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
 763         s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
 764         s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
 765
 766 #ifdef GTE_LOG
 767         GTE_LOG("GTE DCPL\n");
 768 #endif
 769         gteFLAG = 0;
 770
 771         gteMAC1 = RIR1 + ((gteIR0 * limB1(A1U((s64)gteRFC - RIR1), 0)) >> 12);
 772         gteMAC2 = GIR2 + ((gteIR0 * limB1(A2U((s64)gteGFC - GIR2), 0)) >> 12);
 773         gteMAC3 = BIR3 + ((gteIR0 * limB1(A3U((s64)gteBFC - BIR3), 0)) >> 12);
 774
 775         gteIR1 = limB1(gteMAC1, lm);
 776         gteIR2 = limB2(gteMAC2, lm);
 777         gteIR3 = limB3(gteMAC3, lm);
 778
 779         gteRGB0 = gteRGB1;
 780         gteRGB1 = gteRGB2;
 781         gteCODE2 = gteCODE;
 782         gteR2 = limC1(gteMAC1 >> 4);
 783         gteG2 = limC2(gteMAC2 >> 4);
 784         gteB2 = limC3(gteMAC3 >> 4);
 785 }
 786
 787 void gteGPF(psxCP2Regs *regs) {
 788         int shift = 12 * GTE_SF(gteop);
 789
 790 #ifdef GTE_LOG
 791         GTE_LOG("GTE GPF\n");
 792 #endif
 793         gteFLAG = 0;
 794
 795         gteMAC1 = (gteIR0 * gteIR1) >> shift;
 796         gteMAC2 = (gteIR0 * gteIR2) >> shift;
 797         gteMAC3 = (gteIR0 * gteIR3) >> shift;
 798         gteIR1 = limB1(gteMAC1, 0);
 799         gteIR2 = limB2(gteMAC2, 0);
 800         gteIR3 = limB3(gteMAC3, 0);
 801
 802         gteRGB0 = gteRGB1;
 803         gteRGB1 = gteRGB2;
 804         gteCODE2 = gteCODE;
 805         gteR2 = limC1(gteMAC1 >> 4);
 806         gteG2 = limC2(gteMAC2 >> 4);
 807         gteB2 = limC3(gteMAC3 >> 4);
 808 }
 809
 810 void gteGPL(psxCP2Regs *regs) {
 811         int shift = 12 * GTE_SF(gteop);
 812
 813 #ifdef GTE_LOG
 814         GTE_LOG("GTE GPL\n");
 815 #endif
 816         gteFLAG = 0;
 817
 818         gteMAC1 = A1((((s64)gteMAC1 << shift) + (gteIR0 * gteIR1)) >> shift);
 819         gteMAC2 = A2((((s64)gteMAC2 << shift) + (gteIR0 * gteIR2)) >> shift);
 820         gteMAC3 = A3((((s64)gteMAC3 << shift) + (gteIR0 * gteIR3)) >> shift);
 821         gteIR1 = limB1(gteMAC1, 0);
 822         gteIR2 = limB2(gteMAC2, 0);
 823         gteIR3 = limB3(gteMAC3, 0);
 824
 825         gteRGB0 = gteRGB1;
 826         gteRGB1 = gteRGB2;
 827         gteCODE2 = gteCODE;
 828         gteR2 = limC1(gteMAC1 >> 4);
 829         gteG2 = limC2(gteMAC2 >> 4);
 830         gteB2 = limC3(gteMAC3 >> 4);
 831 }
 832
 833 void gteDPCS(psxCP2Regs *regs) {
 834         int shift = 12 * GTE_SF(gteop);
 835
 836 #ifdef GTE_LOG
 837         GTE_LOG("GTE DPCS\n");
 838 #endif
 839         gteFLAG = 0;
 840
 841         gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U(((s64)gteRFC - (gteR << 4)) << (12 - shift)), 0))) >> 12;
 842         gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U(((s64)gteGFC - (gteG << 4)) << (12 - shift)), 0))) >> 12;
 843         gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U(((s64)gteBFC - (gteB << 4)) << (12 - shift)), 0))) >> 12;
 844
 845         gteIR1 = limB1(gteMAC1, 0);
 846         gteIR2 = limB2(gteMAC2, 0);
 847         gteIR3 = limB3(gteMAC3, 0);
 848         gteRGB0 = gteRGB1;
 849         gteRGB1 = gteRGB2;
 850         gteCODE2 = gteCODE;
 851         gteR2 = limC1(gteMAC1 >> 4);
 852         gteG2 = limC2(gteMAC2 >> 4);
 853         gteB2 = limC3(gteMAC3 >> 4);
 854 }
 855
 856 void gteDPCT(psxCP2Regs *regs) {
 857         int v;
 858
 859 #ifdef GTE_LOG
 860         GTE_LOG("GTE DPCT\n");
 861 #endif
 862         gteFLAG = 0;
 863
 864         for (v = 0; v < 3; v++) {
 865                 gteMAC1 = ((gteR0 << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR0 << 4)), 0))) >> 12;
 866                 gteMAC2 = ((gteG0 << 16) + (gteIR0 * limB1(A2U((s64)gteGFC - (gteG0 << 4)), 0))) >> 12;
 867                 gteMAC3 = ((gteB0 << 16) + (gteIR0 * limB1(A3U((s64)gteBFC - (gteB0 << 4)), 0))) >> 12;
 868
 869                 gteRGB0 = gteRGB1;
 870                 gteRGB1 = gteRGB2;
 871                 gteCODE2 = gteCODE;
 872                 gteR2 = limC1(gteMAC1 >> 4);
 873                 gteG2 = limC2(gteMAC2 >> 4);
 874                 gteB2 = limC3(gteMAC3 >> 4);
 875         }
 876         gteIR1 = limB1(gteMAC1, 0);
 877         gteIR2 = limB2(gteMAC2, 0);
 878         gteIR3 = limB3(gteMAC3, 0);
 879 }
 880
 881 void gteNCS(psxCP2Regs *regs) {
 882 #ifdef GTE_LOG
 883         GTE_LOG("GTE NCS\n");
 884 #endif
 885         gteFLAG = 0;
 886
 887         gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
 888         gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
 889         gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
 890         gteIR1 = limB1(gteMAC1, 1);
 891         gteIR2 = limB2(gteMAC2, 1);
 892         gteIR3 = limB3(gteMAC3, 1);
 893         gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 894         gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 895         gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 896         gteIR1 = limB1(gteMAC1, 1);
 897         gteIR2 = limB2(gteMAC2, 1);
 898         gteIR3 = limB3(gteMAC3, 1);
 899
 900         gteRGB0 = gteRGB1;
 901         gteRGB1 = gteRGB2;
 902         gteCODE2 = gteCODE;
 903         gteR2 = limC1(gteMAC1 >> 4);
 904         gteG2 = limC2(gteMAC2 >> 4);
 905         gteB2 = limC3(gteMAC3 >> 4);
 906 }
 907
 908 void gteNCT(psxCP2Regs *regs) {
 909         int v;
 910         s32 vx, vy, vz;
 911
 912 #ifdef GTE_LOG
 913         GTE_LOG("GTE NCT\n");
 914 #endif
 915         gteFLAG = 0;
 916
 917         for (v = 0; v < 3; v++) {
 918                 vx = VX(v);
 919                 vy = VY(v);
 920                 vz = VZ(v);
 921                 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
 922                 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
 923                 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 12;
 924                 gteIR1 = limB1(gteMAC1, 1);
 925                 gteIR2 = limB2(gteMAC2, 1);
 926                 gteIR3 = limB3(gteMAC3, 1);
 927                 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 928                 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 929                 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 930                 gteRGB0 = gteRGB1;
 931                 gteRGB1 = gteRGB2;
 932                 gteCODE2 = gteCODE;
 933                 gteR2 = limC1(gteMAC1 >> 4);
 934                 gteG2 = limC2(gteMAC2 >> 4);
 935                 gteB2 = limC3(gteMAC3 >> 4);
 936         }
 937         gteIR1 = limB1(gteMAC1, 1);
 938         gteIR2 = limB2(gteMAC2, 1);
 939         gteIR3 = limB3(gteMAC3, 1);
 940 }
 941
 942 void gteCC(psxCP2Regs *regs) {
 943 #ifdef GTE_LOG
 944         GTE_LOG("GTE CC\n");
 945 #endif
 946         gteFLAG = 0;
 947
 948         gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 949         gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 950         gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 951         gteIR1 = limB1(gteMAC1, 1);
 952         gteIR2 = limB2(gteMAC2, 1);
 953         gteIR3 = limB3(gteMAC3, 1);
 954         gteMAC1 = ((s32)gteR * gteIR1) >> 8;
 955         gteMAC2 = ((s32)gteG * gteIR2) >> 8;
 956         gteMAC3 = ((s32)gteB * gteIR3) >> 8;
 957         gteIR1 = limB1(gteMAC1, 1);
 958         gteIR2 = limB2(gteMAC2, 1);
 959         gteIR3 = limB3(gteMAC3, 1);
 960
 961         gteRGB0 = gteRGB1;
 962         gteRGB1 = gteRGB2;
 963         gteCODE2 = gteCODE;
 964         gteR2 = limC1(gteMAC1 >> 4);
 965         gteG2 = limC2(gteMAC2 >> 4);
 966         gteB2 = limC3(gteMAC3 >> 4);
 967 }
 968
 969 void gteINTPL(psxCP2Regs *regs) {
 970         int shift = 12 * GTE_SF(gteop);
 971         int lm = GTE_LM(gteop);
 972
 973 #ifdef GTE_LOG
 974         GTE_LOG("GTE INTPL\n");
 975 #endif
 976         gteFLAG = 0;
 977
 978         gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0))) >> shift;
 979         gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0))) >> shift;
 980         gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0))) >> shift;
 981         gteIR1 = limB1(gteMAC1, lm);
 982         gteIR2 = limB2(gteMAC2, lm);
 983         gteIR3 = limB3(gteMAC3, lm);
 984         gteRGB0 = gteRGB1;
 985         gteRGB1 = gteRGB2;
 986         gteCODE2 = gteCODE;
 987         gteR2 = limC1(gteMAC1 >> 4);
 988         gteG2 = limC2(gteMAC2 >> 4);
 989         gteB2 = limC3(gteMAC3 >> 4);
 990 }
 991
 992 void gteCDP(psxCP2Regs *regs) {
 993 #ifdef GTE_LOG
 994         GTE_LOG("GTE CDP\n");
 995 #endif
 996         gteFLAG = 0;
 997
 998         gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 999         gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
1000         gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
1001         gteIR1 = limB1(gteMAC1, 1);
1002         gteIR2 = limB2(gteMAC2, 1);
1003         gteIR3 = limB3(gteMAC3, 1);
1004         gteMAC1 = (((gteR << 4) * gteIR1) + (gteIR0 * limB1(A1U((s64)gteRFC - ((gteR * gteIR1) >> 8)), 0))) >> 12;
1005         gteMAC2 = (((gteG << 4) * gteIR2) + (gteIR0 * limB2(A2U((s64)gteGFC - ((gteG * gteIR2) >> 8)), 0))) >> 12;
1006         gteMAC3 = (((gteB << 4) * gteIR3) + (gteIR0 * limB3(A3U((s64)gteBFC - ((gteB * gteIR3) >> 8)), 0))) >> 12;
1007         gteIR1 = limB1(gteMAC1, 1);
1008         gteIR2 = limB2(gteMAC2, 1);
1009         gteIR3 = limB3(gteMAC3, 1);
1010
1011         gteRGB0 = gteRGB1;
1012         gteRGB1 = gteRGB2;
1013         gteCODE2 = gteCODE;
1014         gteR2 = limC1(gteMAC1 >> 4);
1015         gteG2 = limC2(gteMAC2 >> 4);
1016         gteB2 = limC3(gteMAC3 >> 4);
1017 }
1018
1019 /* decomposed/parametrized versions for the recompiler */
1020
1021 #ifndef FLAGLESS
1022
1023 void gteSQR_part_noshift(psxCP2Regs *regs) {
1024         gteFLAG = 0;
1025
1026         gteMAC1 = gteIR1 * gteIR1;
1027         gteMAC2 = gteIR2 * gteIR2;
1028         gteMAC3 = gteIR3 * gteIR3;
1029 }
1030
1031 void gteSQR_part_shift(psxCP2Regs *regs) {
1032         gteFLAG = 0;
1033
1034         gteMAC1 = (gteIR1 * gteIR1) >> 12;
1035         gteMAC2 = (gteIR2 * gteIR2) >> 12;
1036         gteMAC3 = (gteIR3 * gteIR3) >> 12;
1037 }
1038
1039 void gteOP_part_noshift(psxCP2Regs *regs) {
1040         gteFLAG = 0;
1041
1042         gteMAC1 = (gteR22 * gteIR3) - (gteR33 * gteIR2);
1043         gteMAC2 = (gteR33 * gteIR1) - (gteR11 * gteIR3);
1044         gteMAC3 = (gteR11 * gteIR2) - (gteR22 * gteIR1);
1045 }
1046
1047 void gteOP_part_shift(psxCP2Regs *regs) {
1048         gteFLAG = 0;
1049
1050         gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> 12;
1051         gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> 12;
1052         gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> 12;
1053 }
1054
1055 void gteDCPL_part(psxCP2Regs *regs) {
1056         s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
1057         s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
1058         s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
1059
1060         gteFLAG = 0;
1061
1062         gteMAC1 = RIR1 + ((gteIR0 * limB1(A1U((s64)gteRFC - RIR1), 0)) >> 12);
1063         gteMAC2 = GIR2 + ((gteIR0 * limB1(A2U((s64)gteGFC - GIR2), 0)) >> 12);
1064         gteMAC3 = BIR3 + ((gteIR0 * limB1(A3U((s64)gteBFC - BIR3), 0)) >> 12);
1065 }
1066
1067 void gteGPF_part_noshift(psxCP2Regs *regs) {
1068         gteFLAG = 0;
1069
1070         gteMAC1 = gteIR0 * gteIR1;
1071         gteMAC2 = gteIR0 * gteIR2;
1072         gteMAC3 = gteIR0 * gteIR3;
1073 }
1074
1075 void gteGPF_part_shift(psxCP2Regs *regs) {
1076         gteFLAG = 0;
1077
1078         gteMAC1 = (gteIR0 * gteIR1) >> 12;
1079         gteMAC2 = (gteIR0 * gteIR2) >> 12;
1080         gteMAC3 = (gteIR0 * gteIR3) >> 12;
1081 }
1082
1083 #endif // !FLAGLESS
1084
1085 void gteGPL_part_noshift(psxCP2Regs *regs) {
1086         gteFLAG = 0;
1087
1088         gteMAC1 = A1((s64)gteMAC1 + (gteIR0 * gteIR1));
1089         gteMAC2 = A2((s64)gteMAC2 + (gteIR0 * gteIR2));
1090         gteMAC3 = A3((s64)gteMAC3 + (gteIR0 * gteIR3));
1091 }
1092
1093 void gteGPL_part_shift(psxCP2Regs *regs) {
1094         gteFLAG = 0;
1095
1096         gteMAC1 = A1((s64)gteMAC1 + ((gteIR0 * gteIR1) >> 12));
1097         gteMAC2 = A2((s64)gteMAC2 + ((gteIR0 * gteIR2) >> 12));
1098         gteMAC3 = A3((s64)gteMAC3 + ((gteIR0 * gteIR3) >> 12));
1099 }
1100
1101 void gteDPCS_part_noshift(psxCP2Regs *regs) {
1102         int shift = 0;
1103
1104         gteFLAG = 0;
1105
1106         gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR << 4)) << (12 - shift), 0))) >> 12;
1107         gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U((s64)gteGFC - (gteG << 4)) << (12 - shift), 0))) >> 12;
1108         gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U((s64)gteBFC - (gteB << 4)) << (12 - shift), 0))) >> 12;
1109 }
1110
1111 void gteDPCS_part_shift(psxCP2Regs *regs) {
1112         int shift = 12;
1113
1114         gteFLAG = 0;
1115
1116         gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR << 4)) << (12 - shift), 0))) >> 12;
1117         gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U((s64)gteGFC - (gteG << 4)) << (12 - shift), 0))) >> 12;
1118         gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U((s64)gteBFC - (gteB << 4)) << (12 - shift), 0))) >> 12;
1119 }
1120
1121 void gteINTPL_part_noshift(psxCP2Regs *regs) {
1122         gteFLAG = 0;
1123
1124         gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0)));
1125         gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0)));
1126         gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0)));
1127 }
1128
1129 void gteINTPL_part_shift(psxCP2Regs *regs) {
1130         gteFLAG = 0;
1131
1132         gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0))) >> 12;
1133         gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0))) >> 12;
1134         gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0))) >> 12;
1135 }
1136
1137 void gteMACtoRGB(psxCP2Regs *regs) {
1138         gteRGB0 = gteRGB1;
1139         gteRGB1 = gteRGB2;
1140         gteCODE2 = gteCODE;
1141         gteR2 = limC1(gteMAC1 >> 4);
1142         gteG2 = limC2(gteMAC2 >> 4);
1143         gteB2 = limC3(gteMAC3 >> 4);
1144 }
1145