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 (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])
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 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);
304 static inline u32 MFC2(int reg) {
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 static inline 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 static inline 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_);
433 psxMemWrite32(_oB_, MFC2(_Rt_));
439 #define DIVIDE DIVIDE_
440 static u32 DIVIDE_(s16 n, u16 d) {
441 if (n >= 0 && n < d * 2) {
443 return ((n_ << 16) + d / 2) / d;
444 //return (u32)((float)(n_ << 16) / (float)d + (float)0.5);
450 void gteRTPS(psxCP2Regs *regs) {
455 GTE_LOG("GTE RTPS\n");
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);
468 gteSZ3 = limD(gteMAC3);
469 quotient = limE(DIVIDE(gteH, gteSZ3));
472 gteSX2 = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
473 gteSY2 = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
475 tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
477 gteIR0 = limH(tmp >> 12);
480 void gteRTPT(psxCP2Regs *regs) {
487 GTE_LOG("GTE RTPT\n");
492 for (v = 0; v < 3; 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);
508 tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
510 gteIR0 = limH(tmp >> 12);
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);
524 GTE_LOG("GTE MVMVA\n");
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);
532 gteIR1 = limB1(gteMAC1, lm);
533 gteIR2 = limB2(gteMAC2, lm);
534 gteIR3 = limB3(gteMAC3, lm);
537 void gteNCLIP(psxCP2Regs *regs) {
539 GTE_LOG("GTE NCLIP\n");
543 gteMAC0 = F((s64)gteSX0 * (gteSY1 - gteSY2) +
544 gteSX1 * (gteSY2 - gteSY0) +
545 gteSX2 * (gteSY0 - gteSY1));
548 void gteAVSZ3(psxCP2Regs *regs) {
550 GTE_LOG("GTE AVSZ3\n");
554 gteMAC0 = F((s64)gteZSF3 * (gteSZ1 + gteSZ2 + gteSZ3));
555 gteOTZ = limD(gteMAC0 >> 12);
558 void gteAVSZ4(psxCP2Regs *regs) {
560 GTE_LOG("GTE AVSZ4\n");
564 gteMAC0 = F((s64)gteZSF4 * (gteSZ0 + gteSZ1 + gteSZ2 + gteSZ3));
565 gteOTZ = limD(gteMAC0 >> 12);
568 void gteSQR(psxCP2Regs *regs) {
569 int shift = 12 * GTE_SF(gteop);
570 int lm = GTE_LM(gteop);
573 GTE_LOG("GTE SQR\n");
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);
585 void gteNCCS(psxCP2Regs *regs) {
587 GTE_LOG("GTE NCCS\n");
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;
613 gteR2 = limC1(gteMAC1 >> 4);
614 gteG2 = limC2(gteMAC2 >> 4);
615 gteB2 = limC3(gteMAC3 >> 4);
618 void gteNCCT(psxCP2Regs *regs) {
623 GTE_LOG("GTE NCCT\n");
627 for (v = 0; v < 3; 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;
650 gteR2 = limC1(gteMAC1 >> 4);
651 gteG2 = limC2(gteMAC2 >> 4);
652 gteB2 = limC3(gteMAC3 >> 4);
659 void gteNCDS(psxCP2Regs *regs) {
661 GTE_LOG("GTE NCDS\n");
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);
687 gteR2 = limC1(gteMAC1 >> 4);
688 gteG2 = limC2(gteMAC2 >> 4);
689 gteB2 = limC3(gteMAC3 >> 4);
692 void gteNCDT(psxCP2Regs *regs) {
697 GTE_LOG("GTE NCDT\n");
701 for (v = 0; v < 3; 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;
724 gteR2 = limC1(gteMAC1 >> 4);
725 gteG2 = limC2(gteMAC2 >> 4);
726 gteB2 = limC3(gteMAC3 >> 4);
728 gteIR1 = limB1(gteMAC1, 1);
729 gteIR2 = limB2(gteMAC2, 1);
730 gteIR3 = limB3(gteMAC3, 1);
733 void gteOP(psxCP2Regs *regs) {
734 int shift = 12 * GTE_SF(gteop);
735 int lm = GTE_LM(gteop);
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);
750 void gteDCPL(psxCP2Regs *regs) {
751 int lm = GTE_LM(gteop);
753 s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
754 s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
755 s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
758 GTE_LOG("GTE DCPL\n");
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);
766 gteIR1 = limB1(gteMAC1, lm);
767 gteIR2 = limB2(gteMAC2, lm);
768 gteIR3 = limB3(gteMAC3, lm);
773 gteR2 = limC1(gteMAC1 >> 4);
774 gteG2 = limC2(gteMAC2 >> 4);
775 gteB2 = limC3(gteMAC3 >> 4);
778 void gteGPF(psxCP2Regs *regs) {
779 int shift = 12 * GTE_SF(gteop);
782 GTE_LOG("GTE GPF\n");
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);
796 gteR2 = limC1(gteMAC1 >> 4);
797 gteG2 = limC2(gteMAC2 >> 4);
798 gteB2 = limC3(gteMAC3 >> 4);
801 void gteGPL(psxCP2Regs *regs) {
802 int shift = 12 * GTE_SF(gteop);
805 GTE_LOG("GTE GPL\n");
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);
819 gteR2 = limC1(gteMAC1 >> 4);
820 gteG2 = limC2(gteMAC2 >> 4);
821 gteB2 = limC3(gteMAC3 >> 4);
824 void gteDPCS(psxCP2Regs *regs) {
825 int shift = 12 * GTE_SF(gteop);
828 GTE_LOG("GTE DPCS\n");
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;
836 gteIR1 = limB1(gteMAC1, 0);
837 gteIR2 = limB2(gteMAC2, 0);
838 gteIR3 = limB3(gteMAC3, 0);
842 gteR2 = limC1(gteMAC1 >> 4);
843 gteG2 = limC2(gteMAC2 >> 4);
844 gteB2 = limC3(gteMAC3 >> 4);
847 void gteDPCT(psxCP2Regs *regs) {
851 GTE_LOG("GTE DPCT\n");
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;
863 gteR2 = limC1(gteMAC1 >> 4);
864 gteG2 = limC2(gteMAC2 >> 4);
865 gteB2 = limC3(gteMAC3 >> 4);
867 gteIR1 = limB1(gteMAC1, 0);
868 gteIR2 = limB2(gteMAC2, 0);
869 gteIR3 = limB3(gteMAC3, 0);
872 void gteNCS(psxCP2Regs *regs) {
874 GTE_LOG("GTE NCS\n");
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);
894 gteR2 = limC1(gteMAC1 >> 4);
895 gteG2 = limC2(gteMAC2 >> 4);
896 gteB2 = limC3(gteMAC3 >> 4);
899 void gteNCT(psxCP2Regs *regs) {
904 GTE_LOG("GTE NCT\n");
908 for (v = 0; v < 3; 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);
924 gteR2 = limC1(gteMAC1 >> 4);
925 gteG2 = limC2(gteMAC2 >> 4);
926 gteB2 = limC3(gteMAC3 >> 4);
928 gteIR1 = limB1(gteMAC1, 1);
929 gteIR2 = limB2(gteMAC2, 1);
930 gteIR3 = limB3(gteMAC3, 1);
933 void gteCC(psxCP2Regs *regs) {
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);
955 gteR2 = limC1(gteMAC1 >> 4);
956 gteG2 = limC2(gteMAC2 >> 4);
957 gteB2 = limC3(gteMAC3 >> 4);
960 void gteINTPL(psxCP2Regs *regs) {
961 int shift = 12 * GTE_SF(gteop);
962 int lm = GTE_LM(gteop);
965 GTE_LOG("GTE INTPL\n");
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);
978 gteR2 = limC1(gteMAC1 >> 4);
979 gteG2 = limC2(gteMAC2 >> 4);
980 gteB2 = limC3(gteMAC3 >> 4);
983 void gteCDP(psxCP2Regs *regs) {
985 GTE_LOG("GTE CDP\n");
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);
1005 gteR2 = limC1(gteMAC1 >> 4);
1006 gteG2 = limC2(gteMAC2 >> 4);
1007 gteB2 = limC3(gteMAC3 >> 4);
1010 /* decomposed/parametrized versions for the recompiler */
1014 void gteSQR_part_noshift(psxCP2Regs *regs) {
1017 gteMAC1 = gteIR1 * gteIR1;
1018 gteMAC2 = gteIR2 * gteIR2;
1019 gteMAC3 = gteIR3 * gteIR3;
1022 void gteSQR_part_shift(psxCP2Regs *regs) {
1025 gteMAC1 = (gteIR1 * gteIR1) >> 12;
1026 gteMAC2 = (gteIR2 * gteIR2) >> 12;
1027 gteMAC3 = (gteIR3 * gteIR3) >> 12;
1030 void gteOP_part_noshift(psxCP2Regs *regs) {
1033 gteMAC1 = (gteR22 * gteIR3) - (gteR33 * gteIR2);
1034 gteMAC2 = (gteR33 * gteIR1) - (gteR11 * gteIR3);
1035 gteMAC3 = (gteR11 * gteIR2) - (gteR22 * gteIR1);
1038 void gteOP_part_shift(psxCP2Regs *regs) {
1041 gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> 12;
1042 gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> 12;
1043 gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> 12;
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;
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);
1058 void gteGPF_part_noshift(psxCP2Regs *regs) {
1061 gteMAC1 = gteIR0 * gteIR1;
1062 gteMAC2 = gteIR0 * gteIR2;
1063 gteMAC3 = gteIR0 * gteIR3;
1066 void gteGPF_part_shift(psxCP2Regs *regs) {
1069 gteMAC1 = (gteIR0 * gteIR1) >> 12;
1070 gteMAC2 = (gteIR0 * gteIR2) >> 12;
1071 gteMAC3 = (gteIR0 * gteIR3) >> 12;
1076 void gteGPL_part_noshift(psxCP2Regs *regs) {
1079 gteMAC1 = A1((s64)gteMAC1 + (gteIR0 * gteIR1));
1080 gteMAC2 = A2((s64)gteMAC2 + (gteIR0 * gteIR2));
1081 gteMAC3 = A3((s64)gteMAC3 + (gteIR0 * gteIR3));
1084 void gteGPL_part_shift(psxCP2Regs *regs) {
1087 gteMAC1 = A1((s64)gteMAC1 + ((gteIR0 * gteIR1) >> 12));
1088 gteMAC2 = A2((s64)gteMAC2 + ((gteIR0 * gteIR2) >> 12));
1089 gteMAC3 = A3((s64)gteMAC3 + ((gteIR0 * gteIR3) >> 12));
1092 void gteDPCS_part_noshift(psxCP2Regs *regs) {
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;
1102 void gteDPCS_part_shift(psxCP2Regs *regs) {
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;
1112 void gteINTPL_part_noshift(psxCP2Regs *regs) {
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)));
1120 void gteINTPL_part_shift(psxCP2Regs *regs) {
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;
1128 void gteMACtoRGB(psxCP2Regs *regs) {
1132 gteR2 = limC1(gteMAC1 >> 4);
1133 gteG2 = limC2(gteMAC2 >> 4);
1134 gteB2 = limC3(gteMAC3 >> 4);