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);
304 u32 MFC2(struct psxCP2Regs *regs, int reg) {
313 regs->CP2D.r[reg] = (s32)regs->CP2D.p[reg].sw.l;
321 regs->CP2D.r[reg] = (u32)regs->CP2D.p[reg].w.l;
325 regs->CP2D.r[reg] = gteSXY2;
330 regs->CP2D.r[reg] = LIM(gteIR1 >> 7, 0x1f, 0, 0) |
331 (LIM(gteIR2 >> 7, 0x1f, 0, 0) << 5) |
332 (LIM(gteIR3 >> 7, 0x1f, 0, 0) << 10);
335 return regs->CP2D.r[reg];
338 void MTC2(struct psxCP2Regs *regs, u32 value, int reg) {
349 // not gteIR1 etc. just to be consistent with dynarec
350 regs->CP2D.n.ir1 = (value & 0x1f) << 7;
351 regs->CP2D.n.ir2 = (value & 0x3e0) << 2;
352 regs->CP2D.n.ir3 = (value & 0x7c00) >> 3;
363 for (i = 31; (a & (1 << i)) == 0 && i >= 0; i--);
368 for (i = 31; (a & (1 << i)) == 0 && i >= 0; i--);
380 regs->CP2D.r[reg] = value;
384 void CTC2(struct psxCP2Regs *regs, u32 value, int reg) {
393 value = (s32)(s16)value;
397 value = value & 0x7ffff000;
398 if (value & 0x7f87e000) value |= 0x80000000;
402 regs->CP2C.r[reg] = value;
408 #define DIVIDE DIVIDE_
409 static u32 DIVIDE_(s16 n, u16 d) {
410 if (n >= 0 && n < d * 2) {
412 return ((n_ << 16) + d / 2) / d;
413 //return (u32)((float)(n_ << 16) / (float)d + (float)0.5);
419 void gteRTPS(psxCP2Regs *regs) {
424 GTE_LOG("GTE RTPS\n");
428 gteMAC1 = A1((((s64)gteTRX << 12) + (gteR11 * gteVX0) + (gteR12 * gteVY0) + (gteR13 * gteVZ0)) >> 12);
429 gteMAC2 = A2((((s64)gteTRY << 12) + (gteR21 * gteVX0) + (gteR22 * gteVY0) + (gteR23 * gteVZ0)) >> 12);
430 gteMAC3 = A3((((s64)gteTRZ << 12) + (gteR31 * gteVX0) + (gteR32 * gteVY0) + (gteR33 * gteVZ0)) >> 12);
431 gteIR1 = limB1(gteMAC1, 0);
432 gteIR2 = limB2(gteMAC2, 0);
433 gteIR3 = limB3(gteMAC3, 0);
437 gteSZ3 = limD(gteMAC3);
438 quotient = limE(DIVIDE(gteH, gteSZ3));
441 gteSX2 = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
442 gteSY2 = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
444 tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
446 gteIR0 = limH(tmp >> 12);
449 void gteRTPT(psxCP2Regs *regs) {
456 GTE_LOG("GTE RTPT\n");
461 for (v = 0; v < 3; v++) {
465 gteMAC1 = A1((((s64)gteTRX << 12) + (gteR11 * vx) + (gteR12 * vy) + (gteR13 * vz)) >> 12);
466 gteMAC2 = A2((((s64)gteTRY << 12) + (gteR21 * vx) + (gteR22 * vy) + (gteR23 * vz)) >> 12);
467 gteMAC3 = A3((((s64)gteTRZ << 12) + (gteR31 * vx) + (gteR32 * vy) + (gteR33 * vz)) >> 12);
468 gteIR1 = limB1(gteMAC1, 0);
469 gteIR2 = limB2(gteMAC2, 0);
470 gteIR3 = limB3(gteMAC3, 0);
471 fSZ(v) = limD(gteMAC3);
472 quotient = limE(DIVIDE(gteH, fSZ(v)));
473 fSX(v) = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
474 fSY(v) = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
477 tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
479 gteIR0 = limH(tmp >> 12);
482 void gteMVMVA(psxCP2Regs *regs) {
483 int shift = 12 * GTE_SF(gteop);
484 int mx = GTE_MX(gteop);
485 int v = GTE_V(gteop);
486 int cv = GTE_CV(gteop);
487 int lm = GTE_LM(gteop);
493 GTE_LOG("GTE MVMVA\n");
497 gteMAC1 = A1((((s64)CV1(cv) << 12) + (MX11(mx) * vx) + (MX12(mx) * vy) + (MX13(mx) * vz)) >> shift);
498 gteMAC2 = A2((((s64)CV2(cv) << 12) + (MX21(mx) * vx) + (MX22(mx) * vy) + (MX23(mx) * vz)) >> shift);
499 gteMAC3 = A3((((s64)CV3(cv) << 12) + (MX31(mx) * vx) + (MX32(mx) * vy) + (MX33(mx) * vz)) >> shift);
501 gteIR1 = limB1(gteMAC1, lm);
502 gteIR2 = limB2(gteMAC2, lm);
503 gteIR3 = limB3(gteMAC3, lm);
506 void gteNCLIP(psxCP2Regs *regs) {
508 GTE_LOG("GTE NCLIP\n");
512 gteMAC0 = F((s64)gteSX0 * (gteSY1 - gteSY2) +
513 gteSX1 * (gteSY2 - gteSY0) +
514 gteSX2 * (gteSY0 - gteSY1));
517 void gteAVSZ3(psxCP2Regs *regs) {
519 GTE_LOG("GTE AVSZ3\n");
523 gteMAC0 = F((s64)gteZSF3 * (gteSZ1 + gteSZ2 + gteSZ3));
524 gteOTZ = limD(gteMAC0 >> 12);
527 void gteAVSZ4(psxCP2Regs *regs) {
529 GTE_LOG("GTE AVSZ4\n");
533 gteMAC0 = F((s64)gteZSF4 * (gteSZ0 + gteSZ1 + gteSZ2 + gteSZ3));
534 gteOTZ = limD(gteMAC0 >> 12);
537 void gteSQR(psxCP2Regs *regs) {
538 int shift = 12 * GTE_SF(gteop);
539 int lm = GTE_LM(gteop);
542 GTE_LOG("GTE SQR\n");
546 gteMAC1 = (gteIR1 * gteIR1) >> shift;
547 gteMAC2 = (gteIR2 * gteIR2) >> shift;
548 gteMAC3 = (gteIR3 * gteIR3) >> shift;
549 gteIR1 = limB1(gteMAC1, lm);
550 gteIR2 = limB2(gteMAC2, lm);
551 gteIR3 = limB3(gteMAC3, lm);
554 void gteNCCS(psxCP2Regs *regs) {
556 GTE_LOG("GTE NCCS\n");
560 gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
561 gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
562 gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
563 gteIR1 = limB1(gteMAC1, 1);
564 gteIR2 = limB2(gteMAC2, 1);
565 gteIR3 = limB3(gteMAC3, 1);
566 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
567 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
568 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
569 gteIR1 = limB1(gteMAC1, 1);
570 gteIR2 = limB2(gteMAC2, 1);
571 gteIR3 = limB3(gteMAC3, 1);
572 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
573 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
574 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
582 gteR2 = limC1(gteMAC1 >> 4);
583 gteG2 = limC2(gteMAC2 >> 4);
584 gteB2 = limC3(gteMAC3 >> 4);
587 void gteNCCT(psxCP2Regs *regs) {
592 GTE_LOG("GTE NCCT\n");
596 for (v = 0; v < 3; v++) {
600 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
601 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
602 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 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;
619 gteR2 = limC1(gteMAC1 >> 4);
620 gteG2 = limC2(gteMAC2 >> 4);
621 gteB2 = limC3(gteMAC3 >> 4);
628 void gteNCDS(psxCP2Regs *regs) {
630 GTE_LOG("GTE NCDS\n");
634 gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
635 gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
636 gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
637 gteIR1 = limB1(gteMAC1, 1);
638 gteIR2 = limB2(gteMAC2, 1);
639 gteIR3 = limB3(gteMAC3, 1);
640 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
641 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
642 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
643 gteIR1 = limB1(gteMAC1, 1);
644 gteIR2 = limB2(gteMAC2, 1);
645 gteIR3 = limB3(gteMAC3, 1);
646 gteMAC1 = (((gteR << 4) * gteIR1) + (gteIR0 * limB1(A1U((s64)gteRFC - ((gteR * gteIR1) >> 8)), 0))) >> 12;
647 gteMAC2 = (((gteG << 4) * gteIR2) + (gteIR0 * limB2(A2U((s64)gteGFC - ((gteG * gteIR2) >> 8)), 0))) >> 12;
648 gteMAC3 = (((gteB << 4) * gteIR3) + (gteIR0 * limB3(A3U((s64)gteBFC - ((gteB * gteIR3) >> 8)), 0))) >> 12;
649 gteIR1 = limB1(gteMAC1, 1);
650 gteIR2 = limB2(gteMAC2, 1);
651 gteIR3 = limB3(gteMAC3, 1);
656 gteR2 = limC1(gteMAC1 >> 4);
657 gteG2 = limC2(gteMAC2 >> 4);
658 gteB2 = limC3(gteMAC3 >> 4);
661 void gteNCDT(psxCP2Regs *regs) {
666 GTE_LOG("GTE NCDT\n");
670 for (v = 0; v < 3; v++) {
674 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
675 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
676 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 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;
693 gteR2 = limC1(gteMAC1 >> 4);
694 gteG2 = limC2(gteMAC2 >> 4);
695 gteB2 = limC3(gteMAC3 >> 4);
697 gteIR1 = limB1(gteMAC1, 1);
698 gteIR2 = limB2(gteMAC2, 1);
699 gteIR3 = limB3(gteMAC3, 1);
702 void gteOP(psxCP2Regs *regs) {
703 int shift = 12 * GTE_SF(gteop);
704 int lm = GTE_LM(gteop);
711 gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> shift;
712 gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> shift;
713 gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> shift;
714 gteIR1 = limB1(gteMAC1, lm);
715 gteIR2 = limB2(gteMAC2, lm);
716 gteIR3 = limB3(gteMAC3, lm);
719 void gteDCPL(psxCP2Regs *regs) {
720 int lm = GTE_LM(gteop);
722 s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
723 s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
724 s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
727 GTE_LOG("GTE DCPL\n");
731 gteMAC1 = RIR1 + ((gteIR0 * limB1(A1U((s64)gteRFC - RIR1), 0)) >> 12);
732 gteMAC2 = GIR2 + ((gteIR0 * limB1(A2U((s64)gteGFC - GIR2), 0)) >> 12);
733 gteMAC3 = BIR3 + ((gteIR0 * limB1(A3U((s64)gteBFC - BIR3), 0)) >> 12);
735 gteIR1 = limB1(gteMAC1, lm);
736 gteIR2 = limB2(gteMAC2, lm);
737 gteIR3 = limB3(gteMAC3, lm);
742 gteR2 = limC1(gteMAC1 >> 4);
743 gteG2 = limC2(gteMAC2 >> 4);
744 gteB2 = limC3(gteMAC3 >> 4);
747 void gteGPF(psxCP2Regs *regs) {
748 int shift = 12 * GTE_SF(gteop);
751 GTE_LOG("GTE GPF\n");
755 gteMAC1 = (gteIR0 * gteIR1) >> shift;
756 gteMAC2 = (gteIR0 * gteIR2) >> shift;
757 gteMAC3 = (gteIR0 * gteIR3) >> shift;
758 gteIR1 = limB1(gteMAC1, 0);
759 gteIR2 = limB2(gteMAC2, 0);
760 gteIR3 = limB3(gteMAC3, 0);
765 gteR2 = limC1(gteMAC1 >> 4);
766 gteG2 = limC2(gteMAC2 >> 4);
767 gteB2 = limC3(gteMAC3 >> 4);
770 void gteGPL(psxCP2Regs *regs) {
771 int shift = 12 * GTE_SF(gteop);
774 GTE_LOG("GTE GPL\n");
778 gteMAC1 = A1((((s64)gteMAC1 << shift) + (gteIR0 * gteIR1)) >> shift);
779 gteMAC2 = A2((((s64)gteMAC2 << shift) + (gteIR0 * gteIR2)) >> shift);
780 gteMAC3 = A3((((s64)gteMAC3 << shift) + (gteIR0 * gteIR3)) >> shift);
781 gteIR1 = limB1(gteMAC1, 0);
782 gteIR2 = limB2(gteMAC2, 0);
783 gteIR3 = limB3(gteMAC3, 0);
788 gteR2 = limC1(gteMAC1 >> 4);
789 gteG2 = limC2(gteMAC2 >> 4);
790 gteB2 = limC3(gteMAC3 >> 4);
793 void gteDPCS(psxCP2Regs *regs) {
794 int shift = 12 * GTE_SF(gteop);
797 GTE_LOG("GTE DPCS\n");
801 gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U(((s64)gteRFC - (gteR << 4)) << (12 - shift)), 0))) >> 12;
802 gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U(((s64)gteGFC - (gteG << 4)) << (12 - shift)), 0))) >> 12;
803 gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U(((s64)gteBFC - (gteB << 4)) << (12 - shift)), 0))) >> 12;
805 gteIR1 = limB1(gteMAC1, 0);
806 gteIR2 = limB2(gteMAC2, 0);
807 gteIR3 = limB3(gteMAC3, 0);
811 gteR2 = limC1(gteMAC1 >> 4);
812 gteG2 = limC2(gteMAC2 >> 4);
813 gteB2 = limC3(gteMAC3 >> 4);
816 void gteDPCT(psxCP2Regs *regs) {
820 GTE_LOG("GTE DPCT\n");
824 for (v = 0; v < 3; v++) {
825 gteMAC1 = ((gteR0 << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR0 << 4)), 0))) >> 12;
826 gteMAC2 = ((gteG0 << 16) + (gteIR0 * limB1(A2U((s64)gteGFC - (gteG0 << 4)), 0))) >> 12;
827 gteMAC3 = ((gteB0 << 16) + (gteIR0 * limB1(A3U((s64)gteBFC - (gteB0 << 4)), 0))) >> 12;
832 gteR2 = limC1(gteMAC1 >> 4);
833 gteG2 = limC2(gteMAC2 >> 4);
834 gteB2 = limC3(gteMAC3 >> 4);
836 gteIR1 = limB1(gteMAC1, 0);
837 gteIR2 = limB2(gteMAC2, 0);
838 gteIR3 = limB3(gteMAC3, 0);
841 void gteNCS(psxCP2Regs *regs) {
843 GTE_LOG("GTE NCS\n");
847 gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
848 gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
849 gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
850 gteIR1 = limB1(gteMAC1, 1);
851 gteIR2 = limB2(gteMAC2, 1);
852 gteIR3 = limB3(gteMAC3, 1);
853 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
854 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
855 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
856 gteIR1 = limB1(gteMAC1, 1);
857 gteIR2 = limB2(gteMAC2, 1);
858 gteIR3 = limB3(gteMAC3, 1);
863 gteR2 = limC1(gteMAC1 >> 4);
864 gteG2 = limC2(gteMAC2 >> 4);
865 gteB2 = limC3(gteMAC3 >> 4);
868 void gteNCT(psxCP2Regs *regs) {
873 GTE_LOG("GTE NCT\n");
877 for (v = 0; v < 3; v++) {
881 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
882 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
883 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 12;
884 gteIR1 = limB1(gteMAC1, 1);
885 gteIR2 = limB2(gteMAC2, 1);
886 gteIR3 = limB3(gteMAC3, 1);
887 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
888 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
889 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
893 gteR2 = limC1(gteMAC1 >> 4);
894 gteG2 = limC2(gteMAC2 >> 4);
895 gteB2 = limC3(gteMAC3 >> 4);
897 gteIR1 = limB1(gteMAC1, 1);
898 gteIR2 = limB2(gteMAC2, 1);
899 gteIR3 = limB3(gteMAC3, 1);
902 void gteCC(psxCP2Regs *regs) {
908 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
909 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
910 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
911 gteIR1 = limB1(gteMAC1, 1);
912 gteIR2 = limB2(gteMAC2, 1);
913 gteIR3 = limB3(gteMAC3, 1);
914 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
915 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
916 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
917 gteIR1 = limB1(gteMAC1, 1);
918 gteIR2 = limB2(gteMAC2, 1);
919 gteIR3 = limB3(gteMAC3, 1);
924 gteR2 = limC1(gteMAC1 >> 4);
925 gteG2 = limC2(gteMAC2 >> 4);
926 gteB2 = limC3(gteMAC3 >> 4);
929 void gteINTPL(psxCP2Regs *regs) {
930 int shift = 12 * GTE_SF(gteop);
931 int lm = GTE_LM(gteop);
934 GTE_LOG("GTE INTPL\n");
938 gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0))) >> shift;
939 gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0))) >> shift;
940 gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0))) >> shift;
941 gteIR1 = limB1(gteMAC1, lm);
942 gteIR2 = limB2(gteMAC2, lm);
943 gteIR3 = limB3(gteMAC3, lm);
947 gteR2 = limC1(gteMAC1 >> 4);
948 gteG2 = limC2(gteMAC2 >> 4);
949 gteB2 = limC3(gteMAC3 >> 4);
952 void gteCDP(psxCP2Regs *regs) {
954 GTE_LOG("GTE CDP\n");
958 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
959 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
960 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
961 gteIR1 = limB1(gteMAC1, 1);
962 gteIR2 = limB2(gteMAC2, 1);
963 gteIR3 = limB3(gteMAC3, 1);
964 gteMAC1 = (((gteR << 4) * gteIR1) + (gteIR0 * limB1(A1U((s64)gteRFC - ((gteR * gteIR1) >> 8)), 0))) >> 12;
965 gteMAC2 = (((gteG << 4) * gteIR2) + (gteIR0 * limB2(A2U((s64)gteGFC - ((gteG * gteIR2) >> 8)), 0))) >> 12;
966 gteMAC3 = (((gteB << 4) * gteIR3) + (gteIR0 * limB3(A3U((s64)gteBFC - ((gteB * gteIR3) >> 8)), 0))) >> 12;
967 gteIR1 = limB1(gteMAC1, 1);
968 gteIR2 = limB2(gteMAC2, 1);
969 gteIR3 = limB3(gteMAC3, 1);
974 gteR2 = limC1(gteMAC1 >> 4);
975 gteG2 = limC2(gteMAC2 >> 4);
976 gteB2 = limC3(gteMAC3 >> 4);
979 /* decomposed/parametrized versions for the recompiler */
983 void gteSQR_part_noshift(psxCP2Regs *regs) {
986 gteMAC1 = gteIR1 * gteIR1;
987 gteMAC2 = gteIR2 * gteIR2;
988 gteMAC3 = gteIR3 * gteIR3;
991 void gteSQR_part_shift(psxCP2Regs *regs) {
994 gteMAC1 = (gteIR1 * gteIR1) >> 12;
995 gteMAC2 = (gteIR2 * gteIR2) >> 12;
996 gteMAC3 = (gteIR3 * gteIR3) >> 12;
999 void gteOP_part_noshift(psxCP2Regs *regs) {
1002 gteMAC1 = (gteR22 * gteIR3) - (gteR33 * gteIR2);
1003 gteMAC2 = (gteR33 * gteIR1) - (gteR11 * gteIR3);
1004 gteMAC3 = (gteR11 * gteIR2) - (gteR22 * gteIR1);
1007 void gteOP_part_shift(psxCP2Regs *regs) {
1010 gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> 12;
1011 gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> 12;
1012 gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> 12;
1015 void gteDCPL_part(psxCP2Regs *regs) {
1016 s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
1017 s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
1018 s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
1022 gteMAC1 = RIR1 + ((gteIR0 * limB1(A1U((s64)gteRFC - RIR1), 0)) >> 12);
1023 gteMAC2 = GIR2 + ((gteIR0 * limB1(A2U((s64)gteGFC - GIR2), 0)) >> 12);
1024 gteMAC3 = BIR3 + ((gteIR0 * limB1(A3U((s64)gteBFC - BIR3), 0)) >> 12);
1027 void gteGPF_part_noshift(psxCP2Regs *regs) {
1030 gteMAC1 = gteIR0 * gteIR1;
1031 gteMAC2 = gteIR0 * gteIR2;
1032 gteMAC3 = gteIR0 * gteIR3;
1035 void gteGPF_part_shift(psxCP2Regs *regs) {
1038 gteMAC1 = (gteIR0 * gteIR1) >> 12;
1039 gteMAC2 = (gteIR0 * gteIR2) >> 12;
1040 gteMAC3 = (gteIR0 * gteIR3) >> 12;
1045 void gteGPL_part_noshift(psxCP2Regs *regs) {
1048 gteMAC1 = A1((s64)gteMAC1 + (gteIR0 * gteIR1));
1049 gteMAC2 = A2((s64)gteMAC2 + (gteIR0 * gteIR2));
1050 gteMAC3 = A3((s64)gteMAC3 + (gteIR0 * gteIR3));
1053 void gteGPL_part_shift(psxCP2Regs *regs) {
1056 gteMAC1 = A1((s64)gteMAC1 + ((gteIR0 * gteIR1) >> 12));
1057 gteMAC2 = A2((s64)gteMAC2 + ((gteIR0 * gteIR2) >> 12));
1058 gteMAC3 = A3((s64)gteMAC3 + ((gteIR0 * gteIR3) >> 12));
1061 void gteDPCS_part_noshift(psxCP2Regs *regs) {
1066 gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR << 4)) << (12 - shift), 0))) >> 12;
1067 gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U((s64)gteGFC - (gteG << 4)) << (12 - shift), 0))) >> 12;
1068 gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U((s64)gteBFC - (gteB << 4)) << (12 - shift), 0))) >> 12;
1071 void gteDPCS_part_shift(psxCP2Regs *regs) {
1076 gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR << 4)) << (12 - shift), 0))) >> 12;
1077 gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U((s64)gteGFC - (gteG << 4)) << (12 - shift), 0))) >> 12;
1078 gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U((s64)gteBFC - (gteB << 4)) << (12 - shift), 0))) >> 12;
1081 void gteINTPL_part_noshift(psxCP2Regs *regs) {
1084 gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0)));
1085 gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0)));
1086 gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0)));
1089 void gteINTPL_part_shift(psxCP2Regs *regs) {
1092 gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0))) >> 12;
1093 gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0))) >> 12;
1094 gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0))) >> 12;
1097 void gteMACtoRGB(psxCP2Regs *regs) {
1101 gteR2 = limC1(gteMAC1 >> 4);
1102 gteG2 = limC2(gteMAC2 >> 4);
1103 gteB2 = limC3(gteMAC3 >> 4);