notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drc/gte: add some stall handling
[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.
157//#define gteH (psxRegs.CP2C.p[26].sw.l)
158#define gteH (psxRegs.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
81dbbf4c 278const char gte_cycletab[64] = {
279 /* 1 2 3 4 5 6 7 8 9 a b c d e f */
280 0, 15, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 6, 0, 0, 0,
281 8, 8, 8, 19, 13, 0, 44, 0, 0, 0, 0, 17, 11, 0, 14, 0,
282 30, 0, 0, 0, 0, 0, 0, 0, 5, 8, 17, 0, 0, 5, 6, 0,
283 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 39,
284};
285
286// warning: called by the dynarec
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
ef79bbde 304static inline u32 MFC2(int reg) {
eac38522 305 psxCP2Regs *regs = &psxRegs.CP2;
ef79bbde
P		 306 switch (reg) {
307 case 1:
308 case 3:
309 case 5:
310 case 8:
311 case 9:
312 case 10:
313 case 11:
314 psxRegs.CP2D.r[reg] = (s32)psxRegs.CP2D.p[reg].sw.l;
315 break;
316
317 case 7:
318 case 16:
319 case 17:
320 case 18:
321 case 19:
322 psxRegs.CP2D.r[reg] = (u32)psxRegs.CP2D.p[reg].w.l;
323 break;
324
325 case 15:
326 psxRegs.CP2D.r[reg] = gteSXY2;
327 break;
328
329 case 28:
ef79bbde
P		 330 case 29:
331 psxRegs.CP2D.r[reg] = LIM(gteIR1 >> 7, 0x1f, 0, 0) |
332 (LIM(gteIR2 >> 7, 0x1f, 0, 0) << 5) |
333 (LIM(gteIR3 >> 7, 0x1f, 0, 0) << 10);
334 break;
335 }
336 return psxRegs.CP2D.r[reg];
337}
338
339static inline void MTC2(u32 value, int reg) {
eac38522 340 psxCP2Regs *regs = &psxRegs.CP2;
ef79bbde
P		 341 switch (reg) {
342 case 15:
343 gteSXY0 = gteSXY1;
344 gteSXY1 = gteSXY2;
345 gteSXY2 = value;
346 gteSXYP = value;
347 break;
348
349 case 28:
350 gteIRGB = value;
3968e69e 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;
ef79bbde
P		 355 break;
356
357 case 30:
358 {
359 int a;
360 gteLZCS = value;
361
362 a = gteLZCS;
363 if (a > 0) {
364 int i;
365 for (i = 31; (a & (1 << i)) == 0 && i >= 0; i--);
366 gteLZCR = 31 - i;
367 } else if (a < 0) {
368 int i;
369 a ^= 0xffffffff;
370 for (i = 31; (a & (1 << i)) == 0 && i >= 0; i--);
371 gteLZCR = 31 - i;
372 } else {
373 gteLZCR = 32;
374 }
375 }
376 break;
377
ef79bbde
P		 378 case 31:
379 return;
380
381 default:
382 psxRegs.CP2D.r[reg] = value;
383 }
384}
385
386static inline void CTC2(u32 value, int reg) {
387 switch (reg) {
388 case 4:
389 case 12:
390 case 20:
391 case 26:
392 case 27:
393 case 29:
394 case 30:
395 value = (s32)(s16)value;
396 break;
397
398 case 31:
399 value = value & 0x7ffff000;
400 if (value & 0x7f87e000) value |= 0x80000000;
401 break;
402 }
403
404 psxRegs.CP2C.r[reg] = value;
405}
406
407void gteMFC2() {
408 if (!_Rt_) return;
409 psxRegs.GPR.r[_Rt_] = MFC2(_Rd_);
410}
411
412void gteCFC2() {
413 if (!_Rt_) return;
414 psxRegs.GPR.r[_Rt_] = psxRegs.CP2C.r[_Rd_];
415}
416
417void gteMTC2() {
418 MTC2(psxRegs.GPR.r[_Rt_], _Rd_);
419}
420
421void gteCTC2() {
422 CTC2(psxRegs.GPR.r[_Rt_], _Rd_);
423}
424
425#define _oB_ (psxRegs.GPR.r[_Rs_] + _Imm_)
426
427void gteLWC2() {
428 MTC2(psxMemRead32(_oB_), _Rt_);
429}
430
431void gteSWC2() {
81dbbf4c 432 gteCheckStall(0);
ef79bbde
P		 433 psxMemWrite32(_oB_, MFC2(_Rt_));
434}
435
59774ed0 436#endif // FLAGLESS
437
3ebefe71 438#if 0
a2544c92 439#define DIVIDE DIVIDE_
440static u32 DIVIDE_(s16 n, u16 d) {
441 if (n >= 0 && n < d * 2) {
442 s32 n_ = n;
443 return ((n_ << 16) + d / 2) / d;
444 //return (u32)((float)(n_ << 16) / (float)d + (float)0.5);
445 }
446 return 0xffffffff;
447}
3ebefe71 448#endif
a2544c92 449
f74fb727 450void gteRTPS(psxCP2Regs *regs) {
ef79bbde 451 int quotient;
8cb04d22 452 s64 tmp;
ef79bbde
P		 453
454#ifdef GTE_LOG
455 GTE_LOG("GTE RTPS\n");
456#endif
457 gteFLAG = 0;
458
459 gteMAC1 = A1((((s64)gteTRX << 12) + (gteR11 * gteVX0) + (gteR12 * gteVY0) + (gteR13 * gteVZ0)) >> 12);
460 gteMAC2 = A2((((s64)gteTRY << 12) + (gteR21 * gteVX0) + (gteR22 * gteVY0) + (gteR23 * gteVZ0)) >> 12);
461 gteMAC3 = A3((((s64)gteTRZ << 12) + (gteR31 * gteVX0) + (gteR32 * gteVY0) + (gteR33 * gteVZ0)) >> 12);
462 gteIR1 = limB1(gteMAC1, 0);
463 gteIR2 = limB2(gteMAC2, 0);
464 gteIR3 = limB3(gteMAC3, 0);
465 gteSZ0 = gteSZ1;
466 gteSZ1 = gteSZ2;
467 gteSZ2 = gteSZ3;
468 gteSZ3 = limD(gteMAC3);
469 quotient = limE(DIVIDE(gteH, gteSZ3));
470 gteSXY0 = gteSXY1;
471 gteSXY1 = gteSXY2;
472 gteSX2 = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
473 gteSY2 = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
474
8cb04d22 475 tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
476 gteMAC0 = F(tmp);
477 gteIR0 = limH(tmp >> 12);
ef79bbde
P		 478}
479
f74fb727 480void gteRTPT(psxCP2Regs *regs) {
ef79bbde
P		 481 int quotient;
482 int v;
483 s32 vx, vy, vz;
8cb04d22 484 s64 tmp;
ef79bbde
P		 485
486#ifdef GTE_LOG
487 GTE_LOG("GTE RTPT\n");
488#endif
489 gteFLAG = 0;
490
491 gteSZ0 = gteSZ3;
492 for (v = 0; v < 3; v++) {
493 vx = VX(v);
494 vy = VY(v);
495 vz = VZ(v);
496 gteMAC1 = A1((((s64)gteTRX << 12) + (gteR11 * vx) + (gteR12 * vy) + (gteR13 * vz)) >> 12);
497 gteMAC2 = A2((((s64)gteTRY << 12) + (gteR21 * vx) + (gteR22 * vy) + (gteR23 * vz)) >> 12);
498 gteMAC3 = A3((((s64)gteTRZ << 12) + (gteR31 * vx) + (gteR32 * vy) + (gteR33 * vz)) >> 12);
499 gteIR1 = limB1(gteMAC1, 0);
500 gteIR2 = limB2(gteMAC2, 0);
501 gteIR3 = limB3(gteMAC3, 0);
502 fSZ(v) = limD(gteMAC3);
503 quotient = limE(DIVIDE(gteH, fSZ(v)));
504 fSX(v) = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
505 fSY(v) = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
506 }
8cb04d22 507
508 tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
509 gteMAC0 = F(tmp);
510 gteIR0 = limH(tmp >> 12);
ef79bbde
P		 511}
512
f74fb727 513void gteMVMVA(psxCP2Regs *regs) {
ef79bbde
P		 514 int shift = 12 * GTE_SF(gteop);
515 int mx = GTE_MX(gteop);
516 int v = GTE_V(gteop);
517 int cv = GTE_CV(gteop);
518 int lm = GTE_LM(gteop);
519 s32 vx = VX(v);
520 s32 vy = VY(v);
521 s32 vz = VZ(v);
522
523#ifdef GTE_LOG
524 GTE_LOG("GTE MVMVA\n");
525#endif
526 gteFLAG = 0;
527
528 gteMAC1 = A1((((s64)CV1(cv) << 12) + (MX11(mx) * vx) + (MX12(mx) * vy) + (MX13(mx) * vz)) >> shift);
529 gteMAC2 = A2((((s64)CV2(cv) << 12) + (MX21(mx) * vx) + (MX22(mx) * vy) + (MX23(mx) * vz)) >> shift);
530 gteMAC3 = A3((((s64)CV3(cv) << 12) + (MX31(mx) * vx) + (MX32(mx) * vy) + (MX33(mx) * vz)) >> shift);
531
532 gteIR1 = limB1(gteMAC1, lm);
533 gteIR2 = limB2(gteMAC2, lm);
534 gteIR3 = limB3(gteMAC3, lm);
535}
536
f74fb727 537void gteNCLIP(psxCP2Regs *regs) {
ef79bbde
P		 538#ifdef GTE_LOG
539 GTE_LOG("GTE NCLIP\n");
540#endif
541 gteFLAG = 0;
542
543 gteMAC0 = F((s64)gteSX0 * (gteSY1 - gteSY2) +
544 gteSX1 * (gteSY2 - gteSY0) +
545 gteSX2 * (gteSY0 - gteSY1));
546}
547
f74fb727 548void gteAVSZ3(psxCP2Regs *regs) {
ef79bbde
P		 549#ifdef GTE_LOG
550 GTE_LOG("GTE AVSZ3\n");
551#endif
552 gteFLAG = 0;
553
b3254af9 554 gteMAC0 = F((s64)gteZSF3 * (gteSZ1 + gteSZ2 + gteSZ3));
ef79bbde
P		 555 gteOTZ = limD(gteMAC0 >> 12);
556}
557
f74fb727 558void gteAVSZ4(psxCP2Regs *regs) {
ef79bbde
P		 559#ifdef GTE_LOG
560 GTE_LOG("GTE AVSZ4\n");
561#endif
562 gteFLAG = 0;
563
b3254af9 564 gteMAC0 = F((s64)gteZSF4 * (gteSZ0 + gteSZ1 + gteSZ2 + gteSZ3));
ef79bbde
P		 565 gteOTZ = limD(gteMAC0 >> 12);
566}
567
f74fb727 568void gteSQR(psxCP2Regs *regs) {
ef79bbde
P		 569 int shift = 12 * GTE_SF(gteop);
570 int lm = GTE_LM(gteop);
571
572#ifdef GTE_LOG
573 GTE_LOG("GTE SQR\n");
574#endif
575 gteFLAG = 0;
576
b3254af9 577 gteMAC1 = (gteIR1 * gteIR1) >> shift;
578 gteMAC2 = (gteIR2 * gteIR2) >> shift;
579 gteMAC3 = (gteIR3 * gteIR3) >> shift;
7384197d 580 gteIR1 = limB1(gteMAC1, lm);
581 gteIR2 = limB2(gteMAC2, lm);
582 gteIR3 = limB3(gteMAC3, lm);
ef79bbde
P		 583}
584
f74fb727 585void gteNCCS(psxCP2Regs *regs) {
ef79bbde
P		 586#ifdef GTE_LOG
587 GTE_LOG("GTE NCCS\n");
588#endif
589 gteFLAG = 0;
590
b3254af9 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;
ef79bbde
P		 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);
b3254af9 603 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
604 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
605 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
606 gteIR1 = gteMAC1;
607 gteIR2 = gteMAC2;
608 gteIR3 = gteMAC3;
ef79bbde
P		 609
610 gteRGB0 = gteRGB1;
611 gteRGB1 = gteRGB2;
612 gteCODE2 = gteCODE;
613 gteR2 = limC1(gteMAC1 >> 4);
614 gteG2 = limC2(gteMAC2 >> 4);
615 gteB2 = limC3(gteMAC3 >> 4);
616}
617
f74fb727 618void gteNCCT(psxCP2Regs *regs) {
ef79bbde
P		 619 int v;
620 s32 vx, vy, vz;
621
622#ifdef GTE_LOG
623 GTE_LOG("GTE NCCT\n");
624#endif
625 gteFLAG = 0;
626
627 for (v = 0; v < 3; v++) {
628 vx = VX(v);
629 vy = VY(v);
630 vz = VZ(v);
b3254af9 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;
ef79bbde
P		 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);
b3254af9 643 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
644 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
645 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
ef79bbde
P		 646
647 gteRGB0 = gteRGB1;
648 gteRGB1 = gteRGB2;
649 gteCODE2 = gteCODE;
650 gteR2 = limC1(gteMAC1 >> 4);
651 gteG2 = limC2(gteMAC2 >> 4);
652 gteB2 = limC3(gteMAC3 >> 4);
653 }
b3254af9 654 gteIR1 = gteMAC1;
655 gteIR2 = gteMAC2;
656 gteIR3 = gteMAC3;
ef79bbde
P		 657}
658
f74fb727 659void gteNCDS(psxCP2Regs *regs) {
ef79bbde
P		 660#ifdef GTE_LOG
661 GTE_LOG("GTE NCDS\n");
662#endif
663 gteFLAG = 0;
664
b3254af9 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;
ef79bbde
P		 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);
6c6c9590 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;
ef79bbde
P		 680 gteIR1 = limB1(gteMAC1, 1);
681 gteIR2 = limB2(gteMAC2, 1);
682 gteIR3 = limB3(gteMAC3, 1);
683
684 gteRGB0 = gteRGB1;
685 gteRGB1 = gteRGB2;
686 gteCODE2 = gteCODE;
687 gteR2 = limC1(gteMAC1 >> 4);
688 gteG2 = limC2(gteMAC2 >> 4);
689 gteB2 = limC3(gteMAC3 >> 4);
690}
691
f74fb727 692void gteNCDT(psxCP2Regs *regs) {
ef79bbde
P		 693 int v;
694 s32 vx, vy, vz;
695
696#ifdef GTE_LOG
697 GTE_LOG("GTE NCDT\n");
698#endif
699 gteFLAG = 0;
700
701 for (v = 0; v < 3; v++) {
702 vx = VX(v);
703 vy = VY(v);
704 vz = VZ(v);
b3254af9 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;
ef79bbde
P		 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);
6c6c9590 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;
ef79bbde
P		 720
721 gteRGB0 = gteRGB1;
722 gteRGB1 = gteRGB2;
723 gteCODE2 = gteCODE;
724 gteR2 = limC1(gteMAC1 >> 4);
725 gteG2 = limC2(gteMAC2 >> 4);
726 gteB2 = limC3(gteMAC3 >> 4);
727 }
728 gteIR1 = limB1(gteMAC1, 1);
729 gteIR2 = limB2(gteMAC2, 1);
730 gteIR3 = limB3(gteMAC3, 1);
731}
732
f74fb727 733void gteOP(psxCP2Regs *regs) {
ef79bbde
P		 734 int shift = 12 * GTE_SF(gteop);
735 int lm = GTE_LM(gteop);
736
737#ifdef GTE_LOG
738 GTE_LOG("GTE OP\n");
739#endif
740 gteFLAG = 0;
741
b3254af9 742 gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> shift;
743 gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> shift;
744 gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> shift;
ef79bbde
P		 745 gteIR1 = limB1(gteMAC1, lm);
746 gteIR2 = limB2(gteMAC2, lm);
747 gteIR3 = limB3(gteMAC3, lm);
748}
749
f74fb727 750void gteDCPL(psxCP2Regs *regs) {
ef79bbde
P		 751 int lm = GTE_LM(gteop);
752
b3254af9 753 s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
754 s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
755 s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
ef79bbde
P		 756
757#ifdef GTE_LOG
758 GTE_LOG("GTE DCPL\n");
759#endif
760 gteFLAG = 0;
761
6c6c9590 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);
ef79bbde
P		 765
766 gteIR1 = limB1(gteMAC1, lm);
767 gteIR2 = limB2(gteMAC2, lm);
768 gteIR3 = limB3(gteMAC3, lm);
769
770 gteRGB0 = gteRGB1;
771 gteRGB1 = gteRGB2;
772 gteCODE2 = gteCODE;
773 gteR2 = limC1(gteMAC1 >> 4);
774 gteG2 = limC2(gteMAC2 >> 4);
775 gteB2 = limC3(gteMAC3 >> 4);
776}
777
f74fb727 778void gteGPF(psxCP2Regs *regs) {
ef79bbde
P		 779 int shift = 12 * GTE_SF(gteop);
780
781#ifdef GTE_LOG
782 GTE_LOG("GTE GPF\n");
783#endif
784 gteFLAG = 0;
785
b3254af9 786 gteMAC1 = (gteIR0 * gteIR1) >> shift;
787 gteMAC2 = (gteIR0 * gteIR2) >> shift;
788 gteMAC3 = (gteIR0 * gteIR3) >> shift;
ef79bbde
P		 789 gteIR1 = limB1(gteMAC1, 0);
790 gteIR2 = limB2(gteMAC2, 0);
791 gteIR3 = limB3(gteMAC3, 0);
792
793 gteRGB0 = gteRGB1;
794 gteRGB1 = gteRGB2;
795 gteCODE2 = gteCODE;
796 gteR2 = limC1(gteMAC1 >> 4);
797 gteG2 = limC2(gteMAC2 >> 4);
798 gteB2 = limC3(gteMAC3 >> 4);
799}
800
f74fb727 801void gteGPL(psxCP2Regs *regs) {
ef79bbde
P		 802 int shift = 12 * GTE_SF(gteop);
803
804#ifdef GTE_LOG
805 GTE_LOG("GTE GPL\n");
806#endif
807 gteFLAG = 0;
808
809 gteMAC1 = A1((((s64)gteMAC1 << shift) + (gteIR0 * gteIR1)) >> shift);
810 gteMAC2 = A2((((s64)gteMAC2 << shift) + (gteIR0 * gteIR2)) >> shift);
811 gteMAC3 = A3((((s64)gteMAC3 << shift) + (gteIR0 * gteIR3)) >> shift);
812 gteIR1 = limB1(gteMAC1, 0);
813 gteIR2 = limB2(gteMAC2, 0);
814 gteIR3 = limB3(gteMAC3, 0);
815
816 gteRGB0 = gteRGB1;
817 gteRGB1 = gteRGB2;
818 gteCODE2 = gteCODE;
819 gteR2 = limC1(gteMAC1 >> 4);
820 gteG2 = limC2(gteMAC2 >> 4);
821 gteB2 = limC3(gteMAC3 >> 4);
822}
823
f74fb727 824void gteDPCS(psxCP2Regs *regs) {
ef79bbde
P		 825 int shift = 12 * GTE_SF(gteop);
826
827#ifdef GTE_LOG
828 GTE_LOG("GTE DPCS\n");
829#endif
830 gteFLAG = 0;
831
6c6c9590 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;
ef79bbde
P		 835
836 gteIR1 = limB1(gteMAC1, 0);
837 gteIR2 = limB2(gteMAC2, 0);
838 gteIR3 = limB3(gteMAC3, 0);
839 gteRGB0 = gteRGB1;
840 gteRGB1 = gteRGB2;
841 gteCODE2 = gteCODE;
842 gteR2 = limC1(gteMAC1 >> 4);
843 gteG2 = limC2(gteMAC2 >> 4);
844 gteB2 = limC3(gteMAC3 >> 4);
845}
846
f74fb727 847void gteDPCT(psxCP2Regs *regs) {
ef79bbde
P		 848 int v;
849
850#ifdef GTE_LOG
851 GTE_LOG("GTE DPCT\n");
852#endif
853 gteFLAG = 0;
854
855 for (v = 0; v < 3; v++) {
6c6c9590 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;
ef79bbde
P		 859
860 gteRGB0 = gteRGB1;
861 gteRGB1 = gteRGB2;
862 gteCODE2 = gteCODE;
863 gteR2 = limC1(gteMAC1 >> 4);
864 gteG2 = limC2(gteMAC2 >> 4);
865 gteB2 = limC3(gteMAC3 >> 4);
866 }
867 gteIR1 = limB1(gteMAC1, 0);
868 gteIR2 = limB2(gteMAC2, 0);
869 gteIR3 = limB3(gteMAC3, 0);
870}
871
f74fb727 872void gteNCS(psxCP2Regs *regs) {
ef79bbde
P		 873#ifdef GTE_LOG
874 GTE_LOG("GTE NCS\n");
875#endif
876 gteFLAG = 0;
877
b3254af9 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;
ef79bbde
P		 881 gteIR1 = limB1(gteMAC1, 1);
882 gteIR2 = limB2(gteMAC2, 1);
883 gteIR3 = limB3(gteMAC3, 1);
884 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
885 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
886 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
887 gteIR1 = limB1(gteMAC1, 1);
888 gteIR2 = limB2(gteMAC2, 1);
889 gteIR3 = limB3(gteMAC3, 1);
890
891 gteRGB0 = gteRGB1;
892 gteRGB1 = gteRGB2;
893 gteCODE2 = gteCODE;
894 gteR2 = limC1(gteMAC1 >> 4);
895 gteG2 = limC2(gteMAC2 >> 4);
896 gteB2 = limC3(gteMAC3 >> 4);
897}
898
f74fb727 899void gteNCT(psxCP2Regs *regs) {
ef79bbde
P		 900 int v;
901 s32 vx, vy, vz;
902
903#ifdef GTE_LOG
904 GTE_LOG("GTE NCT\n");
905#endif
906 gteFLAG = 0;
907
908 for (v = 0; v < 3; v++) {
909 vx = VX(v);
910 vy = VY(v);
911 vz = VZ(v);
b3254af9 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;
ef79bbde
P		 915 gteIR1 = limB1(gteMAC1, 1);
916 gteIR2 = limB2(gteMAC2, 1);
917 gteIR3 = limB3(gteMAC3, 1);
918 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
919 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
920 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
921 gteRGB0 = gteRGB1;
922 gteRGB1 = gteRGB2;
923 gteCODE2 = gteCODE;
924 gteR2 = limC1(gteMAC1 >> 4);
925 gteG2 = limC2(gteMAC2 >> 4);
926 gteB2 = limC3(gteMAC3 >> 4);
927 }
928 gteIR1 = limB1(gteMAC1, 1);
929 gteIR2 = limB2(gteMAC2, 1);
930 gteIR3 = limB3(gteMAC3, 1);
931}
932
f74fb727 933void gteCC(psxCP2Regs *regs) {
ef79bbde
P		 934#ifdef GTE_LOG
935 GTE_LOG("GTE CC\n");
936#endif
937 gteFLAG = 0;
938
939 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
940 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
941 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
942 gteIR1 = limB1(gteMAC1, 1);
943 gteIR2 = limB2(gteMAC2, 1);
944 gteIR3 = limB3(gteMAC3, 1);
b3254af9 945 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
946 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
947 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
ef79bbde
P		 948 gteIR1 = limB1(gteMAC1, 1);
949 gteIR2 = limB2(gteMAC2, 1);
950 gteIR3 = limB3(gteMAC3, 1);
951
952 gteRGB0 = gteRGB1;
953 gteRGB1 = gteRGB2;
954 gteCODE2 = gteCODE;
955 gteR2 = limC1(gteMAC1 >> 4);
956 gteG2 = limC2(gteMAC2 >> 4);
957 gteB2 = limC3(gteMAC3 >> 4);
958}
959
f74fb727 960void gteINTPL(psxCP2Regs *regs) {
ef79bbde
P		 961 int shift = 12 * GTE_SF(gteop);
962 int lm = GTE_LM(gteop);
963
964#ifdef GTE_LOG
965 GTE_LOG("GTE INTPL\n");
966#endif
967 gteFLAG = 0;
968
6c6c9590 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;
ef79bbde
P		 972 gteIR1 = limB1(gteMAC1, lm);
973 gteIR2 = limB2(gteMAC2, lm);
974 gteIR3 = limB3(gteMAC3, lm);
975 gteRGB0 = gteRGB1;
976 gteRGB1 = gteRGB2;
977 gteCODE2 = gteCODE;
978 gteR2 = limC1(gteMAC1 >> 4);
979 gteG2 = limC2(gteMAC2 >> 4);
980 gteB2 = limC3(gteMAC3 >> 4);
981}
982
f74fb727 983void gteCDP(psxCP2Regs *regs) {
ef79bbde
P		 984#ifdef GTE_LOG
985 GTE_LOG("GTE CDP\n");
986#endif
987 gteFLAG = 0;
988
989 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
990 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
991 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
992 gteIR1 = limB1(gteMAC1, 1);
993 gteIR2 = limB2(gteMAC2, 1);
994 gteIR3 = limB3(gteMAC3, 1);
6c6c9590 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;
ef79bbde
P		 998 gteIR1 = limB1(gteMAC1, 1);
999 gteIR2 = limB2(gteMAC2, 1);
1000 gteIR3 = limB3(gteMAC3, 1);
1001
1002 gteRGB0 = gteRGB1;
1003 gteRGB1 = gteRGB2;
1004 gteCODE2 = gteCODE;
1005 gteR2 = limC1(gteMAC1 >> 4);
1006 gteG2 = limC2(gteMAC2 >> 4);
1007 gteB2 = limC3(gteMAC3 >> 4);
1008}
6c0eefaf 1009
1010/* decomposed/parametrized versions for the recompiler */
1011
1012#ifndef FLAGLESS
1013
1014void gteSQR_part_noshift(psxCP2Regs *regs) {
1015 gteFLAG = 0;
1016
1017 gteMAC1 = gteIR1 * gteIR1;
1018 gteMAC2 = gteIR2 * gteIR2;
1019 gteMAC3 = gteIR3 * gteIR3;
1020}
1021
1022void gteSQR_part_shift(psxCP2Regs *regs) {
1023 gteFLAG = 0;
1024
1025 gteMAC1 = (gteIR1 * gteIR1) >> 12;
1026 gteMAC2 = (gteIR2 * gteIR2) >> 12;
1027 gteMAC3 = (gteIR3 * gteIR3) >> 12;
1028}
1029
1030void gteOP_part_noshift(psxCP2Regs *regs) {
1031 gteFLAG = 0;
1032
1033 gteMAC1 = (gteR22 * gteIR3) - (gteR33 * gteIR2);
1034 gteMAC2 = (gteR33 * gteIR1) - (gteR11 * gteIR3);
1035 gteMAC3 = (gteR11 * gteIR2) - (gteR22 * gteIR1);
1036}
1037
1038void gteOP_part_shift(psxCP2Regs *regs) {
1039 gteFLAG = 0;
1040
1041 gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> 12;
1042 gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> 12;
1043 gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> 12;
1044}
1045
1046void gteDCPL_part(psxCP2Regs *regs) {
1047 s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
1048 s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
1049 s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
1050
1051 gteFLAG = 0;
1052
1053 gteMAC1 = RIR1 + ((gteIR0 * limB1(A1U((s64)gteRFC - RIR1), 0)) >> 12);
1054 gteMAC2 = GIR2 + ((gteIR0 * limB1(A2U((s64)gteGFC - GIR2), 0)) >> 12);
1055 gteMAC3 = BIR3 + ((gteIR0 * limB1(A3U((s64)gteBFC - BIR3), 0)) >> 12);
1056}
1057
1058void gteGPF_part_noshift(psxCP2Regs *regs) {
1059 gteFLAG = 0;
1060
1061 gteMAC1 = gteIR0 * gteIR1;
1062 gteMAC2 = gteIR0 * gteIR2;
1063 gteMAC3 = gteIR0 * gteIR3;
1064}
1065
1066void gteGPF_part_shift(psxCP2Regs *regs) {
1067 gteFLAG = 0;
1068
1069 gteMAC1 = (gteIR0 * gteIR1) >> 12;
1070 gteMAC2 = (gteIR0 * gteIR2) >> 12;
1071 gteMAC3 = (gteIR0 * gteIR3) >> 12;
1072}
1073
1074#endif // !FLAGLESS
1075
1076void gteGPL_part_noshift(psxCP2Regs *regs) {
1077 gteFLAG = 0;
1078
1079 gteMAC1 = A1((s64)gteMAC1 + (gteIR0 * gteIR1));
1080 gteMAC2 = A2((s64)gteMAC2 + (gteIR0 * gteIR2));
1081 gteMAC3 = A3((s64)gteMAC3 + (gteIR0 * gteIR3));
1082}
1083
1084void gteGPL_part_shift(psxCP2Regs *regs) {
1085 gteFLAG = 0;
1086
1087 gteMAC1 = A1((s64)gteMAC1 + ((gteIR0 * gteIR1) >> 12));
1088 gteMAC2 = A2((s64)gteMAC2 + ((gteIR0 * gteIR2) >> 12));
1089 gteMAC3 = A3((s64)gteMAC3 + ((gteIR0 * gteIR3) >> 12));
1090}
1091
1092void gteDPCS_part_noshift(psxCP2Regs *regs) {
1093 int shift = 0;
1094
1095 gteFLAG = 0;
1096
1097 gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR << 4)) << (12 - shift), 0))) >> 12;
1098 gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U((s64)gteGFC - (gteG << 4)) << (12 - shift), 0))) >> 12;
1099 gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U((s64)gteBFC - (gteB << 4)) << (12 - shift), 0))) >> 12;
1100}
1101
1102void gteDPCS_part_shift(psxCP2Regs *regs) {
1103 int shift = 12;
1104
1105 gteFLAG = 0;
1106
1107 gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR << 4)) << (12 - shift), 0))) >> 12;
1108 gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U((s64)gteGFC - (gteG << 4)) << (12 - shift), 0))) >> 12;
1109 gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U((s64)gteBFC - (gteB << 4)) << (12 - shift), 0))) >> 12;
1110}
1111
1112void gteINTPL_part_noshift(psxCP2Regs *regs) {
1113 gteFLAG = 0;
1114
1115 gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0)));
1116 gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0)));
1117 gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0)));
1118}
1119
1120void gteINTPL_part_shift(psxCP2Regs *regs) {
1121 gteFLAG = 0;
1122
1123 gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0))) >> 12;
1124 gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0))) >> 12;
1125 gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0))) >> 12;
1126}
1127
1128void gteMACtoRGB(psxCP2Regs *regs) {
1129 gteRGB0 = gteRGB1;
1130 gteRGB1 = gteRGB2;
1131 gteCODE2 = gteCODE;
1132 gteR2 = limC1(gteMAC1 >> 4);
1133 gteG2 = limC2(gteMAC2 >> 4);
1134 gteB2 = limC3(gteMAC3 >> 4);
1135}
1136
ARM optimized PCSX fork