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/> *
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. *
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. *
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 ***************************************************************************/
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)
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; */
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])
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 (regs->CP2C.p[26].sw.l)
158 #define gteH (regs->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])
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)
175 #define gteop (psxRegs.code & 0x1ffffff)
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;
188 static inline s32 LIM_(psxCP2Regs *regs, s32 value, s32 max, s32 min, u32 flag) {
193 } else if (value < min) {
200 static inline u32 limE_(psxCP2Regs *regs, u32 result) {
201 if (result > 0x1ffff) {
202 gteFLAG |= (1 << 31) | (1 << 17);
210 #define BOUNDS_(regs, a, ...) (a)
212 static inline s32 LIM_(psxCP2Regs *regs, s32 value, s32 max, s32 min, u32 flag_unused) {
216 else if (value < min)
221 static inline u32 limE_(psxCP2Regs *regs, u32 result) {
222 if (result > 0x1ffff)
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) \
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))
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))
257 /* these are unlikely to be hit and usually waste cycles, don't want them on ARM */
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) {
268 return ((u32)n << 16) / d;
273 #include "gte_divider.h"
274 #endif // GTE_USE_NATIVE_DIVIDE
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,
286 // warning: called by the dynarec
287 int gteCheckStallRaw(u32 op_cycles, psxRegisters *regs) {
288 u32 left = regs->gteBusyCycle - regs->cycle;
292 //printf("c %2u stall %2u %u\n", op_cycles, left, regs->cycle);
293 regs->cycle = regs->gteBusyCycle;
296 regs->gteBusyCycle = regs->cycle + op_cycles;
300 void gteCheckStall(u32 op) {
301 gteCheckStallRaw(gte_cycletab[op], &psxRegs);
305 psxCP2Regs *regs = &psxRegs.CP2;
314 psxRegs.CP2D.r[reg] = (s32)psxRegs.CP2D.p[reg].sw.l;
322 psxRegs.CP2D.r[reg] = (u32)psxRegs.CP2D.p[reg].w.l;
326 psxRegs.CP2D.r[reg] = gteSXY2;
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);
336 return psxRegs.CP2D.r[reg];
339 void MTC2(u32 value, int reg) {
340 psxCP2Regs *regs = &psxRegs.CP2;
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;
365 for (i = 31; (a & (1 << i)) == 0 && i >= 0; i--);
370 for (i = 31; (a & (1 << i)) == 0 && i >= 0; i--);
382 psxRegs.CP2D.r[reg] = value;
386 void CTC2(u32 value, int reg) {
395 value = (s32)(s16)value;
399 value = value & 0x7ffff000;
400 if (value & 0x7f87e000) value |= 0x80000000;
404 psxRegs.CP2C.r[reg] = value;
409 psxRegs.GPR.r[_Rt_] = MFC2(_Rd_);
414 psxRegs.GPR.r[_Rt_] = psxRegs.CP2C.r[_Rd_];
418 MTC2(psxRegs.GPR.r[_Rt_], _Rd_);
422 CTC2(psxRegs.GPR.r[_Rt_], _Rd_);
425 #define _oB_ (psxRegs.GPR.r[_Rs_] + _Imm_)
428 MTC2(psxMemRead32(_oB_), _Rt_);
432 psxMemWrite32(_oB_, MFC2(_Rt_));
435 void gteLWC2_stall() {
440 void gteSWC2_stall() {
448 #define DIVIDE DIVIDE_
449 static u32 DIVIDE_(s16 n, u16 d) {
450 if (n >= 0 && n < d * 2) {
452 return ((n_ << 16) + d / 2) / d;
453 //return (u32)((float)(n_ << 16) / (float)d + (float)0.5);
459 void gteRTPS(psxCP2Regs *regs) {
464 GTE_LOG("GTE RTPS\n");
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);
477 gteSZ3 = limD(gteMAC3);
478 quotient = limE(DIVIDE(gteH, gteSZ3));
481 gteSX2 = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
482 gteSY2 = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
484 tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
486 gteIR0 = limH(tmp >> 12);
489 void gteRTPT(psxCP2Regs *regs) {
496 GTE_LOG("GTE RTPT\n");
501 for (v = 0; v < 3; 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);
517 tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
519 gteIR0 = limH(tmp >> 12);
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);
533 GTE_LOG("GTE MVMVA\n");
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);
541 gteIR1 = limB1(gteMAC1, lm);
542 gteIR2 = limB2(gteMAC2, lm);
543 gteIR3 = limB3(gteMAC3, lm);
546 void gteNCLIP(psxCP2Regs *regs) {
548 GTE_LOG("GTE NCLIP\n");
552 gteMAC0 = F((s64)gteSX0 * (gteSY1 - gteSY2) +
553 gteSX1 * (gteSY2 - gteSY0) +
554 gteSX2 * (gteSY0 - gteSY1));
557 void gteAVSZ3(psxCP2Regs *regs) {
559 GTE_LOG("GTE AVSZ3\n");
563 gteMAC0 = F((s64)gteZSF3 * (gteSZ1 + gteSZ2 + gteSZ3));
564 gteOTZ = limD(gteMAC0 >> 12);
567 void gteAVSZ4(psxCP2Regs *regs) {
569 GTE_LOG("GTE AVSZ4\n");
573 gteMAC0 = F((s64)gteZSF4 * (gteSZ0 + gteSZ1 + gteSZ2 + gteSZ3));
574 gteOTZ = limD(gteMAC0 >> 12);
577 void gteSQR(psxCP2Regs *regs) {
578 int shift = 12 * GTE_SF(gteop);
579 int lm = GTE_LM(gteop);
582 GTE_LOG("GTE SQR\n");
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);
594 void gteNCCS(psxCP2Regs *regs) {
596 GTE_LOG("GTE NCCS\n");
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;
622 gteR2 = limC1(gteMAC1 >> 4);
623 gteG2 = limC2(gteMAC2 >> 4);
624 gteB2 = limC3(gteMAC3 >> 4);
627 void gteNCCT(psxCP2Regs *regs) {
632 GTE_LOG("GTE NCCT\n");
636 for (v = 0; v < 3; 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;
659 gteR2 = limC1(gteMAC1 >> 4);
660 gteG2 = limC2(gteMAC2 >> 4);
661 gteB2 = limC3(gteMAC3 >> 4);
668 void gteNCDS(psxCP2Regs *regs) {
670 GTE_LOG("GTE NCDS\n");
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);
696 gteR2 = limC1(gteMAC1 >> 4);
697 gteG2 = limC2(gteMAC2 >> 4);
698 gteB2 = limC3(gteMAC3 >> 4);
701 void gteNCDT(psxCP2Regs *regs) {
706 GTE_LOG("GTE NCDT\n");
710 for (v = 0; v < 3; 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;
733 gteR2 = limC1(gteMAC1 >> 4);
734 gteG2 = limC2(gteMAC2 >> 4);
735 gteB2 = limC3(gteMAC3 >> 4);
737 gteIR1 = limB1(gteMAC1, 1);
738 gteIR2 = limB2(gteMAC2, 1);
739 gteIR3 = limB3(gteMAC3, 1);
742 void gteOP(psxCP2Regs *regs) {
743 int shift = 12 * GTE_SF(gteop);
744 int lm = GTE_LM(gteop);
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);
759 void gteDCPL(psxCP2Regs *regs) {
760 int lm = GTE_LM(gteop);
762 s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
763 s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
764 s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
767 GTE_LOG("GTE DCPL\n");
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);
775 gteIR1 = limB1(gteMAC1, lm);
776 gteIR2 = limB2(gteMAC2, lm);
777 gteIR3 = limB3(gteMAC3, lm);
782 gteR2 = limC1(gteMAC1 >> 4);
783 gteG2 = limC2(gteMAC2 >> 4);
784 gteB2 = limC3(gteMAC3 >> 4);
787 void gteGPF(psxCP2Regs *regs) {
788 int shift = 12 * GTE_SF(gteop);
791 GTE_LOG("GTE GPF\n");
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);
805 gteR2 = limC1(gteMAC1 >> 4);
806 gteG2 = limC2(gteMAC2 >> 4);
807 gteB2 = limC3(gteMAC3 >> 4);
810 void gteGPL(psxCP2Regs *regs) {
811 int shift = 12 * GTE_SF(gteop);
814 GTE_LOG("GTE GPL\n");
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);
828 gteR2 = limC1(gteMAC1 >> 4);
829 gteG2 = limC2(gteMAC2 >> 4);
830 gteB2 = limC3(gteMAC3 >> 4);
833 void gteDPCS(psxCP2Regs *regs) {
834 int shift = 12 * GTE_SF(gteop);
837 GTE_LOG("GTE DPCS\n");
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;
845 gteIR1 = limB1(gteMAC1, 0);
846 gteIR2 = limB2(gteMAC2, 0);
847 gteIR3 = limB3(gteMAC3, 0);
851 gteR2 = limC1(gteMAC1 >> 4);
852 gteG2 = limC2(gteMAC2 >> 4);
853 gteB2 = limC3(gteMAC3 >> 4);
856 void gteDPCT(psxCP2Regs *regs) {
860 GTE_LOG("GTE DPCT\n");
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;
872 gteR2 = limC1(gteMAC1 >> 4);
873 gteG2 = limC2(gteMAC2 >> 4);
874 gteB2 = limC3(gteMAC3 >> 4);
876 gteIR1 = limB1(gteMAC1, 0);
877 gteIR2 = limB2(gteMAC2, 0);
878 gteIR3 = limB3(gteMAC3, 0);
881 void gteNCS(psxCP2Regs *regs) {
883 GTE_LOG("GTE NCS\n");
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);
903 gteR2 = limC1(gteMAC1 >> 4);
904 gteG2 = limC2(gteMAC2 >> 4);
905 gteB2 = limC3(gteMAC3 >> 4);
908 void gteNCT(psxCP2Regs *regs) {
913 GTE_LOG("GTE NCT\n");
917 for (v = 0; v < 3; 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);
933 gteR2 = limC1(gteMAC1 >> 4);
934 gteG2 = limC2(gteMAC2 >> 4);
935 gteB2 = limC3(gteMAC3 >> 4);
937 gteIR1 = limB1(gteMAC1, 1);
938 gteIR2 = limB2(gteMAC2, 1);
939 gteIR3 = limB3(gteMAC3, 1);
942 void gteCC(psxCP2Regs *regs) {
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);
964 gteR2 = limC1(gteMAC1 >> 4);
965 gteG2 = limC2(gteMAC2 >> 4);
966 gteB2 = limC3(gteMAC3 >> 4);
969 void gteINTPL(psxCP2Regs *regs) {
970 int shift = 12 * GTE_SF(gteop);
971 int lm = GTE_LM(gteop);
974 GTE_LOG("GTE INTPL\n");
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);
987 gteR2 = limC1(gteMAC1 >> 4);
988 gteG2 = limC2(gteMAC2 >> 4);
989 gteB2 = limC3(gteMAC3 >> 4);
992 void gteCDP(psxCP2Regs *regs) {
994 GTE_LOG("GTE CDP\n");
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);
1014 gteR2 = limC1(gteMAC1 >> 4);
1015 gteG2 = limC2(gteMAC2 >> 4);
1016 gteB2 = limC3(gteMAC3 >> 4);
1019 /* decomposed/parametrized versions for the recompiler */
1023 void gteSQR_part_noshift(psxCP2Regs *regs) {
1026 gteMAC1 = gteIR1 * gteIR1;
1027 gteMAC2 = gteIR2 * gteIR2;
1028 gteMAC3 = gteIR3 * gteIR3;
1031 void gteSQR_part_shift(psxCP2Regs *regs) {
1034 gteMAC1 = (gteIR1 * gteIR1) >> 12;
1035 gteMAC2 = (gteIR2 * gteIR2) >> 12;
1036 gteMAC3 = (gteIR3 * gteIR3) >> 12;
1039 void gteOP_part_noshift(psxCP2Regs *regs) {
1042 gteMAC1 = (gteR22 * gteIR3) - (gteR33 * gteIR2);
1043 gteMAC2 = (gteR33 * gteIR1) - (gteR11 * gteIR3);
1044 gteMAC3 = (gteR11 * gteIR2) - (gteR22 * gteIR1);
1047 void gteOP_part_shift(psxCP2Regs *regs) {
1050 gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> 12;
1051 gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> 12;
1052 gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> 12;
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;
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);
1067 void gteGPF_part_noshift(psxCP2Regs *regs) {
1070 gteMAC1 = gteIR0 * gteIR1;
1071 gteMAC2 = gteIR0 * gteIR2;
1072 gteMAC3 = gteIR0 * gteIR3;
1075 void gteGPF_part_shift(psxCP2Regs *regs) {
1078 gteMAC1 = (gteIR0 * gteIR1) >> 12;
1079 gteMAC2 = (gteIR0 * gteIR2) >> 12;
1080 gteMAC3 = (gteIR0 * gteIR3) >> 12;
1085 void gteGPL_part_noshift(psxCP2Regs *regs) {
1088 gteMAC1 = A1((s64)gteMAC1 + (gteIR0 * gteIR1));
1089 gteMAC2 = A2((s64)gteMAC2 + (gteIR0 * gteIR2));
1090 gteMAC3 = A3((s64)gteMAC3 + (gteIR0 * gteIR3));
1093 void gteGPL_part_shift(psxCP2Regs *regs) {
1096 gteMAC1 = A1((s64)gteMAC1 + ((gteIR0 * gteIR1) >> 12));
1097 gteMAC2 = A2((s64)gteMAC2 + ((gteIR0 * gteIR2) >> 12));
1098 gteMAC3 = A3((s64)gteMAC3 + ((gteIR0 * gteIR3) >> 12));
1101 void gteDPCS_part_noshift(psxCP2Regs *regs) {
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;
1111 void gteDPCS_part_shift(psxCP2Regs *regs) {
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;
1121 void gteINTPL_part_noshift(psxCP2Regs *regs) {
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)));
1129 void gteINTPL_part_shift(psxCP2Regs *regs) {
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;
1137 void gteMACtoRGB(psxCP2Regs *regs) {
1141 gteR2 = limC1(gteMAC1 >> 4);
1142 gteG2 = limC2(gteMAC2 >> 4);
1143 gteB2 = limC3(gteMAC3 >> 4);