notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
frontend: update libpicofe, fix missed callbacks
[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"
1fdc23fe 28#include "../include/compiler_features.h"
ef79bbde 29
f74fb727 30#define VX(n) (n < 3 ? regs->CP2D.p[n << 1].sw.l : regs->CP2D.p[9].sw.l)
31#define VY(n) (n < 3 ? regs->CP2D.p[n << 1].sw.h : regs->CP2D.p[10].sw.l)
32#define VZ(n) (n < 3 ? regs->CP2D.p[(n << 1) + 1].sw.l : regs->CP2D.p[11].sw.l)
33#define MX11(n) (n < 3 ? regs->CP2C.p[(n << 3)].sw.l : 0)
34#define MX12(n) (n < 3 ? regs->CP2C.p[(n << 3)].sw.h : 0)
35#define MX13(n) (n < 3 ? regs->CP2C.p[(n << 3) + 1].sw.l : 0)
36#define MX21(n) (n < 3 ? regs->CP2C.p[(n << 3) + 1].sw.h : 0)
37#define MX22(n) (n < 3 ? regs->CP2C.p[(n << 3) + 2].sw.l : 0)
38#define MX23(n) (n < 3 ? regs->CP2C.p[(n << 3) + 2].sw.h : 0)
39#define MX31(n) (n < 3 ? regs->CP2C.p[(n << 3) + 3].sw.l : 0)
40#define MX32(n) (n < 3 ? regs->CP2C.p[(n << 3) + 3].sw.h : 0)
41#define MX33(n) (n < 3 ? regs->CP2C.p[(n << 3) + 4].sw.l : 0)
42#define CV1(n) (n < 3 ? (s32)regs->CP2C.r[(n << 3) + 5] : 0)
43#define CV2(n) (n < 3 ? (s32)regs->CP2C.r[(n << 3) + 6] : 0)
44#define CV3(n) (n < 3 ? (s32)regs->CP2C.r[(n << 3) + 7] : 0)
45
46#define fSX(n) ((regs->CP2D.p)[((n) + 12)].sw.l)
47#define fSY(n) ((regs->CP2D.p)[((n) + 12)].sw.h)
48#define fSZ(n) ((regs->CP2D.p)[((n) + 17)].w.l) /* (n == 0) => SZ1; */
49
50#define gteVXY0 (regs->CP2D.r[0])
51#define gteVX0 (regs->CP2D.p[0].sw.l)
52#define gteVY0 (regs->CP2D.p[0].sw.h)
53#define gteVZ0 (regs->CP2D.p[1].sw.l)
54#define gteVXY1 (regs->CP2D.r[2])
55#define gteVX1 (regs->CP2D.p[2].sw.l)
56#define gteVY1 (regs->CP2D.p[2].sw.h)
57#define gteVZ1 (regs->CP2D.p[3].sw.l)
58#define gteVXY2 (regs->CP2D.r[4])
59#define gteVX2 (regs->CP2D.p[4].sw.l)
60#define gteVY2 (regs->CP2D.p[4].sw.h)
61#define gteVZ2 (regs->CP2D.p[5].sw.l)
62#define gteRGB (regs->CP2D.r[6])
63#define gteR (regs->CP2D.p[6].b.l)
64#define gteG (regs->CP2D.p[6].b.h)
65#define gteB (regs->CP2D.p[6].b.h2)
66#define gteCODE (regs->CP2D.p[6].b.h3)
67#define gteOTZ (regs->CP2D.p[7].w.l)
68#define gteIR0 (regs->CP2D.p[8].sw.l)
69#define gteIR1 (regs->CP2D.p[9].sw.l)
70#define gteIR2 (regs->CP2D.p[10].sw.l)
71#define gteIR3 (regs->CP2D.p[11].sw.l)
72#define gteSXY0 (regs->CP2D.r[12])
73#define gteSX0 (regs->CP2D.p[12].sw.l)
74#define gteSY0 (regs->CP2D.p[12].sw.h)
75#define gteSXY1 (regs->CP2D.r[13])
76#define gteSX1 (regs->CP2D.p[13].sw.l)
77#define gteSY1 (regs->CP2D.p[13].sw.h)
78#define gteSXY2 (regs->CP2D.r[14])
79#define gteSX2 (regs->CP2D.p[14].sw.l)
80#define gteSY2 (regs->CP2D.p[14].sw.h)
81#define gteSXYP (regs->CP2D.r[15])
82#define gteSXP (regs->CP2D.p[15].sw.l)
83#define gteSYP (regs->CP2D.p[15].sw.h)
84#define gteSZ0 (regs->CP2D.p[16].w.l)
85#define gteSZ1 (regs->CP2D.p[17].w.l)
86#define gteSZ2 (regs->CP2D.p[18].w.l)
87#define gteSZ3 (regs->CP2D.p[19].w.l)
88#define gteRGB0 (regs->CP2D.r[20])
89#define gteR0 (regs->CP2D.p[20].b.l)
90#define gteG0 (regs->CP2D.p[20].b.h)
91#define gteB0 (regs->CP2D.p[20].b.h2)
92#define gteCODE0 (regs->CP2D.p[20].b.h3)
93#define gteRGB1 (regs->CP2D.r[21])
94#define gteR1 (regs->CP2D.p[21].b.l)
95#define gteG1 (regs->CP2D.p[21].b.h)
96#define gteB1 (regs->CP2D.p[21].b.h2)
97#define gteCODE1 (regs->CP2D.p[21].b.h3)
98#define gteRGB2 (regs->CP2D.r[22])
99#define gteR2 (regs->CP2D.p[22].b.l)
100#define gteG2 (regs->CP2D.p[22].b.h)
101#define gteB2 (regs->CP2D.p[22].b.h2)
102#define gteCODE2 (regs->CP2D.p[22].b.h3)
103#define gteRES1 (regs->CP2D.r[23])
104#define gteMAC0 (((s32 *)regs->CP2D.r)[24])
105#define gteMAC1 (((s32 *)regs->CP2D.r)[25])
106#define gteMAC2 (((s32 *)regs->CP2D.r)[26])
107#define gteMAC3 (((s32 *)regs->CP2D.r)[27])
108#define gteIRGB (regs->CP2D.r[28])
109#define gteORGB (regs->CP2D.r[29])
110#define gteLZCS (regs->CP2D.r[30])
111#define gteLZCR (regs->CP2D.r[31])
112
113#define gteR11R12 (((s32 *)regs->CP2C.r)[0])
114#define gteR22R23 (((s32 *)regs->CP2C.r)[2])
115#define gteR11 (regs->CP2C.p[0].sw.l)
116#define gteR12 (regs->CP2C.p[0].sw.h)
117#define gteR13 (regs->CP2C.p[1].sw.l)
118#define gteR21 (regs->CP2C.p[1].sw.h)
119#define gteR22 (regs->CP2C.p[2].sw.l)
120#define gteR23 (regs->CP2C.p[2].sw.h)
121#define gteR31 (regs->CP2C.p[3].sw.l)
122#define gteR32 (regs->CP2C.p[3].sw.h)
123#define gteR33 (regs->CP2C.p[4].sw.l)
124#define gteTRX (((s32 *)regs->CP2C.r)[5])
125#define gteTRY (((s32 *)regs->CP2C.r)[6])
126#define gteTRZ (((s32 *)regs->CP2C.r)[7])
127#define gteL11 (regs->CP2C.p[8].sw.l)
128#define gteL12 (regs->CP2C.p[8].sw.h)
129#define gteL13 (regs->CP2C.p[9].sw.l)
130#define gteL21 (regs->CP2C.p[9].sw.h)
131#define gteL22 (regs->CP2C.p[10].sw.l)
132#define gteL23 (regs->CP2C.p[10].sw.h)
133#define gteL31 (regs->CP2C.p[11].sw.l)
134#define gteL32 (regs->CP2C.p[11].sw.h)
135#define gteL33 (regs->CP2C.p[12].sw.l)
136#define gteRBK (((s32 *)regs->CP2C.r)[13])
137#define gteGBK (((s32 *)regs->CP2C.r)[14])
138#define gteBBK (((s32 *)regs->CP2C.r)[15])
139#define gteLR1 (regs->CP2C.p[16].sw.l)
140#define gteLR2 (regs->CP2C.p[16].sw.h)
141#define gteLR3 (regs->CP2C.p[17].sw.l)
142#define gteLG1 (regs->CP2C.p[17].sw.h)
143#define gteLG2 (regs->CP2C.p[18].sw.l)
144#define gteLG3 (regs->CP2C.p[18].sw.h)
145#define gteLB1 (regs->CP2C.p[19].sw.l)
146#define gteLB2 (regs->CP2C.p[19].sw.h)
147#define gteLB3 (regs->CP2C.p[20].sw.l)
148#define gteRFC (((s32 *)regs->CP2C.r)[21])
149#define gteGFC (((s32 *)regs->CP2C.r)[22])
150#define gteBFC (((s32 *)regs->CP2C.r)[23])
151#define gteOFX (((s32 *)regs->CP2C.r)[24])
152#define gteOFY (((s32 *)regs->CP2C.r)[25])
b7159e1a 153// senquack - gteH register is u16, not s16, and used in GTE that way.
154// HOWEVER when read back by CPU using CFC2, it will be incorrectly
155// sign-extended by bug in original hardware, according to Nocash docs
156// GTE section 'Screen Offset and Distance'. The emulator does this
157// sign extension when it is loaded to GTE by CTC2.
3d08b9fe 158//#define gteH (regs->CP2C.p[26].sw.l)
159#define gteH (regs->CP2C.p[26].w.l)
f74fb727 160#define gteDQA (regs->CP2C.p[27].sw.l)
161#define gteDQB (((s32 *)regs->CP2C.r)[28])
162#define gteZSF3 (regs->CP2C.p[29].sw.l)
163#define gteZSF4 (regs->CP2C.p[30].sw.l)
164#define gteFLAG (regs->CP2C.r[31])
ef79bbde
P		 165
166#define GTE_OP(op) ((op >> 20) & 31)
167#define GTE_SF(op) ((op >> 19) & 1)
168#define GTE_MX(op) ((op >> 17) & 3)
169#define GTE_V(op) ((op >> 15) & 3)
170#define GTE_CV(op) ((op >> 13) & 3)
171#define GTE_CD(op) ((op >> 11) & 3) /* not used */
172#define GTE_LM(op) ((op >> 10) & 1)
173#define GTE_CT(op) ((op >> 6) & 15) /* not used */
174#define GTE_FUNCT(op) (op & 63)
175
176#define gteop (psxRegs.code & 0x1ffffff)
177
59774ed0 178#ifndef FLAGLESS
179
669fed93 180static inline s64 BOUNDS_(psxCP2Regs *regs, s64 n_value, s64 n_max, int n_maxflag, s64 n_min, int n_minflag) {
ef79bbde
P		 181 if (n_value > n_max) {
182 gteFLAG |= n_maxflag;
183 } else if (n_value < n_min) {
184 gteFLAG |= n_minflag;
185 }
186 return n_value;
187}
188
f74fb727 189static inline s32 LIM_(psxCP2Regs *regs, s32 value, s32 max, s32 min, u32 flag) {
ef79bbde
P		 190 s32 ret = value;
191 if (value > max) {
192 gteFLAG |= flag;
193 ret = max;
194 } else if (value < min) {
195 gteFLAG |= flag;
196 ret = min;
197 }
198 return ret;
199}
200
f74fb727 201static inline u32 limE_(psxCP2Regs *regs, u32 result) {
59774ed0 202 if (result > 0x1ffff) {
f707f14b 203 gteFLAG |= (1u << 31) | (1u << 17);
59774ed0 204 return 0x1ffff;
205 }
206 return result;
207}
208
209#else
210
f74fb727 211#define BOUNDS_(regs, a, ...) (a)
59774ed0 212
f74fb727 213static inline s32 LIM_(psxCP2Regs *regs, s32 value, s32 max, s32 min, u32 flag_unused) {
59774ed0 214 s32 ret = value;
215 if (value > max)
216 ret = max;
217 else if (value < min)
218 ret = min;
219 return ret;
220}
221
f74fb727 222static inline u32 limE_(psxCP2Regs *regs, u32 result) {
bedfea38 223 if (result > 0x1ffff)
224 return 0x1ffff;
225 return result;
226}
59774ed0 227
228#endif
229
f74fb727 230#define BOUNDS(n_value,n_max,n_maxflag,n_min,n_minflag) \
231 BOUNDS_(regs,n_value,n_max,n_maxflag,n_min,n_minflag)
232#define LIM(value,max,min,flag) \
233 LIM_(regs,value,max,min,flag)
234#define limE(result) \
235 limE_(regs,result)
236
f707f14b 237#define A1(a) BOUNDS((a), 0x7fffffff, (1u << 30), -(s64)0x80000000, (1u << 31) | (1u << 27))
238#define A2(a) BOUNDS((a), 0x7fffffff, (1u << 29), -(s64)0x80000000, (1u << 31) | (1u << 26))
239#define A3(a) BOUNDS((a), 0x7fffffff, (1u << 28), -(s64)0x80000000, (1u << 31) | (1u << 25))
240#define limB1(a, l) LIM((a), 0x7fff, -0x8000 * !l, (1u << 31) | (1u << 24))
241#define limB2(a, l) LIM((a), 0x7fff, -0x8000 * !l, (1u << 31) | (1u << 23))
242#define limB3(a, l) LIM((a), 0x7fff, -0x8000 * !l, (1u << 22))
243#define limC1(a) LIM((a), 0x00ff, 0x0000, (1u << 21))
244#define limC2(a) LIM((a), 0x00ff, 0x0000, (1u << 20))
245#define limC3(a) LIM((a), 0x00ff, 0x0000, (1u << 19))
246#define limD(a) LIM((a), 0xffff, 0x0000, (1u << 31) | (1u << 18))
247
248#define F(a) BOUNDS((a), 0x7fffffff, (1u << 31) | (1u << 16), -(s64)0x80000000, (1u << 31) | (1u << 15))
249#define limG1(a) LIM((a), 0x3ff, -0x400, (1u << 31) | (1u << 14))
250#define limG2(a) LIM((a), 0x3ff, -0x400, (1u << 31) | (1u << 13))
251#define limH(a) LIM((a), 0x1000, 0x0000, (1u << 12))
ef79bbde 252
6c6c9590 253#ifndef __arm__
254#define A1U A1
255#define A2U A2
256#define A3U A3
257#else
258/* these are unlikely to be hit and usually waste cycles, don't want them on ARM */
259#define A1U(x) (x)
260#define A2U(x) (x)
261#define A3U(x) (x)
262#endif
263
b7159e1a 264
265//senquack - n param should be unsigned (will be 'gteH' reg which is u16)
266#ifdef GTE_USE_NATIVE_DIVIDE
267INLINE u32 DIVIDE(u16 n, u16 d) {
268 if (n < d * 2) {
269 return ((u32)n << 16) / d;
270 }
271 return 0xffffffff;
272}
273#else
ef79bbde 274#include "gte_divider.h"
b7159e1a 275#endif // GTE_USE_NATIVE_DIVIDE
ef79bbde 276
59774ed0 277#ifndef FLAGLESS
278
32631e6a 279const unsigned char gte_cycletab[64] = {
81dbbf4c 280 /* 1 2 3 4 5 6 7 8 9 a b c d e f */
281 0, 15, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 6, 0, 0, 0,
282 8, 8, 8, 19, 13, 0, 44, 0, 0, 0, 0, 17, 11, 0, 14, 0,
283 30, 0, 0, 0, 0, 0, 0, 0, 5, 8, 17, 0, 0, 5, 6, 0,
284 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 39,
285};
286
21e24294 287// warning: ari64 drc stores it's negative cycles in gteBusyCycle
288static int gteCheckStallRaw(u32 op_cycles, psxRegisters *regs) {
81dbbf4c 289 u32 left = regs->gteBusyCycle - regs->cycle;
290 int stall = 0;
291
292 if (left <= 44) {
293 //printf("c %2u stall %2u %u\n", op_cycles, left, regs->cycle);
294 regs->cycle = regs->gteBusyCycle;
295 stall = left;
296 }
297 regs->gteBusyCycle = regs->cycle + op_cycles;
298 return stall;
299}
300
301void gteCheckStall(u32 op) {
302 gteCheckStallRaw(gte_cycletab[op], &psxRegs);
303}
304
4cc373dd 305u32 MFC2(struct psxCP2Regs *regs, int reg) {
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:
4cc373dd 314 regs->CP2D.r[reg] = (s32)regs->CP2D.p[reg].sw.l;
ef79bbde
P		 315 break;
316
317 case 7:
318 case 16:
319 case 17:
320 case 18:
321 case 19:
4cc373dd 322 regs->CP2D.r[reg] = (u32)regs->CP2D.p[reg].w.l;
ef79bbde
P		 323 break;
324
325 case 15:
4cc373dd 326 regs->CP2D.r[reg] = gteSXY2;
ef79bbde
P		 327 break;
328
329 case 28:
ef79bbde 330 case 29:
4cc373dd 331 regs->CP2D.r[reg] = LIM(gteIR1 >> 7, 0x1f, 0, 0) |
ef79bbde
P		 332 (LIM(gteIR2 >> 7, 0x1f, 0, 0) << 5) |
333 (LIM(gteIR3 >> 7, 0x1f, 0, 0) << 10);
334 break;
335 }
4cc373dd 336 return regs->CP2D.r[reg];
ef79bbde
P		 337}
338
1fdc23fe 339static u32 lzc(s32 val)
340{
341#if __has_builtin(__builtin_clrsb)
342 return 1 + __builtin_clrsb(val);
343#else
344 val ^= val >> 31;
345 return val ? __builtin_clz(val) : 32;
346#endif
347}
348
4cc373dd 349void MTC2(struct psxCP2Regs *regs, u32 value, int reg) {
ef79bbde
P		 350 switch (reg) {
351 case 15:
352 gteSXY0 = gteSXY1;
353 gteSXY1 = gteSXY2;
354 gteSXY2 = value;
355 gteSXYP = value;
356 break;
357
358 case 28:
359 gteIRGB = value;
3968e69e 360 // not gteIR1 etc. just to be consistent with dynarec
361 regs->CP2D.n.ir1 = (value & 0x1f) << 7;
362 regs->CP2D.n.ir2 = (value & 0x3e0) << 2;
363 regs->CP2D.n.ir3 = (value & 0x7c00) >> 3;
ef79bbde
P		 364 break;
365
366 case 30:
1fdc23fe 367 gteLZCS = value;
368 gteLZCR = lzc(value);
ef79bbde
P		 369 break;
370
ef79bbde
P		 371 case 31:
372 return;
373
374 default:
4cc373dd 375 regs->CP2D.r[reg] = value;
ef79bbde
P		 376 }
377}
378
4cc373dd 379void CTC2(struct psxCP2Regs *regs, u32 value, int reg) {
ef79bbde
P		 380 switch (reg) {
381 case 4:
382 case 12:
383 case 20:
384 case 26:
385 case 27:
386 case 29:
387 case 30:
388 value = (s32)(s16)value;
389 break;
390
391 case 31:
392 value = value & 0x7ffff000;
393 if (value & 0x7f87e000) value |= 0x80000000;
394 break;
395 }
396
4cc373dd 397 regs->CP2C.r[reg] = value;
32631e6a 398}
399
59774ed0 400#endif // FLAGLESS
401
3ebefe71 402#if 0
a2544c92 403#define DIVIDE DIVIDE_
404static u32 DIVIDE_(s16 n, u16 d) {
405 if (n >= 0 && n < d * 2) {
406 s32 n_ = n;
407 return ((n_ << 16) + d / 2) / d;
408 //return (u32)((float)(n_ << 16) / (float)d + (float)0.5);
409 }
410 return 0xffffffff;
411}
3ebefe71 412#endif
a2544c92 413
f74fb727 414void gteRTPS(psxCP2Regs *regs) {
ef79bbde 415 int quotient;
8cb04d22 416 s64 tmp;
ef79bbde
P		 417
418#ifdef GTE_LOG
419 GTE_LOG("GTE RTPS\n");
420#endif
421 gteFLAG = 0;
422
423 gteMAC1 = A1((((s64)gteTRX << 12) + (gteR11 * gteVX0) + (gteR12 * gteVY0) + (gteR13 * gteVZ0)) >> 12);
424 gteMAC2 = A2((((s64)gteTRY << 12) + (gteR21 * gteVX0) + (gteR22 * gteVY0) + (gteR23 * gteVZ0)) >> 12);
425 gteMAC3 = A3((((s64)gteTRZ << 12) + (gteR31 * gteVX0) + (gteR32 * gteVY0) + (gteR33 * gteVZ0)) >> 12);
426 gteIR1 = limB1(gteMAC1, 0);
427 gteIR2 = limB2(gteMAC2, 0);
428 gteIR3 = limB3(gteMAC3, 0);
429 gteSZ0 = gteSZ1;
430 gteSZ1 = gteSZ2;
431 gteSZ2 = gteSZ3;
432 gteSZ3 = limD(gteMAC3);
433 quotient = limE(DIVIDE(gteH, gteSZ3));
434 gteSXY0 = gteSXY1;
435 gteSXY1 = gteSXY2;
436 gteSX2 = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
437 gteSY2 = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
438
8cb04d22 439 tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
440 gteMAC0 = F(tmp);
441 gteIR0 = limH(tmp >> 12);
ef79bbde
P		 442}
443
f74fb727 444void gteRTPT(psxCP2Regs *regs) {
ef79bbde
P		 445 int quotient;
446 int v;
447 s32 vx, vy, vz;
8cb04d22 448 s64 tmp;
ef79bbde
P		 449
450#ifdef GTE_LOG
451 GTE_LOG("GTE RTPT\n");
452#endif
453 gteFLAG = 0;
454
455 gteSZ0 = gteSZ3;
456 for (v = 0; v < 3; v++) {
457 vx = VX(v);
458 vy = VY(v);
459 vz = VZ(v);
460 gteMAC1 = A1((((s64)gteTRX << 12) + (gteR11 * vx) + (gteR12 * vy) + (gteR13 * vz)) >> 12);
461 gteMAC2 = A2((((s64)gteTRY << 12) + (gteR21 * vx) + (gteR22 * vy) + (gteR23 * vz)) >> 12);
462 gteMAC3 = A3((((s64)gteTRZ << 12) + (gteR31 * vx) + (gteR32 * vy) + (gteR33 * vz)) >> 12);
463 gteIR1 = limB1(gteMAC1, 0);
464 gteIR2 = limB2(gteMAC2, 0);
465 gteIR3 = limB3(gteMAC3, 0);
466 fSZ(v) = limD(gteMAC3);
467 quotient = limE(DIVIDE(gteH, fSZ(v)));
468 fSX(v) = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
469 fSY(v) = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
470 }
8cb04d22 471
472 tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
473 gteMAC0 = F(tmp);
474 gteIR0 = limH(tmp >> 12);
ef79bbde
P		 475}
476
f74fb727 477void gteMVMVA(psxCP2Regs *regs) {
ef79bbde
P		 478 int shift = 12 * GTE_SF(gteop);
479 int mx = GTE_MX(gteop);
480 int v = GTE_V(gteop);
481 int cv = GTE_CV(gteop);
482 int lm = GTE_LM(gteop);
483 s32 vx = VX(v);
484 s32 vy = VY(v);
485 s32 vz = VZ(v);
486
487#ifdef GTE_LOG
488 GTE_LOG("GTE MVMVA\n");
489#endif
490 gteFLAG = 0;
491
492 gteMAC1 = A1((((s64)CV1(cv) << 12) + (MX11(mx) * vx) + (MX12(mx) * vy) + (MX13(mx) * vz)) >> shift);
493 gteMAC2 = A2((((s64)CV2(cv) << 12) + (MX21(mx) * vx) + (MX22(mx) * vy) + (MX23(mx) * vz)) >> shift);
494 gteMAC3 = A3((((s64)CV3(cv) << 12) + (MX31(mx) * vx) + (MX32(mx) * vy) + (MX33(mx) * vz)) >> shift);
495
496 gteIR1 = limB1(gteMAC1, lm);
497 gteIR2 = limB2(gteMAC2, lm);
498 gteIR3 = limB3(gteMAC3, lm);
499}
500
f74fb727 501void gteNCLIP(psxCP2Regs *regs) {
ef79bbde
P		 502#ifdef GTE_LOG
503 GTE_LOG("GTE NCLIP\n");
504#endif
505 gteFLAG = 0;
506
507 gteMAC0 = F((s64)gteSX0 * (gteSY1 - gteSY2) +
508 gteSX1 * (gteSY2 - gteSY0) +
509 gteSX2 * (gteSY0 - gteSY1));
510}
511
f74fb727 512void gteAVSZ3(psxCP2Regs *regs) {
ef79bbde
P		 513#ifdef GTE_LOG
514 GTE_LOG("GTE AVSZ3\n");
515#endif
516 gteFLAG = 0;
517
b3254af9 518 gteMAC0 = F((s64)gteZSF3 * (gteSZ1 + gteSZ2 + gteSZ3));
ef79bbde
P		 519 gteOTZ = limD(gteMAC0 >> 12);
520}
521
f74fb727 522void gteAVSZ4(psxCP2Regs *regs) {
ef79bbde
P		 523#ifdef GTE_LOG
524 GTE_LOG("GTE AVSZ4\n");
525#endif
526 gteFLAG = 0;
527
b3254af9 528 gteMAC0 = F((s64)gteZSF4 * (gteSZ0 + gteSZ1 + gteSZ2 + gteSZ3));
ef79bbde
P		 529 gteOTZ = limD(gteMAC0 >> 12);
530}
531
f74fb727 532void gteSQR(psxCP2Regs *regs) {
ef79bbde
P		 533 int shift = 12 * GTE_SF(gteop);
534 int lm = GTE_LM(gteop);
535
536#ifdef GTE_LOG
537 GTE_LOG("GTE SQR\n");
538#endif
539 gteFLAG = 0;
540
b3254af9 541 gteMAC1 = (gteIR1 * gteIR1) >> shift;
542 gteMAC2 = (gteIR2 * gteIR2) >> shift;
543 gteMAC3 = (gteIR3 * gteIR3) >> shift;
7384197d 544 gteIR1 = limB1(gteMAC1, lm);
545 gteIR2 = limB2(gteMAC2, lm);
546 gteIR3 = limB3(gteMAC3, lm);
ef79bbde
P		 547}
548
f74fb727 549void gteNCCS(psxCP2Regs *regs) {
ef79bbde
P		 550#ifdef GTE_LOG
551 GTE_LOG("GTE NCCS\n");
552#endif
553 gteFLAG = 0;
554
b3254af9 555 gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
556 gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
557 gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
ef79bbde
P		 558 gteIR1 = limB1(gteMAC1, 1);
559 gteIR2 = limB2(gteMAC2, 1);
560 gteIR3 = limB3(gteMAC3, 1);
561 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
562 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
563 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
564 gteIR1 = limB1(gteMAC1, 1);
565 gteIR2 = limB2(gteMAC2, 1);
566 gteIR3 = limB3(gteMAC3, 1);
b3254af9 567 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
568 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
569 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
570 gteIR1 = gteMAC1;
571 gteIR2 = gteMAC2;
572 gteIR3 = gteMAC3;
ef79bbde
P		 573
574 gteRGB0 = gteRGB1;
575 gteRGB1 = gteRGB2;
576 gteCODE2 = gteCODE;
577 gteR2 = limC1(gteMAC1 >> 4);
578 gteG2 = limC2(gteMAC2 >> 4);
579 gteB2 = limC3(gteMAC3 >> 4);
580}
581
f74fb727 582void gteNCCT(psxCP2Regs *regs) {
ef79bbde
P		 583 int v;
584 s32 vx, vy, vz;
585
586#ifdef GTE_LOG
587 GTE_LOG("GTE NCCT\n");
588#endif
589 gteFLAG = 0;
590
591 for (v = 0; v < 3; v++) {
592 vx = VX(v);
593 vy = VY(v);
594 vz = VZ(v);
b3254af9 595 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
596 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
597 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 12;
ef79bbde
P		 598 gteIR1 = limB1(gteMAC1, 1);
599 gteIR2 = limB2(gteMAC2, 1);
600 gteIR3 = limB3(gteMAC3, 1);
601 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
602 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
603 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
604 gteIR1 = limB1(gteMAC1, 1);
605 gteIR2 = limB2(gteMAC2, 1);
606 gteIR3 = limB3(gteMAC3, 1);
b3254af9 607 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
608 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
609 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
ef79bbde
P		 610
611 gteRGB0 = gteRGB1;
612 gteRGB1 = gteRGB2;
613 gteCODE2 = gteCODE;
614 gteR2 = limC1(gteMAC1 >> 4);
615 gteG2 = limC2(gteMAC2 >> 4);
616 gteB2 = limC3(gteMAC3 >> 4);
617 }
b3254af9 618 gteIR1 = gteMAC1;
619 gteIR2 = gteMAC2;
620 gteIR3 = gteMAC3;
ef79bbde
P		 621}
622
f74fb727 623void gteNCDS(psxCP2Regs *regs) {
ef79bbde
P		 624#ifdef GTE_LOG
625 GTE_LOG("GTE NCDS\n");
626#endif
627 gteFLAG = 0;
628
b3254af9 629 gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
630 gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
631 gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
ef79bbde
P		 632 gteIR1 = limB1(gteMAC1, 1);
633 gteIR2 = limB2(gteMAC2, 1);
634 gteIR3 = limB3(gteMAC3, 1);
635 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
636 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
637 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
638 gteIR1 = limB1(gteMAC1, 1);
639 gteIR2 = limB2(gteMAC2, 1);
640 gteIR3 = limB3(gteMAC3, 1);
6c6c9590 641 gteMAC1 = (((gteR << 4) * gteIR1) + (gteIR0 * limB1(A1U((s64)gteRFC - ((gteR * gteIR1) >> 8)), 0))) >> 12;
642 gteMAC2 = (((gteG << 4) * gteIR2) + (gteIR0 * limB2(A2U((s64)gteGFC - ((gteG * gteIR2) >> 8)), 0))) >> 12;
643 gteMAC3 = (((gteB << 4) * gteIR3) + (gteIR0 * limB3(A3U((s64)gteBFC - ((gteB * gteIR3) >> 8)), 0))) >> 12;
ef79bbde
P		 644 gteIR1 = limB1(gteMAC1, 1);
645 gteIR2 = limB2(gteMAC2, 1);
646 gteIR3 = limB3(gteMAC3, 1);
647
648 gteRGB0 = gteRGB1;
649 gteRGB1 = gteRGB2;
650 gteCODE2 = gteCODE;
651 gteR2 = limC1(gteMAC1 >> 4);
652 gteG2 = limC2(gteMAC2 >> 4);
653 gteB2 = limC3(gteMAC3 >> 4);
654}
655
f74fb727 656void gteNCDT(psxCP2Regs *regs) {
ef79bbde
P		 657 int v;
658 s32 vx, vy, vz;
659
660#ifdef GTE_LOG
661 GTE_LOG("GTE NCDT\n");
662#endif
663 gteFLAG = 0;
664
665 for (v = 0; v < 3; v++) {
666 vx = VX(v);
667 vy = VY(v);
668 vz = VZ(v);
b3254af9 669 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
670 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
671 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 12;
ef79bbde
P		 672 gteIR1 = limB1(gteMAC1, 1);
673 gteIR2 = limB2(gteMAC2, 1);
674 gteIR3 = limB3(gteMAC3, 1);
675 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
676 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
677 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
678 gteIR1 = limB1(gteMAC1, 1);
679 gteIR2 = limB2(gteMAC2, 1);
680 gteIR3 = limB3(gteMAC3, 1);
6c6c9590 681 gteMAC1 = (((gteR << 4) * gteIR1) + (gteIR0 * limB1(A1U((s64)gteRFC - ((gteR * gteIR1) >> 8)), 0))) >> 12;
682 gteMAC2 = (((gteG << 4) * gteIR2) + (gteIR0 * limB2(A2U((s64)gteGFC - ((gteG * gteIR2) >> 8)), 0))) >> 12;
683 gteMAC3 = (((gteB << 4) * gteIR3) + (gteIR0 * limB3(A3U((s64)gteBFC - ((gteB * gteIR3) >> 8)), 0))) >> 12;
ef79bbde
P		 684
685 gteRGB0 = gteRGB1;
686 gteRGB1 = gteRGB2;
687 gteCODE2 = gteCODE;
688 gteR2 = limC1(gteMAC1 >> 4);
689 gteG2 = limC2(gteMAC2 >> 4);
690 gteB2 = limC3(gteMAC3 >> 4);
691 }
692 gteIR1 = limB1(gteMAC1, 1);
693 gteIR2 = limB2(gteMAC2, 1);
694 gteIR3 = limB3(gteMAC3, 1);
695}
696
f74fb727 697void gteOP(psxCP2Regs *regs) {
ef79bbde
P		 698 int shift = 12 * GTE_SF(gteop);
699 int lm = GTE_LM(gteop);
700
701#ifdef GTE_LOG
702 GTE_LOG("GTE OP\n");
703#endif
704 gteFLAG = 0;
705
b3254af9 706 gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> shift;
707 gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> shift;
708 gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> shift;
ef79bbde
P		 709 gteIR1 = limB1(gteMAC1, lm);
710 gteIR2 = limB2(gteMAC2, lm);
711 gteIR3 = limB3(gteMAC3, lm);
712}
713
f74fb727 714void gteDCPL(psxCP2Regs *regs) {
ef79bbde
P		 715 int lm = GTE_LM(gteop);
716
b3254af9 717 s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
718 s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
719 s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
ef79bbde
P		 720
721#ifdef GTE_LOG
722 GTE_LOG("GTE DCPL\n");
723#endif
724 gteFLAG = 0;
725
6c6c9590 726 gteMAC1 = RIR1 + ((gteIR0 * limB1(A1U((s64)gteRFC - RIR1), 0)) >> 12);
727 gteMAC2 = GIR2 + ((gteIR0 * limB1(A2U((s64)gteGFC - GIR2), 0)) >> 12);
728 gteMAC3 = BIR3 + ((gteIR0 * limB1(A3U((s64)gteBFC - BIR3), 0)) >> 12);
ef79bbde
P		 729
730 gteIR1 = limB1(gteMAC1, lm);
731 gteIR2 = limB2(gteMAC2, lm);
732 gteIR3 = limB3(gteMAC3, lm);
733
734 gteRGB0 = gteRGB1;
735 gteRGB1 = gteRGB2;
736 gteCODE2 = gteCODE;
737 gteR2 = limC1(gteMAC1 >> 4);
738 gteG2 = limC2(gteMAC2 >> 4);
739 gteB2 = limC3(gteMAC3 >> 4);
740}
741
f74fb727 742void gteGPF(psxCP2Regs *regs) {
ef79bbde
P		 743 int shift = 12 * GTE_SF(gteop);
744
745#ifdef GTE_LOG
746 GTE_LOG("GTE GPF\n");
747#endif
748 gteFLAG = 0;
749
b3254af9 750 gteMAC1 = (gteIR0 * gteIR1) >> shift;
751 gteMAC2 = (gteIR0 * gteIR2) >> shift;
752 gteMAC3 = (gteIR0 * gteIR3) >> shift;
ef79bbde
P		 753 gteIR1 = limB1(gteMAC1, 0);
754 gteIR2 = limB2(gteMAC2, 0);
755 gteIR3 = limB3(gteMAC3, 0);
756
757 gteRGB0 = gteRGB1;
758 gteRGB1 = gteRGB2;
759 gteCODE2 = gteCODE;
760 gteR2 = limC1(gteMAC1 >> 4);
761 gteG2 = limC2(gteMAC2 >> 4);
762 gteB2 = limC3(gteMAC3 >> 4);
763}
764
f74fb727 765void gteGPL(psxCP2Regs *regs) {
ef79bbde
P		 766 int shift = 12 * GTE_SF(gteop);
767
768#ifdef GTE_LOG
769 GTE_LOG("GTE GPL\n");
770#endif
771 gteFLAG = 0;
772
773 gteMAC1 = A1((((s64)gteMAC1 << shift) + (gteIR0 * gteIR1)) >> shift);
774 gteMAC2 = A2((((s64)gteMAC2 << shift) + (gteIR0 * gteIR2)) >> shift);
775 gteMAC3 = A3((((s64)gteMAC3 << shift) + (gteIR0 * gteIR3)) >> shift);
776 gteIR1 = limB1(gteMAC1, 0);
777 gteIR2 = limB2(gteMAC2, 0);
778 gteIR3 = limB3(gteMAC3, 0);
779
780 gteRGB0 = gteRGB1;
781 gteRGB1 = gteRGB2;
782 gteCODE2 = gteCODE;
783 gteR2 = limC1(gteMAC1 >> 4);
784 gteG2 = limC2(gteMAC2 >> 4);
785 gteB2 = limC3(gteMAC3 >> 4);
786}
787
f74fb727 788void gteDPCS(psxCP2Regs *regs) {
ef79bbde
P		 789 int shift = 12 * GTE_SF(gteop);
790
791#ifdef GTE_LOG
792 GTE_LOG("GTE DPCS\n");
793#endif
794 gteFLAG = 0;
795
6c6c9590 796 gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U(((s64)gteRFC - (gteR << 4)) << (12 - shift)), 0))) >> 12;
797 gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U(((s64)gteGFC - (gteG << 4)) << (12 - shift)), 0))) >> 12;
798 gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U(((s64)gteBFC - (gteB << 4)) << (12 - shift)), 0))) >> 12;
ef79bbde
P		 799
800 gteIR1 = limB1(gteMAC1, 0);
801 gteIR2 = limB2(gteMAC2, 0);
802 gteIR3 = limB3(gteMAC3, 0);
803 gteRGB0 = gteRGB1;
804 gteRGB1 = gteRGB2;
805 gteCODE2 = gteCODE;
806 gteR2 = limC1(gteMAC1 >> 4);
807 gteG2 = limC2(gteMAC2 >> 4);
808 gteB2 = limC3(gteMAC3 >> 4);
809}
810
f74fb727 811void gteDPCT(psxCP2Regs *regs) {
ef79bbde
P		 812 int v;
813
814#ifdef GTE_LOG
815 GTE_LOG("GTE DPCT\n");
816#endif
817 gteFLAG = 0;
818
819 for (v = 0; v < 3; v++) {
6c6c9590 820 gteMAC1 = ((gteR0 << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR0 << 4)), 0))) >> 12;
821 gteMAC2 = ((gteG0 << 16) + (gteIR0 * limB1(A2U((s64)gteGFC - (gteG0 << 4)), 0))) >> 12;
822 gteMAC3 = ((gteB0 << 16) + (gteIR0 * limB1(A3U((s64)gteBFC - (gteB0 << 4)), 0))) >> 12;
ef79bbde
P		 823
824 gteRGB0 = gteRGB1;
825 gteRGB1 = gteRGB2;
826 gteCODE2 = gteCODE;
827 gteR2 = limC1(gteMAC1 >> 4);
828 gteG2 = limC2(gteMAC2 >> 4);
829 gteB2 = limC3(gteMAC3 >> 4);
830 }
831 gteIR1 = limB1(gteMAC1, 0);
832 gteIR2 = limB2(gteMAC2, 0);
833 gteIR3 = limB3(gteMAC3, 0);
834}
835
f74fb727 836void gteNCS(psxCP2Regs *regs) {
ef79bbde
P		 837#ifdef GTE_LOG
838 GTE_LOG("GTE NCS\n");
839#endif
840 gteFLAG = 0;
841
b3254af9 842 gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
843 gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
844 gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
ef79bbde
P		 845 gteIR1 = limB1(gteMAC1, 1);
846 gteIR2 = limB2(gteMAC2, 1);
847 gteIR3 = limB3(gteMAC3, 1);
848 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
849 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
850 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
851 gteIR1 = limB1(gteMAC1, 1);
852 gteIR2 = limB2(gteMAC2, 1);
853 gteIR3 = limB3(gteMAC3, 1);
854
855 gteRGB0 = gteRGB1;
856 gteRGB1 = gteRGB2;
857 gteCODE2 = gteCODE;
858 gteR2 = limC1(gteMAC1 >> 4);
859 gteG2 = limC2(gteMAC2 >> 4);
860 gteB2 = limC3(gteMAC3 >> 4);
861}
862
f74fb727 863void gteNCT(psxCP2Regs *regs) {
ef79bbde
P		 864 int v;
865 s32 vx, vy, vz;
866
867#ifdef GTE_LOG
868 GTE_LOG("GTE NCT\n");
869#endif
870 gteFLAG = 0;
871
872 for (v = 0; v < 3; v++) {
873 vx = VX(v);
874 vy = VY(v);
875 vz = VZ(v);
b3254af9 876 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
877 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
878 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 12;
ef79bbde
P		 879 gteIR1 = limB1(gteMAC1, 1);
880 gteIR2 = limB2(gteMAC2, 1);
881 gteIR3 = limB3(gteMAC3, 1);
882 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
883 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
884 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
885 gteRGB0 = gteRGB1;
886 gteRGB1 = gteRGB2;
887 gteCODE2 = gteCODE;
888 gteR2 = limC1(gteMAC1 >> 4);
889 gteG2 = limC2(gteMAC2 >> 4);
890 gteB2 = limC3(gteMAC3 >> 4);
891 }
892 gteIR1 = limB1(gteMAC1, 1);
893 gteIR2 = limB2(gteMAC2, 1);
894 gteIR3 = limB3(gteMAC3, 1);
895}
896
f74fb727 897void gteCC(psxCP2Regs *regs) {
ef79bbde
P		 898#ifdef GTE_LOG
899 GTE_LOG("GTE CC\n");
900#endif
901 gteFLAG = 0;
902
903 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
904 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
905 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
906 gteIR1 = limB1(gteMAC1, 1);
907 gteIR2 = limB2(gteMAC2, 1);
908 gteIR3 = limB3(gteMAC3, 1);
b3254af9 909 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
910 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
911 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
ef79bbde
P		 912 gteIR1 = limB1(gteMAC1, 1);
913 gteIR2 = limB2(gteMAC2, 1);
914 gteIR3 = limB3(gteMAC3, 1);
915
916 gteRGB0 = gteRGB1;
917 gteRGB1 = gteRGB2;
918 gteCODE2 = gteCODE;
919 gteR2 = limC1(gteMAC1 >> 4);
920 gteG2 = limC2(gteMAC2 >> 4);
921 gteB2 = limC3(gteMAC3 >> 4);
922}
923
f74fb727 924void gteINTPL(psxCP2Regs *regs) {
ef79bbde
P		 925 int shift = 12 * GTE_SF(gteop);
926 int lm = GTE_LM(gteop);
927
928#ifdef GTE_LOG
929 GTE_LOG("GTE INTPL\n");
930#endif
931 gteFLAG = 0;
932
6c6c9590 933 gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0))) >> shift;
934 gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0))) >> shift;
935 gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0))) >> shift;
ef79bbde
P		 936 gteIR1 = limB1(gteMAC1, lm);
937 gteIR2 = limB2(gteMAC2, lm);
938 gteIR3 = limB3(gteMAC3, lm);
939 gteRGB0 = gteRGB1;
940 gteRGB1 = gteRGB2;
941 gteCODE2 = gteCODE;
942 gteR2 = limC1(gteMAC1 >> 4);
943 gteG2 = limC2(gteMAC2 >> 4);
944 gteB2 = limC3(gteMAC3 >> 4);
945}
946
f74fb727 947void gteCDP(psxCP2Regs *regs) {
ef79bbde
P		 948#ifdef GTE_LOG
949 GTE_LOG("GTE CDP\n");
950#endif
951 gteFLAG = 0;
952
953 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
954 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
955 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
956 gteIR1 = limB1(gteMAC1, 1);
957 gteIR2 = limB2(gteMAC2, 1);
958 gteIR3 = limB3(gteMAC3, 1);
6c6c9590 959 gteMAC1 = (((gteR << 4) * gteIR1) + (gteIR0 * limB1(A1U((s64)gteRFC - ((gteR * gteIR1) >> 8)), 0))) >> 12;
960 gteMAC2 = (((gteG << 4) * gteIR2) + (gteIR0 * limB2(A2U((s64)gteGFC - ((gteG * gteIR2) >> 8)), 0))) >> 12;
961 gteMAC3 = (((gteB << 4) * gteIR3) + (gteIR0 * limB3(A3U((s64)gteBFC - ((gteB * gteIR3) >> 8)), 0))) >> 12;
ef79bbde
P		 962 gteIR1 = limB1(gteMAC1, 1);
963 gteIR2 = limB2(gteMAC2, 1);
964 gteIR3 = limB3(gteMAC3, 1);
965
966 gteRGB0 = gteRGB1;
967 gteRGB1 = gteRGB2;
968 gteCODE2 = gteCODE;
969 gteR2 = limC1(gteMAC1 >> 4);
970 gteG2 = limC2(gteMAC2 >> 4);
971 gteB2 = limC3(gteMAC3 >> 4);
972}
6c0eefaf 973
974/* decomposed/parametrized versions for the recompiler */
975
976#ifndef FLAGLESS
977
978void gteSQR_part_noshift(psxCP2Regs *regs) {
979 gteFLAG = 0;
980
981 gteMAC1 = gteIR1 * gteIR1;
982 gteMAC2 = gteIR2 * gteIR2;
983 gteMAC3 = gteIR3 * gteIR3;
984}
985
986void gteSQR_part_shift(psxCP2Regs *regs) {
987 gteFLAG = 0;
988
989 gteMAC1 = (gteIR1 * gteIR1) >> 12;
990 gteMAC2 = (gteIR2 * gteIR2) >> 12;
991 gteMAC3 = (gteIR3 * gteIR3) >> 12;
992}
993
994void gteOP_part_noshift(psxCP2Regs *regs) {
995 gteFLAG = 0;
996
997 gteMAC1 = (gteR22 * gteIR3) - (gteR33 * gteIR2);
998 gteMAC2 = (gteR33 * gteIR1) - (gteR11 * gteIR3);
999 gteMAC3 = (gteR11 * gteIR2) - (gteR22 * gteIR1);
1000}
1001
1002void gteOP_part_shift(psxCP2Regs *regs) {
1003 gteFLAG = 0;
1004
1005 gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> 12;
1006 gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> 12;
1007 gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> 12;
1008}
1009
1010void gteDCPL_part(psxCP2Regs *regs) {
1011 s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
1012 s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
1013 s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
1014
1015 gteFLAG = 0;
1016
1017 gteMAC1 = RIR1 + ((gteIR0 * limB1(A1U((s64)gteRFC - RIR1), 0)) >> 12);
1018 gteMAC2 = GIR2 + ((gteIR0 * limB1(A2U((s64)gteGFC - GIR2), 0)) >> 12);
1019 gteMAC3 = BIR3 + ((gteIR0 * limB1(A3U((s64)gteBFC - BIR3), 0)) >> 12);
1020}
1021
1022void gteGPF_part_noshift(psxCP2Regs *regs) {
1023 gteFLAG = 0;
1024
1025 gteMAC1 = gteIR0 * gteIR1;
1026 gteMAC2 = gteIR0 * gteIR2;
1027 gteMAC3 = gteIR0 * gteIR3;
1028}
1029
1030void gteGPF_part_shift(psxCP2Regs *regs) {
1031 gteFLAG = 0;
1032
1033 gteMAC1 = (gteIR0 * gteIR1) >> 12;
1034 gteMAC2 = (gteIR0 * gteIR2) >> 12;
1035 gteMAC3 = (gteIR0 * gteIR3) >> 12;
1036}
1037
1038#endif // !FLAGLESS
1039
1040void gteGPL_part_noshift(psxCP2Regs *regs) {
1041 gteFLAG = 0;
1042
1043 gteMAC1 = A1((s64)gteMAC1 + (gteIR0 * gteIR1));
1044 gteMAC2 = A2((s64)gteMAC2 + (gteIR0 * gteIR2));
1045 gteMAC3 = A3((s64)gteMAC3 + (gteIR0 * gteIR3));
1046}
1047
1048void gteGPL_part_shift(psxCP2Regs *regs) {
1049 gteFLAG = 0;
1050
1051 gteMAC1 = A1((s64)gteMAC1 + ((gteIR0 * gteIR1) >> 12));
1052 gteMAC2 = A2((s64)gteMAC2 + ((gteIR0 * gteIR2) >> 12));
1053 gteMAC3 = A3((s64)gteMAC3 + ((gteIR0 * gteIR3) >> 12));
1054}
1055
1056void gteDPCS_part_noshift(psxCP2Regs *regs) {
1057 int shift = 0;
1058
1059 gteFLAG = 0;
1060
1061 gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR << 4)) << (12 - shift), 0))) >> 12;
1062 gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U((s64)gteGFC - (gteG << 4)) << (12 - shift), 0))) >> 12;
1063 gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U((s64)gteBFC - (gteB << 4)) << (12 - shift), 0))) >> 12;
1064}
1065
1066void gteDPCS_part_shift(psxCP2Regs *regs) {
1067 int shift = 12;
1068
1069 gteFLAG = 0;
1070
1071 gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR << 4)) << (12 - shift), 0))) >> 12;
1072 gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U((s64)gteGFC - (gteG << 4)) << (12 - shift), 0))) >> 12;
1073 gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U((s64)gteBFC - (gteB << 4)) << (12 - shift), 0))) >> 12;
1074}
1075
1076void gteINTPL_part_noshift(psxCP2Regs *regs) {
1077 gteFLAG = 0;
1078
1079 gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0)));
1080 gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0)));
1081 gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0)));
1082}
1083
1084void gteINTPL_part_shift(psxCP2Regs *regs) {
1085 gteFLAG = 0;
1086
1087 gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0))) >> 12;
1088 gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0))) >> 12;
1089 gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0))) >> 12;
1090}
1091
1092void gteMACtoRGB(psxCP2Regs *regs) {
1093 gteRGB0 = gteRGB1;
1094 gteRGB1 = gteRGB2;
1095 gteCODE2 = gteCODE;
1096 gteR2 = limC1(gteMAC1 >> 4);
1097 gteG2 = limC2(gteMAC2 >> 4);
1098 gteB2 = limC3(gteMAC3 >> 4);
1099}
1100
ARM optimized PCSX fork