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 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         gteCheckStall(0);
 433         psxMemWrite32(_oB_, MFC2(_Rt_));
 434 }
 435
 436 #endif // FLAGLESS
 437
 438 #if 0
 439 #define DIVIDE DIVIDE_
 440 static u32 DIVIDE_(s16 n, u16 d) {
 441         if (n >= 0 && n < d * 2) {
 442                 s32 n_ = n;
 443                 return ((n_ << 16) + d / 2) / d;
 444                 //return (u32)((float)(n_ << 16) / (float)d + (float)0.5);
 445         }
 446         return 0xffffffff;
 447 }
 448 #endif
 449
 450 void gteRTPS(psxCP2Regs *regs) {
 451         int quotient;
 452         s64 tmp;
 453
 454 #ifdef GTE_LOG
 455         GTE_LOG("GTE RTPS\n");
 456 #endif
 457         gteFLAG = 0;
 458
 459         gteMAC1 = A1((((s64)gteTRX << 12) + (gteR11 * gteVX0) + (gteR12 * gteVY0) + (gteR13 * gteVZ0)) >> 12);
 460         gteMAC2 = A2((((s64)gteTRY << 12) + (gteR21 * gteVX0) + (gteR22 * gteVY0) + (gteR23 * gteVZ0)) >> 12);
 461         gteMAC3 = A3((((s64)gteTRZ << 12) + (gteR31 * gteVX0) + (gteR32 * gteVY0) + (gteR33 * gteVZ0)) >> 12);
 462         gteIR1 = limB1(gteMAC1, 0);
 463         gteIR2 = limB2(gteMAC2, 0);
 464         gteIR3 = limB3(gteMAC3, 0);
 465         gteSZ0 = gteSZ1;
 466         gteSZ1 = gteSZ2;
 467         gteSZ2 = gteSZ3;
 468         gteSZ3 = limD(gteMAC3);
 469         quotient = limE(DIVIDE(gteH, gteSZ3));
 470         gteSXY0 = gteSXY1;
 471         gteSXY1 = gteSXY2;
 472         gteSX2 = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
 473         gteSY2 = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
 474
 475         tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
 476         gteMAC0 = F(tmp);
 477         gteIR0 = limH(tmp >> 12);
 478 }
 479
 480 void gteRTPT(psxCP2Regs *regs) {
 481         int quotient;
 482         int v;
 483         s32 vx, vy, vz;
 484         s64 tmp;
 485
 486 #ifdef GTE_LOG
 487         GTE_LOG("GTE RTPT\n");
 488 #endif
 489         gteFLAG = 0;
 490
 491         gteSZ0 = gteSZ3;
 492         for (v = 0; v < 3; v++) {
 493                 vx = VX(v);
 494                 vy = VY(v);
 495                 vz = VZ(v);
 496                 gteMAC1 = A1((((s64)gteTRX << 12) + (gteR11 * vx) + (gteR12 * vy) + (gteR13 * vz)) >> 12);
 497                 gteMAC2 = A2((((s64)gteTRY << 12) + (gteR21 * vx) + (gteR22 * vy) + (gteR23 * vz)) >> 12);
 498                 gteMAC3 = A3((((s64)gteTRZ << 12) + (gteR31 * vx) + (gteR32 * vy) + (gteR33 * vz)) >> 12);
 499                 gteIR1 = limB1(gteMAC1, 0);
 500                 gteIR2 = limB2(gteMAC2, 0);
 501                 gteIR3 = limB3(gteMAC3, 0);
 502                 fSZ(v) = limD(gteMAC3);
 503                 quotient = limE(DIVIDE(gteH, fSZ(v)));
 504                 fSX(v) = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
 505                 fSY(v) = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
 506         }
 507
 508         tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
 509         gteMAC0 = F(tmp);
 510         gteIR0 = limH(tmp >> 12);
 511 }
 512
 513 void gteMVMVA(psxCP2Regs *regs) {
 514         int shift = 12 * GTE_SF(gteop);
 515         int mx = GTE_MX(gteop);
 516         int v = GTE_V(gteop);
 517         int cv = GTE_CV(gteop);
 518         int lm = GTE_LM(gteop);
 519         s32 vx = VX(v);
 520         s32 vy = VY(v);
 521         s32 vz = VZ(v);
 522
 523 #ifdef GTE_LOG
 524         GTE_LOG("GTE MVMVA\n");
 525 #endif
 526         gteFLAG = 0;
 527
 528         gteMAC1 = A1((((s64)CV1(cv) << 12) + (MX11(mx) * vx) + (MX12(mx) * vy) + (MX13(mx) * vz)) >> shift);
 529         gteMAC2 = A2((((s64)CV2(cv) << 12) + (MX21(mx) * vx) + (MX22(mx) * vy) + (MX23(mx) * vz)) >> shift);
 530         gteMAC3 = A3((((s64)CV3(cv) << 12) + (MX31(mx) * vx) + (MX32(mx) * vy) + (MX33(mx) * vz)) >> shift);
 531
 532         gteIR1 = limB1(gteMAC1, lm);
 533         gteIR2 = limB2(gteMAC2, lm);
 534         gteIR3 = limB3(gteMAC3, lm);
 535 }
 536
 537 void gteNCLIP(psxCP2Regs *regs) {
 538 #ifdef GTE_LOG
 539         GTE_LOG("GTE NCLIP\n");
 540 #endif
 541         gteFLAG = 0;
 542
 543         gteMAC0 = F((s64)gteSX0 * (gteSY1 - gteSY2) +
 544                                 gteSX1 * (gteSY2 - gteSY0) +
 545                                 gteSX2 * (gteSY0 - gteSY1));
 546 }
 547
 548 void gteAVSZ3(psxCP2Regs *regs) {
 549 #ifdef GTE_LOG
 550         GTE_LOG("GTE AVSZ3\n");
 551 #endif
 552         gteFLAG = 0;
 553
 554         gteMAC0 = F((s64)gteZSF3 * (gteSZ1 + gteSZ2 + gteSZ3));
 555         gteOTZ = limD(gteMAC0 >> 12);
 556 }
 557
 558 void gteAVSZ4(psxCP2Regs *regs) {
 559 #ifdef GTE_LOG
 560         GTE_LOG("GTE AVSZ4\n");
 561 #endif
 562         gteFLAG = 0;
 563
 564         gteMAC0 = F((s64)gteZSF4 * (gteSZ0 + gteSZ1 + gteSZ2 + gteSZ3));
 565         gteOTZ = limD(gteMAC0 >> 12);
 566 }
 567
 568 void gteSQR(psxCP2Regs *regs) {
 569         int shift = 12 * GTE_SF(gteop);
 570         int lm = GTE_LM(gteop);
 571
 572 #ifdef GTE_LOG
 573         GTE_LOG("GTE SQR\n");
 574 #endif
 575         gteFLAG = 0;
 576
 577         gteMAC1 = (gteIR1 * gteIR1) >> shift;
 578         gteMAC2 = (gteIR2 * gteIR2) >> shift;
 579         gteMAC3 = (gteIR3 * gteIR3) >> shift;
 580         gteIR1 = limB1(gteMAC1, lm);
 581         gteIR2 = limB2(gteMAC2, lm);
 582         gteIR3 = limB3(gteMAC3, lm);
 583 }
 584
 585 void gteNCCS(psxCP2Regs *regs) {
 586 #ifdef GTE_LOG
 587         GTE_LOG("GTE NCCS\n");
 588 #endif
 589         gteFLAG = 0;
 590
 591         gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
 592         gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
 593         gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
 594         gteIR1 = limB1(gteMAC1, 1);
 595         gteIR2 = limB2(gteMAC2, 1);
 596         gteIR3 = limB3(gteMAC3, 1);
 597         gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 598         gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 599         gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 600         gteIR1 = limB1(gteMAC1, 1);
 601         gteIR2 = limB2(gteMAC2, 1);
 602         gteIR3 = limB3(gteMAC3, 1);
 603         gteMAC1 = ((s32)gteR * gteIR1) >> 8;
 604         gteMAC2 = ((s32)gteG * gteIR2) >> 8;
 605         gteMAC3 = ((s32)gteB * gteIR3) >> 8;
 606         gteIR1 = gteMAC1;
 607         gteIR2 = gteMAC2;
 608         gteIR3 = gteMAC3;
 609
 610         gteRGB0 = gteRGB1;
 611         gteRGB1 = gteRGB2;
 612         gteCODE2 = gteCODE;
 613         gteR2 = limC1(gteMAC1 >> 4);
 614         gteG2 = limC2(gteMAC2 >> 4);
 615         gteB2 = limC3(gteMAC3 >> 4);
 616 }
 617
 618 void gteNCCT(psxCP2Regs *regs) {
 619         int v;
 620         s32 vx, vy, vz;
 621
 622 #ifdef GTE_LOG
 623         GTE_LOG("GTE NCCT\n");
 624 #endif
 625         gteFLAG = 0;
 626
 627         for (v = 0; v < 3; v++) {
 628                 vx = VX(v);
 629                 vy = VY(v);
 630                 vz = VZ(v);
 631                 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
 632                 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
 633                 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 12;
 634                 gteIR1 = limB1(gteMAC1, 1);
 635                 gteIR2 = limB2(gteMAC2, 1);
 636                 gteIR3 = limB3(gteMAC3, 1);
 637                 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 638                 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 639                 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 640                 gteIR1 = limB1(gteMAC1, 1);
 641                 gteIR2 = limB2(gteMAC2, 1);
 642                 gteIR3 = limB3(gteMAC3, 1);
 643                 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
 644                 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
 645                 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
 646
 647                 gteRGB0 = gteRGB1;
 648                 gteRGB1 = gteRGB2;
 649                 gteCODE2 = gteCODE;
 650                 gteR2 = limC1(gteMAC1 >> 4);
 651                 gteG2 = limC2(gteMAC2 >> 4);
 652                 gteB2 = limC3(gteMAC3 >> 4);
 653         }
 654         gteIR1 = gteMAC1;
 655         gteIR2 = gteMAC2;
 656         gteIR3 = gteMAC3;
 657 }
 658
 659 void gteNCDS(psxCP2Regs *regs) {
 660 #ifdef GTE_LOG
 661         GTE_LOG("GTE NCDS\n");
 662 #endif
 663         gteFLAG = 0;
 664
 665         gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
 666         gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
 667         gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
 668         gteIR1 = limB1(gteMAC1, 1);
 669         gteIR2 = limB2(gteMAC2, 1);
 670         gteIR3 = limB3(gteMAC3, 1);
 671         gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 672         gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 673         gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 674         gteIR1 = limB1(gteMAC1, 1);
 675         gteIR2 = limB2(gteMAC2, 1);
 676         gteIR3 = limB3(gteMAC3, 1);
 677         gteMAC1 = (((gteR << 4) * gteIR1) + (gteIR0 * limB1(A1U((s64)gteRFC - ((gteR * gteIR1) >> 8)), 0))) >> 12;
 678         gteMAC2 = (((gteG << 4) * gteIR2) + (gteIR0 * limB2(A2U((s64)gteGFC - ((gteG * gteIR2) >> 8)), 0))) >> 12;
 679         gteMAC3 = (((gteB << 4) * gteIR3) + (gteIR0 * limB3(A3U((s64)gteBFC - ((gteB * gteIR3) >> 8)), 0))) >> 12;
 680         gteIR1 = limB1(gteMAC1, 1);
 681         gteIR2 = limB2(gteMAC2, 1);
 682         gteIR3 = limB3(gteMAC3, 1);
 683
 684         gteRGB0 = gteRGB1;
 685         gteRGB1 = gteRGB2;
 686         gteCODE2 = gteCODE;
 687         gteR2 = limC1(gteMAC1 >> 4);
 688         gteG2 = limC2(gteMAC2 >> 4);
 689         gteB2 = limC3(gteMAC3 >> 4);
 690 }
 691
 692 void gteNCDT(psxCP2Regs *regs) {
 693         int v;
 694         s32 vx, vy, vz;
 695
 696 #ifdef GTE_LOG
 697         GTE_LOG("GTE NCDT\n");
 698 #endif
 699         gteFLAG = 0;
 700
 701         for (v = 0; v < 3; v++) {
 702                 vx = VX(v);
 703                 vy = VY(v);
 704                 vz = VZ(v);
 705                 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
 706                 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
 707                 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 12;
 708                 gteIR1 = limB1(gteMAC1, 1);
 709                 gteIR2 = limB2(gteMAC2, 1);
 710                 gteIR3 = limB3(gteMAC3, 1);
 711                 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 712                 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 713                 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 714                 gteIR1 = limB1(gteMAC1, 1);
 715                 gteIR2 = limB2(gteMAC2, 1);
 716                 gteIR3 = limB3(gteMAC3, 1);
 717                 gteMAC1 = (((gteR << 4) * gteIR1) + (gteIR0 * limB1(A1U((s64)gteRFC - ((gteR * gteIR1) >> 8)), 0))) >> 12;
 718                 gteMAC2 = (((gteG << 4) * gteIR2) + (gteIR0 * limB2(A2U((s64)gteGFC - ((gteG * gteIR2) >> 8)), 0))) >> 12;
 719                 gteMAC3 = (((gteB << 4) * gteIR3) + (gteIR0 * limB3(A3U((s64)gteBFC - ((gteB * gteIR3) >> 8)), 0))) >> 12;
 720
 721                 gteRGB0 = gteRGB1;
 722                 gteRGB1 = gteRGB2;
 723                 gteCODE2 = gteCODE;
 724                 gteR2 = limC1(gteMAC1 >> 4);
 725                 gteG2 = limC2(gteMAC2 >> 4);
 726                 gteB2 = limC3(gteMAC3 >> 4);
 727         }
 728         gteIR1 = limB1(gteMAC1, 1);
 729         gteIR2 = limB2(gteMAC2, 1);
 730         gteIR3 = limB3(gteMAC3, 1);
 731 }
 732
 733 void gteOP(psxCP2Regs *regs) {
 734         int shift = 12 * GTE_SF(gteop);
 735         int lm = GTE_LM(gteop);
 736
 737 #ifdef GTE_LOG
 738         GTE_LOG("GTE OP\n");
 739 #endif
 740         gteFLAG = 0;
 741
 742         gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> shift;
 743         gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> shift;
 744         gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> shift;
 745         gteIR1 = limB1(gteMAC1, lm);
 746         gteIR2 = limB2(gteMAC2, lm);
 747         gteIR3 = limB3(gteMAC3, lm);
 748 }
 749
 750 void gteDCPL(psxCP2Regs *regs) {
 751         int lm = GTE_LM(gteop);
 752
 753         s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
 754         s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
 755         s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
 756
 757 #ifdef GTE_LOG
 758         GTE_LOG("GTE DCPL\n");
 759 #endif
 760         gteFLAG = 0;
 761
 762         gteMAC1 = RIR1 + ((gteIR0 * limB1(A1U((s64)gteRFC - RIR1), 0)) >> 12);
 763         gteMAC2 = GIR2 + ((gteIR0 * limB1(A2U((s64)gteGFC - GIR2), 0)) >> 12);
 764         gteMAC3 = BIR3 + ((gteIR0 * limB1(A3U((s64)gteBFC - BIR3), 0)) >> 12);
 765
 766         gteIR1 = limB1(gteMAC1, lm);
 767         gteIR2 = limB2(gteMAC2, lm);
 768         gteIR3 = limB3(gteMAC3, lm);
 769
 770         gteRGB0 = gteRGB1;
 771         gteRGB1 = gteRGB2;
 772         gteCODE2 = gteCODE;
 773         gteR2 = limC1(gteMAC1 >> 4);
 774         gteG2 = limC2(gteMAC2 >> 4);
 775         gteB2 = limC3(gteMAC3 >> 4);
 776 }
 777
 778 void gteGPF(psxCP2Regs *regs) {
 779         int shift = 12 * GTE_SF(gteop);
 780
 781 #ifdef GTE_LOG
 782         GTE_LOG("GTE GPF\n");
 783 #endif
 784         gteFLAG = 0;
 785
 786         gteMAC1 = (gteIR0 * gteIR1) >> shift;
 787         gteMAC2 = (gteIR0 * gteIR2) >> shift;
 788         gteMAC3 = (gteIR0 * gteIR3) >> shift;
 789         gteIR1 = limB1(gteMAC1, 0);
 790         gteIR2 = limB2(gteMAC2, 0);
 791         gteIR3 = limB3(gteMAC3, 0);
 792
 793         gteRGB0 = gteRGB1;
 794         gteRGB1 = gteRGB2;
 795         gteCODE2 = gteCODE;
 796         gteR2 = limC1(gteMAC1 >> 4);
 797         gteG2 = limC2(gteMAC2 >> 4);
 798         gteB2 = limC3(gteMAC3 >> 4);
 799 }
 800
 801 void gteGPL(psxCP2Regs *regs) {
 802         int shift = 12 * GTE_SF(gteop);
 803
 804 #ifdef GTE_LOG
 805         GTE_LOG("GTE GPL\n");
 806 #endif
 807         gteFLAG = 0;
 808
 809         gteMAC1 = A1((((s64)gteMAC1 << shift) + (gteIR0 * gteIR1)) >> shift);
 810         gteMAC2 = A2((((s64)gteMAC2 << shift) + (gteIR0 * gteIR2)) >> shift);
 811         gteMAC3 = A3((((s64)gteMAC3 << shift) + (gteIR0 * gteIR3)) >> shift);
 812         gteIR1 = limB1(gteMAC1, 0);
 813         gteIR2 = limB2(gteMAC2, 0);
 814         gteIR3 = limB3(gteMAC3, 0);
 815
 816         gteRGB0 = gteRGB1;
 817         gteRGB1 = gteRGB2;
 818         gteCODE2 = gteCODE;
 819         gteR2 = limC1(gteMAC1 >> 4);
 820         gteG2 = limC2(gteMAC2 >> 4);
 821         gteB2 = limC3(gteMAC3 >> 4);
 822 }
 823
 824 void gteDPCS(psxCP2Regs *regs) {
 825         int shift = 12 * GTE_SF(gteop);
 826
 827 #ifdef GTE_LOG
 828         GTE_LOG("GTE DPCS\n");
 829 #endif
 830         gteFLAG = 0;
 831
 832         gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U(((s64)gteRFC - (gteR << 4)) << (12 - shift)), 0))) >> 12;
 833         gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U(((s64)gteGFC - (gteG << 4)) << (12 - shift)), 0))) >> 12;
 834         gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U(((s64)gteBFC - (gteB << 4)) << (12 - shift)), 0))) >> 12;
 835
 836         gteIR1 = limB1(gteMAC1, 0);
 837         gteIR2 = limB2(gteMAC2, 0);
 838         gteIR3 = limB3(gteMAC3, 0);
 839         gteRGB0 = gteRGB1;
 840         gteRGB1 = gteRGB2;
 841         gteCODE2 = gteCODE;
 842         gteR2 = limC1(gteMAC1 >> 4);
 843         gteG2 = limC2(gteMAC2 >> 4);
 844         gteB2 = limC3(gteMAC3 >> 4);
 845 }
 846
 847 void gteDPCT(psxCP2Regs *regs) {
 848         int v;
 849
 850 #ifdef GTE_LOG
 851         GTE_LOG("GTE DPCT\n");
 852 #endif
 853         gteFLAG = 0;
 854
 855         for (v = 0; v < 3; v++) {
 856                 gteMAC1 = ((gteR0 << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR0 << 4)), 0))) >> 12;
 857                 gteMAC2 = ((gteG0 << 16) + (gteIR0 * limB1(A2U((s64)gteGFC - (gteG0 << 4)), 0))) >> 12;
 858                 gteMAC3 = ((gteB0 << 16) + (gteIR0 * limB1(A3U((s64)gteBFC - (gteB0 << 4)), 0))) >> 12;
 859
 860                 gteRGB0 = gteRGB1;
 861                 gteRGB1 = gteRGB2;
 862                 gteCODE2 = gteCODE;
 863                 gteR2 = limC1(gteMAC1 >> 4);
 864                 gteG2 = limC2(gteMAC2 >> 4);
 865                 gteB2 = limC3(gteMAC3 >> 4);
 866         }
 867         gteIR1 = limB1(gteMAC1, 0);
 868         gteIR2 = limB2(gteMAC2, 0);
 869         gteIR3 = limB3(gteMAC3, 0);
 870 }
 871
 872 void gteNCS(psxCP2Regs *regs) {
 873 #ifdef GTE_LOG
 874         GTE_LOG("GTE NCS\n");
 875 #endif
 876         gteFLAG = 0;
 877
 878         gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
 879         gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
 880         gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
 881         gteIR1 = limB1(gteMAC1, 1);
 882         gteIR2 = limB2(gteMAC2, 1);
 883         gteIR3 = limB3(gteMAC3, 1);
 884         gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 885         gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 886         gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 887         gteIR1 = limB1(gteMAC1, 1);
 888         gteIR2 = limB2(gteMAC2, 1);
 889         gteIR3 = limB3(gteMAC3, 1);
 890
 891         gteRGB0 = gteRGB1;
 892         gteRGB1 = gteRGB2;
 893         gteCODE2 = gteCODE;
 894         gteR2 = limC1(gteMAC1 >> 4);
 895         gteG2 = limC2(gteMAC2 >> 4);
 896         gteB2 = limC3(gteMAC3 >> 4);
 897 }
 898
 899 void gteNCT(psxCP2Regs *regs) {
 900         int v;
 901         s32 vx, vy, vz;
 902
 903 #ifdef GTE_LOG
 904         GTE_LOG("GTE NCT\n");
 905 #endif
 906         gteFLAG = 0;
 907
 908         for (v = 0; v < 3; v++) {
 909                 vx = VX(v);
 910                 vy = VY(v);
 911                 vz = VZ(v);
 912                 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
 913                 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
 914                 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 12;
 915                 gteIR1 = limB1(gteMAC1, 1);
 916                 gteIR2 = limB2(gteMAC2, 1);
 917                 gteIR3 = limB3(gteMAC3, 1);
 918                 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 919                 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 920                 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 921                 gteRGB0 = gteRGB1;
 922                 gteRGB1 = gteRGB2;
 923                 gteCODE2 = gteCODE;
 924                 gteR2 = limC1(gteMAC1 >> 4);
 925                 gteG2 = limC2(gteMAC2 >> 4);
 926                 gteB2 = limC3(gteMAC3 >> 4);
 927         }
 928         gteIR1 = limB1(gteMAC1, 1);
 929         gteIR2 = limB2(gteMAC2, 1);
 930         gteIR3 = limB3(gteMAC3, 1);
 931 }
 932
 933 void gteCC(psxCP2Regs *regs) {
 934 #ifdef GTE_LOG
 935         GTE_LOG("GTE CC\n");
 936 #endif
 937         gteFLAG = 0;
 938
 939         gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 940         gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 941         gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 942         gteIR1 = limB1(gteMAC1, 1);
 943         gteIR2 = limB2(gteMAC2, 1);
 944         gteIR3 = limB3(gteMAC3, 1);
 945         gteMAC1 = ((s32)gteR * gteIR1) >> 8;
 946         gteMAC2 = ((s32)gteG * gteIR2) >> 8;
 947         gteMAC3 = ((s32)gteB * gteIR3) >> 8;
 948         gteIR1 = limB1(gteMAC1, 1);
 949         gteIR2 = limB2(gteMAC2, 1);
 950         gteIR3 = limB3(gteMAC3, 1);
 951
 952         gteRGB0 = gteRGB1;
 953         gteRGB1 = gteRGB2;
 954         gteCODE2 = gteCODE;
 955         gteR2 = limC1(gteMAC1 >> 4);
 956         gteG2 = limC2(gteMAC2 >> 4);
 957         gteB2 = limC3(gteMAC3 >> 4);
 958 }
 959
 960 void gteINTPL(psxCP2Regs *regs) {
 961         int shift = 12 * GTE_SF(gteop);
 962         int lm = GTE_LM(gteop);
 963
 964 #ifdef GTE_LOG
 965         GTE_LOG("GTE INTPL\n");
 966 #endif
 967         gteFLAG = 0;
 968
 969         gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0))) >> shift;
 970         gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0))) >> shift;
 971         gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0))) >> shift;
 972         gteIR1 = limB1(gteMAC1, lm);
 973         gteIR2 = limB2(gteMAC2, lm);
 974         gteIR3 = limB3(gteMAC3, lm);
 975         gteRGB0 = gteRGB1;
 976         gteRGB1 = gteRGB2;
 977         gteCODE2 = gteCODE;
 978         gteR2 = limC1(gteMAC1 >> 4);
 979         gteG2 = limC2(gteMAC2 >> 4);
 980         gteB2 = limC3(gteMAC3 >> 4);
 981 }
 982
 983 void gteCDP(psxCP2Regs *regs) {
 984 #ifdef GTE_LOG
 985         GTE_LOG("GTE CDP\n");
 986 #endif
 987         gteFLAG = 0;
 988
 989         gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 990         gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 991         gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 992         gteIR1 = limB1(gteMAC1, 1);
 993         gteIR2 = limB2(gteMAC2, 1);
 994         gteIR3 = limB3(gteMAC3, 1);
 995         gteMAC1 = (((gteR << 4) * gteIR1) + (gteIR0 * limB1(A1U((s64)gteRFC - ((gteR * gteIR1) >> 8)), 0))) >> 12;
 996         gteMAC2 = (((gteG << 4) * gteIR2) + (gteIR0 * limB2(A2U((s64)gteGFC - ((gteG * gteIR2) >> 8)), 0))) >> 12;
 997         gteMAC3 = (((gteB << 4) * gteIR3) + (gteIR0 * limB3(A3U((s64)gteBFC - ((gteB * gteIR3) >> 8)), 0))) >> 12;
 998         gteIR1 = limB1(gteMAC1, 1);
 999         gteIR2 = limB2(gteMAC2, 1);
1000         gteIR3 = limB3(gteMAC3, 1);
1001
1002         gteRGB0 = gteRGB1;
1003         gteRGB1 = gteRGB2;
1004         gteCODE2 = gteCODE;
1005         gteR2 = limC1(gteMAC1 >> 4);
1006         gteG2 = limC2(gteMAC2 >> 4);
1007         gteB2 = limC3(gteMAC3 >> 4);
1008 }
1009
1010 /* decomposed/parametrized versions for the recompiler */
1011
1012 #ifndef FLAGLESS
1013
1014 void gteSQR_part_noshift(psxCP2Regs *regs) {
1015         gteFLAG = 0;
1016
1017         gteMAC1 = gteIR1 * gteIR1;
1018         gteMAC2 = gteIR2 * gteIR2;
1019         gteMAC3 = gteIR3 * gteIR3;
1020 }
1021
1022 void gteSQR_part_shift(psxCP2Regs *regs) {
1023         gteFLAG = 0;
1024
1025         gteMAC1 = (gteIR1 * gteIR1) >> 12;
1026         gteMAC2 = (gteIR2 * gteIR2) >> 12;
1027         gteMAC3 = (gteIR3 * gteIR3) >> 12;
1028 }
1029
1030 void gteOP_part_noshift(psxCP2Regs *regs) {
1031         gteFLAG = 0;
1032
1033         gteMAC1 = (gteR22 * gteIR3) - (gteR33 * gteIR2);
1034         gteMAC2 = (gteR33 * gteIR1) - (gteR11 * gteIR3);
1035         gteMAC3 = (gteR11 * gteIR2) - (gteR22 * gteIR1);
1036 }
1037
1038 void gteOP_part_shift(psxCP2Regs *regs) {
1039         gteFLAG = 0;
1040
1041         gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> 12;
1042         gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> 12;
1043         gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> 12;
1044 }
1045
1046 void gteDCPL_part(psxCP2Regs *regs) {
1047         s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
1048         s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
1049         s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
1050
1051         gteFLAG = 0;
1052
1053         gteMAC1 = RIR1 + ((gteIR0 * limB1(A1U((s64)gteRFC - RIR1), 0)) >> 12);
1054         gteMAC2 = GIR2 + ((gteIR0 * limB1(A2U((s64)gteGFC - GIR2), 0)) >> 12);
1055         gteMAC3 = BIR3 + ((gteIR0 * limB1(A3U((s64)gteBFC - BIR3), 0)) >> 12);
1056 }
1057
1058 void gteGPF_part_noshift(psxCP2Regs *regs) {
1059         gteFLAG = 0;
1060
1061         gteMAC1 = gteIR0 * gteIR1;
1062         gteMAC2 = gteIR0 * gteIR2;
1063         gteMAC3 = gteIR0 * gteIR3;
1064 }
1065
1066 void gteGPF_part_shift(psxCP2Regs *regs) {
1067         gteFLAG = 0;
1068
1069         gteMAC1 = (gteIR0 * gteIR1) >> 12;
1070         gteMAC2 = (gteIR0 * gteIR2) >> 12;
1071         gteMAC3 = (gteIR0 * gteIR3) >> 12;
1072 }
1073
1074 #endif // !FLAGLESS
1075
1076 void gteGPL_part_noshift(psxCP2Regs *regs) {
1077         gteFLAG = 0;
1078
1079         gteMAC1 = A1((s64)gteMAC1 + (gteIR0 * gteIR1));
1080         gteMAC2 = A2((s64)gteMAC2 + (gteIR0 * gteIR2));
1081         gteMAC3 = A3((s64)gteMAC3 + (gteIR0 * gteIR3));
1082 }
1083
1084 void gteGPL_part_shift(psxCP2Regs *regs) {
1085         gteFLAG = 0;
1086
1087         gteMAC1 = A1((s64)gteMAC1 + ((gteIR0 * gteIR1) >> 12));
1088         gteMAC2 = A2((s64)gteMAC2 + ((gteIR0 * gteIR2) >> 12));
1089         gteMAC3 = A3((s64)gteMAC3 + ((gteIR0 * gteIR3) >> 12));
1090 }
1091
1092 void gteDPCS_part_noshift(psxCP2Regs *regs) {
1093         int shift = 0;
1094
1095         gteFLAG = 0;
1096
1097         gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR << 4)) << (12 - shift), 0))) >> 12;
1098         gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U((s64)gteGFC - (gteG << 4)) << (12 - shift), 0))) >> 12;
1099         gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U((s64)gteBFC - (gteB << 4)) << (12 - shift), 0))) >> 12;
1100 }
1101
1102 void gteDPCS_part_shift(psxCP2Regs *regs) {
1103         int shift = 12;
1104
1105         gteFLAG = 0;
1106
1107         gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR << 4)) << (12 - shift), 0))) >> 12;
1108         gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U((s64)gteGFC - (gteG << 4)) << (12 - shift), 0))) >> 12;
1109         gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U((s64)gteBFC - (gteB << 4)) << (12 - shift), 0))) >> 12;
1110 }
1111
1112 void gteINTPL_part_noshift(psxCP2Regs *regs) {
1113         gteFLAG = 0;
1114
1115         gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0)));
1116         gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0)));
1117         gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0)));
1118 }
1119
1120 void gteINTPL_part_shift(psxCP2Regs *regs) {
1121         gteFLAG = 0;
1122
1123         gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0))) >> 12;
1124         gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0))) >> 12;
1125         gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0))) >> 12;
1126 }
1127
1128 void gteMACtoRGB(psxCP2Regs *regs) {
1129         gteRGB0 = gteRGB1;
1130         gteRGB1 = gteRGB2;
1131         gteCODE2 = gteCODE;
1132         gteR2 = limC1(gteMAC1 >> 4);
1133         gteG2 = limC2(gteMAC2 >> 4);
1134         gteB2 = limC3(gteMAC3 >> 4);
1135 }
1136