notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
cdrom: change pause timing again
[pcsx_rearmed.git] / libpcsxcore / gte.c
CommitLineData
ef79bbde
P		 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
f74fb727 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])
b7159e1a 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.
3d08b9fe 157//#define gteH (regs->CP2C.p[26].sw.l)
158#define gteH (regs->CP2C.p[26].w.l)
f74fb727 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])
ef79bbde
P		 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
59774ed0 177#ifndef FLAGLESS
178
669fed93 179static inline s64 BOUNDS_(psxCP2Regs *regs, s64 n_value, s64 n_max, int n_maxflag, s64 n_min, int n_minflag) {
ef79bbde
P		 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
f74fb727 188static inline s32 LIM_(psxCP2Regs *regs, s32 value, s32 max, s32 min, u32 flag) {
ef79bbde
P		 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
f74fb727 200static inline u32 limE_(psxCP2Regs *regs, u32 result) {
59774ed0 201 if (result > 0x1ffff) {
202 gteFLAG |= (1 << 31) | (1 << 17);
203 return 0x1ffff;
204 }
205 return result;
206}
207
208#else
209
f74fb727 210#define BOUNDS_(regs, a, ...) (a)
59774ed0 211
f74fb727 212static inline s32 LIM_(psxCP2Regs *regs, s32 value, s32 max, s32 min, u32 flag_unused) {
59774ed0 213 s32 ret = value;
214 if (value > max)
215 ret = max;
216 else if (value < min)
217 ret = min;
218 return ret;
219}
220
f74fb727 221static inline u32 limE_(psxCP2Regs *regs, u32 result) {
bedfea38 222 if (result > 0x1ffff)
223 return 0x1ffff;
224 return result;
225}
59774ed0 226
227#endif
228
f74fb727 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
ef79bbde
P		 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
ef79bbde
P		 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))
7384197d 250#define limH(a) LIM((a), 0x1000, 0x0000, (1 << 12))
ef79bbde 251
6c6c9590 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
b7159e1a 263
264//senquack - n param should be unsigned (will be 'gteH' reg which is u16)
265#ifdef GTE_USE_NATIVE_DIVIDE
266INLINE u32 DIVIDE(u16 n, u16 d) {
267 if (n < d * 2) {
268 return ((u32)n << 16) / d;
269 }
270 return 0xffffffff;
271}
272#else
ef79bbde 273#include "gte_divider.h"
b7159e1a 274#endif // GTE_USE_NATIVE_DIVIDE
ef79bbde 275
59774ed0 276#ifndef FLAGLESS
277
32631e6a 278const unsigned char gte_cycletab[64] = {
81dbbf4c 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
287int 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
300void gteCheckStall(u32 op) {
301 gteCheckStallRaw(gte_cycletab[op], &psxRegs);
302}
303
4cc373dd 304u32 MFC2(struct psxCP2Regs *regs, int reg) {
ef79bbde
P		 305 switch (reg) {
306 case 1:
307 case 3:
308 case 5:
309 case 8:
310 case 9:
311 case 10:
312 case 11:
4cc373dd 313 regs->CP2D.r[reg] = (s32)regs->CP2D.p[reg].sw.l;
ef79bbde
P		 314 break;
315
316 case 7:
317 case 16:
318 case 17:
319 case 18:
320 case 19:
4cc373dd 321 regs->CP2D.r[reg] = (u32)regs->CP2D.p[reg].w.l;
ef79bbde
P		 322 break;
323
324 case 15:
4cc373dd 325 regs->CP2D.r[reg] = gteSXY2;
ef79bbde
P		 326 break;
327
328 case 28:
ef79bbde 329 case 29:
4cc373dd 330 regs->CP2D.r[reg] = LIM(gteIR1 >> 7, 0x1f, 0, 0) |
ef79bbde
P		 331 (LIM(gteIR2 >> 7, 0x1f, 0, 0) << 5) |
332 (LIM(gteIR3 >> 7, 0x1f, 0, 0) << 10);
333 break;
334 }
4cc373dd 335 return regs->CP2D.r[reg];
ef79bbde
P		 336}
337
4cc373dd 338void MTC2(struct psxCP2Regs *regs, u32 value, int reg) {
ef79bbde
P		 339 switch (reg) {
340 case 15:
341 gteSXY0 = gteSXY1;
342 gteSXY1 = gteSXY2;
343 gteSXY2 = value;
344 gteSXYP = value;
345 break;
346
347 case 28:
348 gteIRGB = value;
3968e69e 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;
ef79bbde
P		 353 break;
354
355 case 30:
356 {
357 int a;
358 gteLZCS = value;
359
360 a = gteLZCS;
361 if (a > 0) {
362 int i;
363 for (i = 31; (a & (1 << i)) == 0 && i >= 0; i--);
364 gteLZCR = 31 - i;
365 } else if (a < 0) {
366 int i;
367 a ^= 0xffffffff;
368 for (i = 31; (a & (1 << i)) == 0 && i >= 0; i--);
369 gteLZCR = 31 - i;
370 } else {
371 gteLZCR = 32;
372 }
373 }
374 break;
375
ef79bbde
P		 376 case 31:
377 return;
378
379 default:
4cc373dd 380 regs->CP2D.r[reg] = value;
ef79bbde
P		 381 }
382}
383
4cc373dd 384void CTC2(struct psxCP2Regs *regs, u32 value, int reg) {
ef79bbde
P		 385 switch (reg) {
386 case 4:
387 case 12:
388 case 20:
389 case 26:
390 case 27:
391 case 29:
392 case 30:
393 value = (s32)(s16)value;
394 break;
395
396 case 31:
397 value = value & 0x7ffff000;
398 if (value & 0x7f87e000) value |= 0x80000000;
399 break;
400 }
401
4cc373dd 402 regs->CP2C.r[reg] = value;
32631e6a 403}
404
59774ed0 405#endif // FLAGLESS
406
3ebefe71 407#if 0
a2544c92 408#define DIVIDE DIVIDE_
409static u32 DIVIDE_(s16 n, u16 d) {
410 if (n >= 0 && n < d * 2) {
411 s32 n_ = n;
412 return ((n_ << 16) + d / 2) / d;
413 //return (u32)((float)(n_ << 16) / (float)d + (float)0.5);
414 }
415 return 0xffffffff;
416}
3ebefe71 417#endif
a2544c92 418
f74fb727 419void gteRTPS(psxCP2Regs *regs) {
ef79bbde 420 int quotient;
8cb04d22 421 s64 tmp;
ef79bbde
P		 422
423#ifdef GTE_LOG
424 GTE_LOG("GTE RTPS\n");
425#endif
426 gteFLAG = 0;
427
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);
434 gteSZ0 = gteSZ1;
435 gteSZ1 = gteSZ2;
436 gteSZ2 = gteSZ3;
437 gteSZ3 = limD(gteMAC3);
438 quotient = limE(DIVIDE(gteH, gteSZ3));
439 gteSXY0 = gteSXY1;
440 gteSXY1 = gteSXY2;
441 gteSX2 = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
442 gteSY2 = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
443
8cb04d22 444 tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
445 gteMAC0 = F(tmp);
446 gteIR0 = limH(tmp >> 12);
ef79bbde
P		 447}
448
f74fb727 449void gteRTPT(psxCP2Regs *regs) {
ef79bbde
P		 450 int quotient;
451 int v;
452 s32 vx, vy, vz;
8cb04d22 453 s64 tmp;
ef79bbde
P		 454
455#ifdef GTE_LOG
456 GTE_LOG("GTE RTPT\n");
457#endif
458 gteFLAG = 0;
459
460 gteSZ0 = gteSZ3;
461 for (v = 0; v < 3; v++) {
462 vx = VX(v);
463 vy = VY(v);
464 vz = VZ(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);
475 }
8cb04d22 476
477 tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
478 gteMAC0 = F(tmp);
479 gteIR0 = limH(tmp >> 12);
ef79bbde
P		 480}
481
f74fb727 482void gteMVMVA(psxCP2Regs *regs) {
ef79bbde
P		 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);
488 s32 vx = VX(v);
489 s32 vy = VY(v);
490 s32 vz = VZ(v);
491
492#ifdef GTE_LOG
493 GTE_LOG("GTE MVMVA\n");
494#endif
495 gteFLAG = 0;
496
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);
500
501 gteIR1 = limB1(gteMAC1, lm);
502 gteIR2 = limB2(gteMAC2, lm);
503 gteIR3 = limB3(gteMAC3, lm);
504}
505
f74fb727 506void gteNCLIP(psxCP2Regs *regs) {
ef79bbde
P		 507#ifdef GTE_LOG
508 GTE_LOG("GTE NCLIP\n");
509#endif
510 gteFLAG = 0;
511
512 gteMAC0 = F((s64)gteSX0 * (gteSY1 - gteSY2) +
513 gteSX1 * (gteSY2 - gteSY0) +
514 gteSX2 * (gteSY0 - gteSY1));
515}
516
f74fb727 517void gteAVSZ3(psxCP2Regs *regs) {
ef79bbde
P		 518#ifdef GTE_LOG
519 GTE_LOG("GTE AVSZ3\n");
520#endif
521 gteFLAG = 0;
522
b3254af9 523 gteMAC0 = F((s64)gteZSF3 * (gteSZ1 + gteSZ2 + gteSZ3));
ef79bbde
P		 524 gteOTZ = limD(gteMAC0 >> 12);
525}
526
f74fb727 527void gteAVSZ4(psxCP2Regs *regs) {
ef79bbde
P		 528#ifdef GTE_LOG
529 GTE_LOG("GTE AVSZ4\n");
530#endif
531 gteFLAG = 0;
532
b3254af9 533 gteMAC0 = F((s64)gteZSF4 * (gteSZ0 + gteSZ1 + gteSZ2 + gteSZ3));
ef79bbde
P		 534 gteOTZ = limD(gteMAC0 >> 12);
535}
536
f74fb727 537void gteSQR(psxCP2Regs *regs) {
ef79bbde
P		 538 int shift = 12 * GTE_SF(gteop);
539 int lm = GTE_LM(gteop);
540
541#ifdef GTE_LOG
542 GTE_LOG("GTE SQR\n");
543#endif
544 gteFLAG = 0;
545
b3254af9 546 gteMAC1 = (gteIR1 * gteIR1) >> shift;
547 gteMAC2 = (gteIR2 * gteIR2) >> shift;
548 gteMAC3 = (gteIR3 * gteIR3) >> shift;
7384197d 549 gteIR1 = limB1(gteMAC1, lm);
550 gteIR2 = limB2(gteMAC2, lm);
551 gteIR3 = limB3(gteMAC3, lm);
ef79bbde
P		 552}
553
f74fb727 554void gteNCCS(psxCP2Regs *regs) {
ef79bbde
P		 555#ifdef GTE_LOG
556 GTE_LOG("GTE NCCS\n");
557#endif
558 gteFLAG = 0;
559
b3254af9 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;
ef79bbde
P		 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);
b3254af9 572 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
573 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
574 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
575 gteIR1 = gteMAC1;
576 gteIR2 = gteMAC2;
577 gteIR3 = gteMAC3;
ef79bbde
P		 578
579 gteRGB0 = gteRGB1;
580 gteRGB1 = gteRGB2;
581 gteCODE2 = gteCODE;
582 gteR2 = limC1(gteMAC1 >> 4);
583 gteG2 = limC2(gteMAC2 >> 4);
584 gteB2 = limC3(gteMAC3 >> 4);
585}
586
f74fb727 587void gteNCCT(psxCP2Regs *regs) {
ef79bbde
P		 588 int v;
589 s32 vx, vy, vz;
590
591#ifdef GTE_LOG
592 GTE_LOG("GTE NCCT\n");
593#endif
594 gteFLAG = 0;
595
596 for (v = 0; v < 3; v++) {
597 vx = VX(v);
598 vy = VY(v);
599 vz = VZ(v);
b3254af9 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;
ef79bbde
P		 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);
b3254af9 612 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
613 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
614 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
ef79bbde
P		 615
616 gteRGB0 = gteRGB1;
617 gteRGB1 = gteRGB2;
618 gteCODE2 = gteCODE;
619 gteR2 = limC1(gteMAC1 >> 4);
620 gteG2 = limC2(gteMAC2 >> 4);
621 gteB2 = limC3(gteMAC3 >> 4);
622 }
b3254af9 623 gteIR1 = gteMAC1;
624 gteIR2 = gteMAC2;
625 gteIR3 = gteMAC3;
ef79bbde
P		 626}
627
f74fb727 628void gteNCDS(psxCP2Regs *regs) {
ef79bbde
P		 629#ifdef GTE_LOG
630 GTE_LOG("GTE NCDS\n");
631#endif
632 gteFLAG = 0;
633
b3254af9 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;
ef79bbde
P		 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);
6c6c9590 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;
ef79bbde
P		 649 gteIR1 = limB1(gteMAC1, 1);
650 gteIR2 = limB2(gteMAC2, 1);
651 gteIR3 = limB3(gteMAC3, 1);
652
653 gteRGB0 = gteRGB1;
654 gteRGB1 = gteRGB2;
655 gteCODE2 = gteCODE;
656 gteR2 = limC1(gteMAC1 >> 4);
657 gteG2 = limC2(gteMAC2 >> 4);
658 gteB2 = limC3(gteMAC3 >> 4);
659}
660
f74fb727 661void gteNCDT(psxCP2Regs *regs) {
ef79bbde
P		 662 int v;
663 s32 vx, vy, vz;
664
665#ifdef GTE_LOG
666 GTE_LOG("GTE NCDT\n");
667#endif
668 gteFLAG = 0;
669
670 for (v = 0; v < 3; v++) {
671 vx = VX(v);
672 vy = VY(v);
673 vz = VZ(v);
b3254af9 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;
ef79bbde
P		 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);
6c6c9590 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;
ef79bbde
P		 689
690 gteRGB0 = gteRGB1;
691 gteRGB1 = gteRGB2;
692 gteCODE2 = gteCODE;
693 gteR2 = limC1(gteMAC1 >> 4);
694 gteG2 = limC2(gteMAC2 >> 4);
695 gteB2 = limC3(gteMAC3 >> 4);
696 }
697 gteIR1 = limB1(gteMAC1, 1);
698 gteIR2 = limB2(gteMAC2, 1);
699 gteIR3 = limB3(gteMAC3, 1);
700}
701
f74fb727 702void gteOP(psxCP2Regs *regs) {
ef79bbde
P		 703 int shift = 12 * GTE_SF(gteop);
704 int lm = GTE_LM(gteop);
705
706#ifdef GTE_LOG
707 GTE_LOG("GTE OP\n");
708#endif
709 gteFLAG = 0;
710
b3254af9 711 gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> shift;
712 gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> shift;
713 gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> shift;
ef79bbde
P		 714 gteIR1 = limB1(gteMAC1, lm);
715 gteIR2 = limB2(gteMAC2, lm);
716 gteIR3 = limB3(gteMAC3, lm);
717}
718
f74fb727 719void gteDCPL(psxCP2Regs *regs) {
ef79bbde
P		 720 int lm = GTE_LM(gteop);
721
b3254af9 722 s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
723 s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
724 s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
ef79bbde
P		 725
726#ifdef GTE_LOG
727 GTE_LOG("GTE DCPL\n");
728#endif
729 gteFLAG = 0;
730
6c6c9590 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);
ef79bbde
P		 734
735 gteIR1 = limB1(gteMAC1, lm);
736 gteIR2 = limB2(gteMAC2, lm);
737 gteIR3 = limB3(gteMAC3, lm);
738
739 gteRGB0 = gteRGB1;
740 gteRGB1 = gteRGB2;
741 gteCODE2 = gteCODE;
742 gteR2 = limC1(gteMAC1 >> 4);
743 gteG2 = limC2(gteMAC2 >> 4);
744 gteB2 = limC3(gteMAC3 >> 4);
745}
746
f74fb727 747void gteGPF(psxCP2Regs *regs) {
ef79bbde
P		 748 int shift = 12 * GTE_SF(gteop);
749
750#ifdef GTE_LOG
751 GTE_LOG("GTE GPF\n");
752#endif
753 gteFLAG = 0;
754
b3254af9 755 gteMAC1 = (gteIR0 * gteIR1) >> shift;
756 gteMAC2 = (gteIR0 * gteIR2) >> shift;
757 gteMAC3 = (gteIR0 * gteIR3) >> shift;
ef79bbde
P		 758 gteIR1 = limB1(gteMAC1, 0);
759 gteIR2 = limB2(gteMAC2, 0);
760 gteIR3 = limB3(gteMAC3, 0);
761
762 gteRGB0 = gteRGB1;
763 gteRGB1 = gteRGB2;
764 gteCODE2 = gteCODE;
765 gteR2 = limC1(gteMAC1 >> 4);
766 gteG2 = limC2(gteMAC2 >> 4);
767 gteB2 = limC3(gteMAC3 >> 4);
768}
769
f74fb727 770void gteGPL(psxCP2Regs *regs) {
ef79bbde
P		 771 int shift = 12 * GTE_SF(gteop);
772
773#ifdef GTE_LOG
774 GTE_LOG("GTE GPL\n");
775#endif
776 gteFLAG = 0;
777
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);
784
785 gteRGB0 = gteRGB1;
786 gteRGB1 = gteRGB2;
787 gteCODE2 = gteCODE;
788 gteR2 = limC1(gteMAC1 >> 4);
789 gteG2 = limC2(gteMAC2 >> 4);
790 gteB2 = limC3(gteMAC3 >> 4);
791}
792
f74fb727 793void gteDPCS(psxCP2Regs *regs) {
ef79bbde
P		 794 int shift = 12 * GTE_SF(gteop);
795
796#ifdef GTE_LOG
797 GTE_LOG("GTE DPCS\n");
798#endif
799 gteFLAG = 0;
800
6c6c9590 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;
ef79bbde
P		 804
805 gteIR1 = limB1(gteMAC1, 0);
806 gteIR2 = limB2(gteMAC2, 0);
807 gteIR3 = limB3(gteMAC3, 0);
808 gteRGB0 = gteRGB1;
809 gteRGB1 = gteRGB2;
810 gteCODE2 = gteCODE;
811 gteR2 = limC1(gteMAC1 >> 4);
812 gteG2 = limC2(gteMAC2 >> 4);
813 gteB2 = limC3(gteMAC3 >> 4);
814}
815
f74fb727 816void gteDPCT(psxCP2Regs *regs) {
ef79bbde
P		 817 int v;
818
819#ifdef GTE_LOG
820 GTE_LOG("GTE DPCT\n");
821#endif
822 gteFLAG = 0;
823
824 for (v = 0; v < 3; v++) {
6c6c9590 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;
ef79bbde
P		 828
829 gteRGB0 = gteRGB1;
830 gteRGB1 = gteRGB2;
831 gteCODE2 = gteCODE;
832 gteR2 = limC1(gteMAC1 >> 4);
833 gteG2 = limC2(gteMAC2 >> 4);
834 gteB2 = limC3(gteMAC3 >> 4);
835 }
836 gteIR1 = limB1(gteMAC1, 0);
837 gteIR2 = limB2(gteMAC2, 0);
838 gteIR3 = limB3(gteMAC3, 0);
839}
840
f74fb727 841void gteNCS(psxCP2Regs *regs) {
ef79bbde
P		 842#ifdef GTE_LOG
843 GTE_LOG("GTE NCS\n");
844#endif
845 gteFLAG = 0;
846
b3254af9 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;
ef79bbde
P		 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);
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
f74fb727 868void gteNCT(psxCP2Regs *regs) {
ef79bbde
P		 869 int v;
870 s32 vx, vy, vz;
871
872#ifdef GTE_LOG
873 GTE_LOG("GTE NCT\n");
874#endif
875 gteFLAG = 0;
876
877 for (v = 0; v < 3; v++) {
878 vx = VX(v);
879 vy = VY(v);
880 vz = VZ(v);
b3254af9 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;
ef79bbde
P		 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);
890 gteRGB0 = gteRGB1;
891 gteRGB1 = gteRGB2;
892 gteCODE2 = gteCODE;
893 gteR2 = limC1(gteMAC1 >> 4);
894 gteG2 = limC2(gteMAC2 >> 4);
895 gteB2 = limC3(gteMAC3 >> 4);
896 }
897 gteIR1 = limB1(gteMAC1, 1);
898 gteIR2 = limB2(gteMAC2, 1);
899 gteIR3 = limB3(gteMAC3, 1);
900}
901
f74fb727 902void gteCC(psxCP2Regs *regs) {
ef79bbde
P		 903#ifdef GTE_LOG
904 GTE_LOG("GTE CC\n");
905#endif
906 gteFLAG = 0;
907
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);
b3254af9 914 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
915 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
916 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
ef79bbde
P		 917 gteIR1 = limB1(gteMAC1, 1);
918 gteIR2 = limB2(gteMAC2, 1);
919 gteIR3 = limB3(gteMAC3, 1);
920
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
f74fb727 929void gteINTPL(psxCP2Regs *regs) {
ef79bbde
P		 930 int shift = 12 * GTE_SF(gteop);
931 int lm = GTE_LM(gteop);
932
933#ifdef GTE_LOG
934 GTE_LOG("GTE INTPL\n");
935#endif
936 gteFLAG = 0;
937
6c6c9590 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;
ef79bbde
P		 941 gteIR1 = limB1(gteMAC1, lm);
942 gteIR2 = limB2(gteMAC2, lm);
943 gteIR3 = limB3(gteMAC3, lm);
944 gteRGB0 = gteRGB1;
945 gteRGB1 = gteRGB2;
946 gteCODE2 = gteCODE;
947 gteR2 = limC1(gteMAC1 >> 4);
948 gteG2 = limC2(gteMAC2 >> 4);
949 gteB2 = limC3(gteMAC3 >> 4);
950}
951
f74fb727 952void gteCDP(psxCP2Regs *regs) {
ef79bbde
P		 953#ifdef GTE_LOG
954 GTE_LOG("GTE CDP\n");
955#endif
956 gteFLAG = 0;
957
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);
6c6c9590 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;
ef79bbde
P		 967 gteIR1 = limB1(gteMAC1, 1);
968 gteIR2 = limB2(gteMAC2, 1);
969 gteIR3 = limB3(gteMAC3, 1);
970
971 gteRGB0 = gteRGB1;
972 gteRGB1 = gteRGB2;
973 gteCODE2 = gteCODE;
974 gteR2 = limC1(gteMAC1 >> 4);
975 gteG2 = limC2(gteMAC2 >> 4);
976 gteB2 = limC3(gteMAC3 >> 4);
977}
6c0eefaf 978
979/* decomposed/parametrized versions for the recompiler */
980
981#ifndef FLAGLESS
982
983void gteSQR_part_noshift(psxCP2Regs *regs) {
984 gteFLAG = 0;
985
986 gteMAC1 = gteIR1 * gteIR1;
987 gteMAC2 = gteIR2 * gteIR2;
988 gteMAC3 = gteIR3 * gteIR3;
989}
990
991void gteSQR_part_shift(psxCP2Regs *regs) {
992 gteFLAG = 0;
993
994 gteMAC1 = (gteIR1 * gteIR1) >> 12;
995 gteMAC2 = (gteIR2 * gteIR2) >> 12;
996 gteMAC3 = (gteIR3 * gteIR3) >> 12;
997}
998
999void gteOP_part_noshift(psxCP2Regs *regs) {
1000 gteFLAG = 0;
1001
1002 gteMAC1 = (gteR22 * gteIR3) - (gteR33 * gteIR2);
1003 gteMAC2 = (gteR33 * gteIR1) - (gteR11 * gteIR3);
1004 gteMAC3 = (gteR11 * gteIR2) - (gteR22 * gteIR1);
1005}
1006
1007void gteOP_part_shift(psxCP2Regs *regs) {
1008 gteFLAG = 0;
1009
1010 gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> 12;
1011 gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> 12;
1012 gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> 12;
1013}
1014
1015void 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;
1019
1020 gteFLAG = 0;
1021
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);
1025}
1026
1027void gteGPF_part_noshift(psxCP2Regs *regs) {
1028 gteFLAG = 0;
1029
1030 gteMAC1 = gteIR0 * gteIR1;
1031 gteMAC2 = gteIR0 * gteIR2;
1032 gteMAC3 = gteIR0 * gteIR3;
1033}
1034
1035void gteGPF_part_shift(psxCP2Regs *regs) {
1036 gteFLAG = 0;
1037
1038 gteMAC1 = (gteIR0 * gteIR1) >> 12;
1039 gteMAC2 = (gteIR0 * gteIR2) >> 12;
1040 gteMAC3 = (gteIR0 * gteIR3) >> 12;
1041}
1042
1043#endif // !FLAGLESS
1044
1045void gteGPL_part_noshift(psxCP2Regs *regs) {
1046 gteFLAG = 0;
1047
1048 gteMAC1 = A1((s64)gteMAC1 + (gteIR0 * gteIR1));
1049 gteMAC2 = A2((s64)gteMAC2 + (gteIR0 * gteIR2));
1050 gteMAC3 = A3((s64)gteMAC3 + (gteIR0 * gteIR3));
1051}
1052
1053void gteGPL_part_shift(psxCP2Regs *regs) {
1054 gteFLAG = 0;
1055
1056 gteMAC1 = A1((s64)gteMAC1 + ((gteIR0 * gteIR1) >> 12));
1057 gteMAC2 = A2((s64)gteMAC2 + ((gteIR0 * gteIR2) >> 12));
1058 gteMAC3 = A3((s64)gteMAC3 + ((gteIR0 * gteIR3) >> 12));
1059}
1060
1061void gteDPCS_part_noshift(psxCP2Regs *regs) {
1062 int shift = 0;
1063
1064 gteFLAG = 0;
1065
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;
1069}
1070
1071void gteDPCS_part_shift(psxCP2Regs *regs) {
1072 int shift = 12;
1073
1074 gteFLAG = 0;
1075
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;
1079}
1080
1081void gteINTPL_part_noshift(psxCP2Regs *regs) {
1082 gteFLAG = 0;
1083
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)));
1087}
1088
1089void gteINTPL_part_shift(psxCP2Regs *regs) {
1090 gteFLAG = 0;
1091
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;
1095}
1096
1097void gteMACtoRGB(psxCP2Regs *regs) {
1098 gteRGB0 = gteRGB1;
1099 gteRGB1 = gteRGB2;
1100 gteCODE2 = gteCODE;
1101 gteR2 = limC1(gteMAC1 >> 4);
1102 gteG2 = limC2(gteMAC2 >> 4);
1103 gteB2 = limC3(gteMAC3 >> 4);
1104}
1105
ARM optimized PCSX fork