/[pcsx2_0.9.7]/trunk/pcsx2/VUops.cpp
ViewVC logotype

Contents of /trunk/pcsx2/VUops.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 31 - (show annotations) (download)
Tue Sep 7 03:24:11 2010 UTC (9 years, 9 months ago) by william
File size: 105750 byte(s)
committing r3113 initial commit again...
1 /* PCSX2 - PS2 Emulator for PCs
2 * Copyright (C) 2002-2010 PCSX2 Dev Team
3 *
4 * PCSX2 is free software: you can redistribute it and/or modify it under the terms
5 * of the GNU Lesser General Public License as published by the Free Software Found-
6 * ation, either version 3 of the License, or (at your option) any later version.
7 *
8 * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
9 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
10 * PURPOSE. See the GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License along with PCSX2.
13 * If not, see <http://www.gnu.org/licenses/>.
14 */
15
16 #include "PrecompiledHeader.h"
17 #include "Common.h"
18
19 #include <cmath>
20
21 #include "VUops.h"
22 #include "GS.h"
23
24 //Lower/Upper instructions can use that..
25 #define _Ft_ ((VU->code >> 16) & 0x1F) // The rt part of the instruction register
26 #define _Fs_ ((VU->code >> 11) & 0x1F) // The rd part of the instruction register
27 #define _Fd_ ((VU->code >> 6) & 0x1F) // The sa part of the instruction register
28 #define _It_ (_Ft_ & 0xF)
29 #define _Is_ (_Fs_ & 0xF)
30 #define _Id_ (_Fd_ & 0xF)
31
32 #define _X ((VU->code>>24) & 0x1)
33 #define _Y ((VU->code>>23) & 0x1)
34 #define _Z ((VU->code>>22) & 0x1)
35 #define _W ((VU->code>>21) & 0x1)
36
37 #define _XYZW ((VU->code>>21) & 0xF)
38
39 #define _Fsf_ ((VU->code >> 21) & 0x03)
40 #define _Ftf_ ((VU->code >> 23) & 0x03)
41
42 #define _Imm11_ (s32)(VU->code & 0x400 ? 0xfffffc00 | (VU->code & 0x3ff) : VU->code & 0x3ff)
43 #define _UImm11_ (s32)(VU->code & 0x7ff)
44
45
46 static __aligned16 VECTOR RDzero;
47
48 static __releaseinline void __fastcall _vuFMACflush(VURegs * VU) {
49 int i;
50
51 for (i=0; i<8; i++) {
52 if (VU->fmac[i].enable == 0) continue;
53
54 if ((VU->cycle - VU->fmac[i].sCycle) >= VU->fmac[i].Cycle) {
55 VUM_LOG("flushing FMAC pipe[%d] (macflag=%x)", i, VU->fmac[i].macflag);
56
57 VU->fmac[i].enable = 0;
58 VU->VI[REG_MAC_FLAG].UL = VU->fmac[i].macflag;
59 VU->VI[REG_STATUS_FLAG].UL = VU->fmac[i].statusflag;
60 VU->VI[REG_CLIP_FLAG].UL = VU->fmac[i].clipflag;
61 }
62 }
63 }
64
65 static __releaseinline void __fastcall _vuFDIVflush(VURegs * VU) {
66 if (VU->fdiv.enable == 0) return;
67
68 if ((VU->cycle - VU->fdiv.sCycle) >= VU->fdiv.Cycle) {
69 VUM_LOG("flushing FDIV pipe");
70
71 VU->fdiv.enable = 0;
72 VU->VI[REG_Q].UL = VU->fdiv.reg.UL;
73 VU->VI[REG_STATUS_FLAG].UL = VU->fdiv.statusflag;
74 }
75 }
76
77 static __releaseinline void __fastcall _vuEFUflush(VURegs * VU) {
78 if (VU->efu.enable == 0) return;
79
80 if ((VU->cycle - VU->efu.sCycle) >= VU->efu.Cycle) {
81 // VUM_LOG("flushing EFU pipe");
82
83 VU->efu.enable = 0;
84 VU->VI[REG_P].UL = VU->efu.reg.UL;
85 }
86 }
87
88 // called at end of program
89 void _vuFlushAll(VURegs* VU)
90 {
91 int nRepeat = 1, i;
92
93 do {
94 nRepeat = 0;
95
96 for (i=0; i<8; i++) {
97 if (VU->fmac[i].enable == 0) continue;
98
99 nRepeat = 1;
100
101 if ((VU->cycle - VU->fmac[i].sCycle) >= VU->fmac[i].Cycle) {
102 VUM_LOG("flushing FMAC pipe[%d] (macflag=%x)", i, VU->fmac[i].macflag);
103
104 VU->fmac[i].enable = 0;
105 VU->VI[REG_MAC_FLAG].UL = VU->fmac[i].macflag;
106 VU->VI[REG_STATUS_FLAG].UL = VU->fmac[i].statusflag;
107 VU->VI[REG_CLIP_FLAG].UL = VU->fmac[i].clipflag;
108 }
109 }
110
111 if (VU->fdiv.enable ) {
112
113 nRepeat = 1;
114
115 if ((VU->cycle - VU->fdiv.sCycle) >= VU->fdiv.Cycle) {
116 VUM_LOG("flushing FDIV pipe");
117
118 nRepeat = 1;
119 VU->fdiv.enable = 0;
120 VU->VI[REG_Q].UL = VU->fdiv.reg.UL;
121 VU->VI[REG_STATUS_FLAG].UL = VU->fdiv.statusflag;
122 }
123 }
124
125 if (VU->efu.enable) {
126
127 nRepeat = 1;
128
129 if ((VU->cycle - VU->efu.sCycle) >= VU->efu.Cycle) {
130 // VUM_LOG("flushing EFU pipe");
131
132 nRepeat = 1;
133 VU->efu.enable = 0;
134 VU->VI[REG_P].UL = VU->efu.reg.UL;
135 }
136 }
137
138 VU->cycle++;
139
140 } while(nRepeat);
141 }
142
143 __forceinline void _vuTestPipes(VURegs * VU) {
144 _vuFMACflush(VU);
145 _vuFDIVflush(VU);
146 _vuEFUflush(VU);
147 }
148
149 static void __fastcall _vuFMACTestStall(VURegs * VU, int reg, int xyzw) {
150 int cycle;
151 int i;
152
153 for (i=0; i<8; i++) {
154 if (VU->fmac[i].enable == 0) continue;
155 if (VU->fmac[i].reg == reg &&
156 VU->fmac[i].xyzw & xyzw) break;
157 }
158
159 if (i == 8) return;
160
161 cycle = VU->fmac[i].Cycle - (VU->cycle - VU->fmac[i].sCycle) + 1; // add 1 delay! (fixes segaclassics bad geom)
162 VU->fmac[i].enable = 0;
163 VU->VI[REG_MAC_FLAG].UL = VU->fmac[i].macflag;
164 VU->VI[REG_STATUS_FLAG].UL = VU->fmac[i].statusflag;
165 VU->VI[REG_CLIP_FLAG].UL = VU->fmac[i].clipflag;
166 VUM_LOG("FMAC[%d] stall %d", i, cycle);
167
168 VU->cycle+= cycle;
169 _vuTestPipes(VU);
170 }
171
172 static __releaseinline void __fastcall _vuFMACAdd(VURegs * VU, int reg, int xyzw) {
173 int i;
174
175 /* find a free fmac pipe */
176 for (i=0; i<8; i++) {
177 if (VU->fmac[i].enable == 1) continue;
178 break;
179 }
180 //if (i==8) Console.Error("*PCSX2*: error , out of fmacs %d", VU->cycle);
181
182
183 VUM_LOG("adding FMAC pipe[%d]; xyzw=%x", i, xyzw);
184
185 VU->fmac[i].enable = 1;
186 VU->fmac[i].sCycle = VU->cycle;
187 VU->fmac[i].Cycle = 3;
188 VU->fmac[i].reg = reg;
189 VU->fmac[i].xyzw = xyzw;
190 VU->fmac[i].macflag = VU->macflag;
191 VU->fmac[i].statusflag = VU->statusflag;
192 VU->fmac[i].clipflag = VU->clipflag;
193 }
194
195 static __releaseinline void __fastcall _vuFDIVAdd(VURegs * VU, int cycles) {
196 VUM_LOG("adding FDIV pipe");
197
198 VU->fdiv.enable = 1;
199 VU->fdiv.sCycle = VU->cycle;
200 VU->fdiv.Cycle = cycles;
201 VU->fdiv.reg.F = VU->q.F;
202 VU->fdiv.statusflag = VU->statusflag;
203 }
204
205 static __releaseinline void __fastcall _vuEFUAdd(VURegs * VU, int cycles) {
206 // VUM_LOG("adding EFU pipe\n");
207
208 VU->efu.enable = 1;
209 VU->efu.sCycle = VU->cycle;
210 VU->efu.Cycle = cycles;
211 VU->efu.reg.F = VU->p.F;
212 }
213
214 static __releaseinline void __fastcall _vuFlushFDIV(VURegs * VU) {
215 int cycle;
216
217 if (VU->fdiv.enable == 0) return;
218
219 cycle = VU->fdiv.Cycle - (VU->cycle - VU->fdiv.sCycle);
220 VUM_LOG("waiting FDIV pipe %d", cycle);
221
222 VU->fdiv.enable = 0;
223 VU->cycle+= cycle;
224 VU->VI[REG_Q].UL = VU->fdiv.reg.UL;
225 VU->VI[REG_STATUS_FLAG].UL = VU->fdiv.statusflag;
226 }
227
228 static __releaseinline void __fastcall _vuFlushEFU(VURegs * VU) {
229 int cycle;
230
231 if (VU->efu.enable == 0) return;
232
233 cycle = VU->efu.Cycle - (VU->cycle - VU->efu.sCycle);
234 // VUM_LOG("waiting EFU pipe %d", cycle);
235
236 VU->efu.enable = 0;
237 VU->cycle+= cycle;
238 VU->VI[REG_P].UL = VU->efu.reg.UL;
239 }
240
241 __forceinline void _vuTestFMACStalls(VURegs * VU, _VURegsNum *VUregsn) {
242 if (VUregsn->VFread0) {
243 _vuFMACTestStall(VU, VUregsn->VFread0, VUregsn->VFr0xyzw);
244 }
245 if (VUregsn->VFread1) {
246 _vuFMACTestStall(VU, VUregsn->VFread1, VUregsn->VFr1xyzw);
247 }
248 }
249
250 __forceinline void _vuAddFMACStalls(VURegs * VU, _VURegsNum *VUregsn) {
251 if (VUregsn->VFwrite) {
252 _vuFMACAdd(VU, VUregsn->VFwrite, VUregsn->VFwxyzw);
253 } else
254 if (VUregsn->VIwrite & (1 << REG_CLIP_FLAG)) {
255 _vuFMACAdd(VU, -REG_CLIP_FLAG, 0);
256 } else {
257 _vuFMACAdd(VU, 0, 0);
258 }
259 }
260
261 __forceinline void _vuTestFDIVStalls(VURegs * VU, _VURegsNum *VUregsn) {
262 // _vuTestFMACStalls(VURegs * VU, _VURegsNum *VUregsn);
263 _vuFlushFDIV(VU);
264 }
265
266 __forceinline void _vuAddFDIVStalls(VURegs * VU, _VURegsNum *VUregsn) {
267 if (VUregsn->VIwrite & (1 << REG_Q)) {
268 _vuFDIVAdd(VU, VUregsn->cycles);
269 }
270 }
271
272
273 __forceinline void _vuTestEFUStalls(VURegs * VU, _VURegsNum *VUregsn) {
274 // _vuTestFMACStalls(VURegs * VU, _VURegsNum *VUregsn);
275 _vuFlushEFU(VU);
276 }
277
278 __forceinline void _vuAddEFUStalls(VURegs * VU, _VURegsNum *VUregsn) {
279 if (VUregsn->VIwrite & (1 << REG_P)) {
280 _vuEFUAdd(VU, VUregsn->cycles);
281 }
282 }
283
284 __forceinline void _vuTestUpperStalls(VURegs * VU, _VURegsNum *VUregsn) {
285 switch (VUregsn->pipe) {
286 case VUPIPE_FMAC: _vuTestFMACStalls(VU, VUregsn); break;
287 }
288 }
289
290 __forceinline void _vuTestLowerStalls(VURegs * VU, _VURegsNum *VUregsn) {
291 switch (VUregsn->pipe) {
292 case VUPIPE_FMAC: _vuTestFMACStalls(VU, VUregsn); break;
293 case VUPIPE_FDIV: _vuTestFDIVStalls(VU, VUregsn); break;
294 case VUPIPE_EFU: _vuTestEFUStalls(VU, VUregsn); break;
295 }
296 }
297
298 __forceinline void _vuAddUpperStalls(VURegs * VU, _VURegsNum *VUregsn) {
299 switch (VUregsn->pipe) {
300 case VUPIPE_FMAC: _vuAddFMACStalls(VU, VUregsn); break;
301 }
302 }
303
304 __forceinline void _vuAddLowerStalls(VURegs * VU, _VURegsNum *VUregsn) {
305 switch (VUregsn->pipe) {
306 case VUPIPE_FMAC: _vuAddFMACStalls(VU, VUregsn); break;
307 case VUPIPE_FDIV: _vuAddFDIVStalls(VU, VUregsn); break;
308 case VUPIPE_EFU: _vuAddEFUStalls(VU, VUregsn); break;
309 }
310 }
311
312
313 /******************************/
314 /* VU Upper instructions */
315 /******************************/
316 #ifndef INT_VUDOUBLEHACK
317 static float __fastcall vuDouble(u32 f)
318 {
319 switch(f & 0x7f800000)
320 {
321 case 0x0:
322 f &= 0x80000000;
323 return *(float*)&f;
324 break;
325 case 0x7f800000:
326 {
327 u32 d = (f & 0x80000000)|0x7f7fffff;
328 return *(float*)&d;
329 break;
330 }
331 }
332 return *(float*)&f;
333 }
334 #else
335 static __forceinline float vuDouble(u32 f)
336 {
337 return *(float*)&f;
338 }
339 #endif
340
341 void _vuABS(VURegs * VU) {
342 if (_Ft_ == 0) return;
343
344 if (_X){ VU->VF[_Ft_].f.x = fabs(vuDouble(VU->VF[_Fs_].i.x)); }
345 if (_Y){ VU->VF[_Ft_].f.y = fabs(vuDouble(VU->VF[_Fs_].i.y)); }
346 if (_Z){ VU->VF[_Ft_].f.z = fabs(vuDouble(VU->VF[_Fs_].i.z)); }
347 if (_W){ VU->VF[_Ft_].f.w = fabs(vuDouble(VU->VF[_Fs_].i.w)); }
348 }/*Reworked from define to function. asadr*/
349
350
351 void _vuADD(VURegs * VU) {
352 VECTOR * dst;
353 if (_Fd_ == 0) dst = &RDzero;
354 else dst = &VU->VF[_Fd_];
355
356 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACx_CLEAR(VU);
357 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACy_CLEAR(VU);
358 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACz_CLEAR(VU);
359 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACw_CLEAR(VU);
360 VU_STAT_UPDATE(VU);
361 }/*Reworked from define to function. asadr*/
362
363
364 void _vuADDi(VURegs * VU) {
365 VECTOR * dst;
366 if (_Fd_ == 0) dst = &RDzero;
367 else dst = &VU->VF[_Fd_];
368
369 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + vuDouble(VU->VI[REG_I].UL));} else VU_MACx_CLEAR(VU);
370 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + vuDouble(VU->VI[REG_I].UL));} else VU_MACy_CLEAR(VU);
371 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + vuDouble(VU->VI[REG_I].UL));} else VU_MACz_CLEAR(VU);
372 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + vuDouble(VU->VI[REG_I].UL));} else VU_MACw_CLEAR(VU);
373 VU_STAT_UPDATE(VU);
374 }/*Reworked from define to function. asadr*/
375
376 void _vuADDq(VURegs * VU) {
377 VECTOR * dst;
378 if (_Fd_ == 0) dst = &RDzero;
379 else dst = &VU->VF[_Fd_];
380
381 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + vuDouble(VU->VI[REG_Q].UL)); } else VU_MACx_CLEAR(VU);
382 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + vuDouble(VU->VI[REG_Q].UL)); } else VU_MACy_CLEAR(VU);
383 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + vuDouble(VU->VI[REG_Q].UL)); } else VU_MACz_CLEAR(VU);
384 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + vuDouble(VU->VI[REG_Q].UL)); } else VU_MACw_CLEAR(VU);
385 VU_STAT_UPDATE(VU);
386 }/*Reworked from define to function. asadr*/
387
388
389 void _vuADDx(VURegs * VU) {
390 float ftx;
391 VECTOR * dst;
392 if (_Fd_ == 0) dst = &RDzero;
393 else dst = &VU->VF[_Fd_];
394
395 ftx=vuDouble(VU->VF[_Ft_].i.x);
396 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + ftx); } else VU_MACx_CLEAR(VU);
397 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + ftx); } else VU_MACy_CLEAR(VU);
398 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + ftx); } else VU_MACz_CLEAR(VU);
399 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + ftx); } else VU_MACw_CLEAR(VU);
400 VU_STAT_UPDATE(VU);
401 }/*Reworked from define to function. asadr*/
402
403 void _vuADDy(VURegs * VU) {
404 float fty;
405 VECTOR * dst;
406 if (_Fd_ == 0) dst = &RDzero;
407 else dst = &VU->VF[_Fd_];
408
409 fty=vuDouble(VU->VF[_Ft_].i.y);
410 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + fty);} else VU_MACx_CLEAR(VU);
411 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + fty);} else VU_MACy_CLEAR(VU);
412 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + fty);} else VU_MACz_CLEAR(VU);
413 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + fty);} else VU_MACw_CLEAR(VU);
414 VU_STAT_UPDATE(VU);
415 }/*Reworked from define to function. asadr*/
416
417 void _vuADDz(VURegs * VU) {
418 float ftz;
419 VECTOR * dst;
420 if (_Fd_ == 0) dst = &RDzero;
421 else dst = &VU->VF[_Fd_];
422
423 ftz=vuDouble(VU->VF[_Ft_].i.z);
424 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + ftz); } else VU_MACx_CLEAR(VU);
425 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + ftz); } else VU_MACy_CLEAR(VU);
426 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + ftz); } else VU_MACz_CLEAR(VU);
427 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + ftz); } else VU_MACw_CLEAR(VU);
428 VU_STAT_UPDATE(VU);
429 }/*Reworked from define to function. asadr*/
430
431 void _vuADDw(VURegs * VU) {
432 float ftw;
433 VECTOR * dst;
434 if (_Fd_ == 0) dst = &RDzero;
435 else dst = &VU->VF[_Fd_];
436
437 ftw=vuDouble(VU->VF[_Ft_].i.w);
438 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + ftw); } else VU_MACx_CLEAR(VU);
439 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + ftw); } else VU_MACy_CLEAR(VU);
440 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + ftw); } else VU_MACz_CLEAR(VU);
441 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + ftw); } else VU_MACw_CLEAR(VU);
442 VU_STAT_UPDATE(VU);
443 }/*Reworked from define to function. asadr*/
444
445 void _vuADDA(VURegs * VU) {
446 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACx_CLEAR(VU);
447 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACy_CLEAR(VU);
448 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACz_CLEAR(VU);
449 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACw_CLEAR(VU);
450 VU_STAT_UPDATE(VU);
451 }/*Reworked from define to function. asadr*/
452
453 void _vuADDAi(VURegs * VU) {
454 float ti = vuDouble(VU->VI[REG_I].UL);
455
456 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + ti); } else VU_MACx_CLEAR(VU);
457 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + ti); } else VU_MACy_CLEAR(VU);
458 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + ti); } else VU_MACz_CLEAR(VU);
459 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + ti); } else VU_MACw_CLEAR(VU);
460 VU_STAT_UPDATE(VU);
461 }/*Reworked from define to function. asadr*/
462
463 void _vuADDAq(VURegs * VU) {
464 float tf = vuDouble(VU->VI[REG_Q].UL);
465
466 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + tf); } else VU_MACx_CLEAR(VU);
467 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + tf); } else VU_MACy_CLEAR(VU);
468 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + tf); } else VU_MACz_CLEAR(VU);
469 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + tf); } else VU_MACw_CLEAR(VU);
470 VU_STAT_UPDATE(VU);
471 }/*Reworked from define to function. asadr*/
472
473 void _vuADDAx(VURegs * VU) {
474 float tx = vuDouble(VU->VF[_Ft_].i.x);
475
476 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + tx); } else VU_MACx_CLEAR(VU);
477 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + tx); } else VU_MACy_CLEAR(VU);
478 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + tx); } else VU_MACz_CLEAR(VU);
479 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + tx); } else VU_MACw_CLEAR(VU);
480 VU_STAT_UPDATE(VU);
481 }/*Reworked from define to function. asadr*/
482
483 void _vuADDAy(VURegs * VU) {
484 float ty = vuDouble(VU->VF[_Ft_].i.y);
485
486 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + ty); } else VU_MACx_CLEAR(VU);
487 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + ty); } else VU_MACy_CLEAR(VU);
488 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + ty); } else VU_MACz_CLEAR(VU);
489 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + ty); } else VU_MACw_CLEAR(VU);
490 VU_STAT_UPDATE(VU);
491 }/*Reworked from define to function. asadr*/
492
493 void _vuADDAz(VURegs * VU) {
494 float tz = vuDouble(VU->VF[_Ft_].i.z);
495
496 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + tz); } else VU_MACx_CLEAR(VU);
497 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + tz); } else VU_MACy_CLEAR(VU);
498 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + tz); } else VU_MACz_CLEAR(VU);
499 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + tz); } else VU_MACw_CLEAR(VU);
500 VU_STAT_UPDATE(VU);
501 }/*Reworked from define to function. asadr*/
502
503 void _vuADDAw(VURegs * VU) {
504 float tw = vuDouble(VU->VF[_Ft_].i.w);
505
506 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + tw); } else VU_MACx_CLEAR(VU);
507 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + tw); } else VU_MACy_CLEAR(VU);
508 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + tw); } else VU_MACz_CLEAR(VU);
509 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + tw); } else VU_MACw_CLEAR(VU);
510 VU_STAT_UPDATE(VU);
511 }/*Reworked from define to function. asadr*/
512
513
514 void _vuSUB(VURegs * VU) {
515 VECTOR * dst;
516 if (_Fd_ == 0) dst = &RDzero;
517 else dst = &VU->VF[_Fd_];
518
519 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACx_CLEAR(VU);
520 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACy_CLEAR(VU);
521 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACz_CLEAR(VU);
522 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACw_CLEAR(VU);
523 VU_STAT_UPDATE(VU);
524 }//updated 10/05/03 shadow
525
526 void _vuSUBi(VURegs * VU) {
527 VECTOR * dst;
528 if (_Fd_ == 0) dst = &RDzero;
529 else dst = &VU->VF[_Fd_];
530
531 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - vuDouble(VU->VI[REG_I].UL)); } else VU_MACx_CLEAR(VU);
532 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - vuDouble(VU->VI[REG_I].UL)); } else VU_MACy_CLEAR(VU);
533 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - vuDouble(VU->VI[REG_I].UL)); } else VU_MACz_CLEAR(VU);
534 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - vuDouble(VU->VI[REG_I].UL)); } else VU_MACw_CLEAR(VU);
535 VU_STAT_UPDATE(VU);
536 }//updated 10/05/03 shadow
537
538 void _vuSUBq(VURegs * VU) {
539 VECTOR * dst;
540 if (_Fd_ == 0) dst = &RDzero;
541 else dst = &VU->VF[_Fd_];
542
543 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - vuDouble(VU->VI[REG_Q].UL)); } else VU_MACx_CLEAR(VU);
544 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - vuDouble(VU->VI[REG_Q].UL)); } else VU_MACy_CLEAR(VU);
545 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - vuDouble(VU->VI[REG_Q].UL)); } else VU_MACz_CLEAR(VU);
546 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - vuDouble(VU->VI[REG_Q].UL)); } else VU_MACw_CLEAR(VU);
547 VU_STAT_UPDATE(VU);
548 }//updated 10/05/03 shadow
549
550 void _vuSUBx(VURegs * VU) {
551 float ftx;
552 VECTOR * dst;
553 if (_Fd_ == 0) dst = &RDzero;
554 else dst = &VU->VF[_Fd_];
555
556 ftx=vuDouble(VU->VF[_Ft_].i.x);
557 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - ftx); } else VU_MACx_CLEAR(VU);
558 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - ftx); } else VU_MACy_CLEAR(VU);
559 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - ftx); } else VU_MACz_CLEAR(VU);
560 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - ftx); } else VU_MACw_CLEAR(VU);
561 VU_STAT_UPDATE(VU);
562 }//updated 10/05/03 shadow
563
564 void _vuSUBy(VURegs * VU) {
565 float fty;
566 VECTOR * dst;
567 if (_Fd_ == 0) dst = &RDzero;
568 else dst = &VU->VF[_Fd_];
569
570 fty=vuDouble(VU->VF[_Ft_].i.y);
571 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - fty); } else VU_MACx_CLEAR(VU);
572 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - fty); } else VU_MACy_CLEAR(VU);
573 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - fty); } else VU_MACz_CLEAR(VU);
574 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - fty); } else VU_MACw_CLEAR(VU);
575 VU_STAT_UPDATE(VU);
576 }//updated 10/05/03 shadow
577
578 void _vuSUBz(VURegs * VU) {
579 float ftz;
580 VECTOR * dst;
581 if (_Fd_ == 0) dst = &RDzero;
582 else dst = &VU->VF[_Fd_];
583
584 ftz=vuDouble(VU->VF[_Ft_].i.z);
585 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - ftz); } else VU_MACx_CLEAR(VU);
586 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - ftz); } else VU_MACy_CLEAR(VU);
587 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - ftz); } else VU_MACz_CLEAR(VU);
588 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - ftz); } else VU_MACw_CLEAR(VU);
589 VU_STAT_UPDATE(VU);
590 }//updated 10/05/03 shadow
591
592 void _vuSUBw(VURegs * VU) {
593 float ftw;
594 VECTOR * dst;
595 if (_Fd_ == 0) dst = &RDzero;
596 else dst = &VU->VF[_Fd_];
597
598 ftw=vuDouble(VU->VF[_Ft_].i.w);
599 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - ftw); } else VU_MACx_CLEAR(VU);
600 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - ftw); } else VU_MACy_CLEAR(VU);
601 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - ftw); } else VU_MACz_CLEAR(VU);
602 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - ftw); } else VU_MACw_CLEAR(VU);
603 VU_STAT_UPDATE(VU);
604 }//updated 10/05/03 shadow
605
606
607 void _vuSUBA(VURegs * VU) {
608 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACx_CLEAR(VU);
609 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACy_CLEAR(VU);
610 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACz_CLEAR(VU);
611 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACw_CLEAR(VU);
612 VU_STAT_UPDATE(VU);
613 }//updated 10/05/03 shadow
614
615 void _vuSUBAi(VURegs * VU) {
616 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - vuDouble(VU->VI[REG_I].UL)); } else VU_MACx_CLEAR(VU);
617 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - vuDouble(VU->VI[REG_I].UL)); } else VU_MACy_CLEAR(VU);
618 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - vuDouble(VU->VI[REG_I].UL)); } else VU_MACz_CLEAR(VU);
619 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - vuDouble(VU->VI[REG_I].UL)); } else VU_MACw_CLEAR(VU);
620 VU_STAT_UPDATE(VU);
621 }//updated 10/05/03 shadow
622
623 void _vuSUBAq(VURegs * VU) {
624 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - vuDouble(VU->VI[REG_Q].UL)); } else VU_MACx_CLEAR(VU);
625 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - vuDouble(VU->VI[REG_Q].UL)); } else VU_MACy_CLEAR(VU);
626 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - vuDouble(VU->VI[REG_Q].UL)); } else VU_MACz_CLEAR(VU);
627 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - vuDouble(VU->VI[REG_Q].UL)); } else VU_MACw_CLEAR(VU);
628 VU_STAT_UPDATE(VU);
629 }//updated 10/05/03 shadow
630
631 void _vuSUBAx(VURegs * VU) {
632 float tx = vuDouble(VU->VF[_Ft_].i.x);
633
634 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - tx); } else VU_MACx_CLEAR(VU);
635 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - tx); } else VU_MACy_CLEAR(VU);
636 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - tx); } else VU_MACz_CLEAR(VU);
637 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - tx); } else VU_MACw_CLEAR(VU);
638 VU_STAT_UPDATE(VU);
639 }//updated 10/05/03 shadow
640
641 void _vuSUBAy(VURegs * VU) {
642 float ty = vuDouble(VU->VF[_Ft_].i.y);
643
644 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - ty); } else VU_MACx_CLEAR(VU);
645 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - ty); } else VU_MACy_CLEAR(VU);
646 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - ty); } else VU_MACz_CLEAR(VU);
647 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - ty); } else VU_MACw_CLEAR(VU);
648 VU_STAT_UPDATE(VU);
649 }//updated 10/05/03 shadow
650
651 void _vuSUBAz(VURegs * VU) {
652 float tz = vuDouble(VU->VF[_Ft_].i.z);
653
654 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - tz); } else VU_MACx_CLEAR(VU);
655 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - tz); } else VU_MACy_CLEAR(VU);
656 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - tz); } else VU_MACz_CLEAR(VU);
657 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - tz); } else VU_MACw_CLEAR(VU);
658 VU_STAT_UPDATE(VU);
659 }//updated 10/05/03 shadow
660
661 void _vuSUBAw(VURegs * VU) {
662 float tw = vuDouble(VU->VF[_Ft_].i.w);
663
664 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - tw); } else VU_MACx_CLEAR(VU);
665 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - tw); } else VU_MACy_CLEAR(VU);
666 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - tw); } else VU_MACz_CLEAR(VU);
667 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - tw); } else VU_MACw_CLEAR(VU);
668 VU_STAT_UPDATE(VU);
669 }//updated 10/05/03 shadow
670
671 void _vuMUL(VURegs * VU) {
672 VECTOR * dst;
673 if (_Fd_ == 0) dst = &RDzero;
674 else dst = &VU->VF[_Fd_];
675
676 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACx_CLEAR(VU);
677 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACy_CLEAR(VU);
678 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACz_CLEAR(VU);
679 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACw_CLEAR(VU);
680 VU_STAT_UPDATE(VU);
681 }/* last update 8/05/03 shadow */
682
683 /* No need to presave I reg in ti. asadr */
684 void _vuMULi(VURegs * VU) {
685 VECTOR * dst;
686 if (_Fd_ == 0) dst = &RDzero;
687 else dst = &VU->VF[_Fd_];
688
689 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VI[REG_I].UL)); } else VU_MACx_CLEAR(VU);
690 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VI[REG_I].UL)); } else VU_MACy_CLEAR(VU);
691 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VI[REG_I].UL)); } else VU_MACz_CLEAR(VU);
692 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VI[REG_I].UL)); } else VU_MACw_CLEAR(VU);
693 VU_STAT_UPDATE(VU);
694 }/* last update 8/05/03 shadow */
695
696 void _vuMULq(VURegs * VU) {
697 VECTOR * dst;
698 if (_Fd_ == 0) dst = &RDzero;
699 else dst = &VU->VF[_Fd_];
700
701 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VI[REG_Q].UL)); } else VU_MACx_CLEAR(VU);
702 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VI[REG_Q].UL)); } else VU_MACy_CLEAR(VU);
703 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VI[REG_Q].UL)); } else VU_MACz_CLEAR(VU);
704 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VI[REG_Q].UL)); } else VU_MACw_CLEAR(VU);
705 VU_STAT_UPDATE(VU);
706 }/* last update 8/05/03 shadow */
707
708 void _vuMULx(VURegs * VU) {
709 float ftx;
710 VECTOR * dst;
711 if (_Fd_ == 0) dst = &RDzero;
712 else dst = &VU->VF[_Fd_];
713
714 ftx=vuDouble(VU->VF[_Ft_].i.x);
715 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * ftx); } else VU_MACx_CLEAR(VU);
716 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * ftx); } else VU_MACy_CLEAR(VU);
717 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * ftx); } else VU_MACz_CLEAR(VU);
718 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * ftx); } else VU_MACw_CLEAR(VU);
719 VU_STAT_UPDATE(VU);
720 }/* last update 8/05/03 shadow */
721
722
723 void _vuMULy(VURegs * VU) {
724 float fty;
725 VECTOR * dst;
726 if (_Fd_ == 0) dst = &RDzero;
727 else dst = &VU->VF[_Fd_];
728
729 fty=vuDouble(VU->VF[_Ft_].i.y);
730 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * fty); } else VU_MACx_CLEAR(VU);
731 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * fty); } else VU_MACy_CLEAR(VU);
732 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * fty); } else VU_MACz_CLEAR(VU);
733 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * fty); } else VU_MACw_CLEAR(VU);
734 VU_STAT_UPDATE(VU);
735 }/* last update 8/05/03 shadow */
736
737 void _vuMULz(VURegs * VU) {
738 float ftz;
739 VECTOR * dst;
740 if (_Fd_ == 0) dst = &RDzero;
741 else dst = &VU->VF[_Fd_];
742
743 ftz=vuDouble(VU->VF[_Ft_].i.z);
744 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * ftz); } else VU_MACx_CLEAR(VU);
745 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * ftz); } else VU_MACy_CLEAR(VU);
746 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * ftz); } else VU_MACz_CLEAR(VU);
747 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * ftz); } else VU_MACw_CLEAR(VU);
748 VU_STAT_UPDATE(VU);
749 }/* last update 8/05/03 shadow */
750
751 void _vuMULw(VURegs * VU) {
752 float ftw;
753 VECTOR * dst;
754 if (_Fd_ == 0) dst = &RDzero;
755 else dst = &VU->VF[_Fd_];
756
757 ftw=vuDouble(VU->VF[_Ft_].i.w);
758 if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * ftw); } else VU_MACx_CLEAR(VU);
759 if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * ftw); } else VU_MACy_CLEAR(VU);
760 if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * ftw); } else VU_MACz_CLEAR(VU);
761 if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * ftw); } else VU_MACw_CLEAR(VU);
762 VU_STAT_UPDATE(VU);
763 }/* last update 8/05/03 shadow */
764
765
766 void _vuMULA(VURegs * VU) {
767 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACx_CLEAR(VU);
768 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACy_CLEAR(VU);
769 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACz_CLEAR(VU);
770 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACw_CLEAR(VU);
771 VU_STAT_UPDATE(VU);
772 }/* last update 8/05/03 shadow */
773
774 /* No need to presave I reg in ti. asadr */
775 void _vuMULAi(VURegs * VU) {
776 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VI[REG_I].UL)); } else VU_MACx_CLEAR(VU);
777 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VI[REG_I].UL)); } else VU_MACy_CLEAR(VU);
778 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VI[REG_I].UL)); } else VU_MACz_CLEAR(VU);
779 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VI[REG_I].UL)); } else VU_MACw_CLEAR(VU);
780 VU_STAT_UPDATE(VU);
781 }/* last update 8/05/03 shadow */
782
783 /* No need to presave Q reg in ti. asadr */
784 void _vuMULAq(VURegs * VU) {
785 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VI[REG_Q].UL)); } else VU_MACx_CLEAR(VU);
786 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VI[REG_Q].UL)); } else VU_MACy_CLEAR(VU);
787 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VI[REG_Q].UL)); } else VU_MACz_CLEAR(VU);
788 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VI[REG_Q].UL)); } else VU_MACw_CLEAR(VU);
789 VU_STAT_UPDATE(VU);
790 }/* last update 8/05/03 shadow */
791
792 /* No need to presave X reg in ti. asadr */
793 void _vuMULAx(VURegs * VU) {
794 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACx_CLEAR(VU);
795 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACy_CLEAR(VU);
796 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACz_CLEAR(VU);
797 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACw_CLEAR(VU);
798 VU_STAT_UPDATE(VU);
799 }/* last update 8/05/03 shadow */
800
801 void _vuMULAy(VURegs * VU) {
802 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACx_CLEAR(VU);
803 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACy_CLEAR(VU);
804 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACz_CLEAR(VU);
805 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACw_CLEAR(VU);
806 VU_STAT_UPDATE(VU);
807 }/* last update 8/05/03 shadow */
808
809 void _vuMULAz(VURegs * VU) {
810 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACx_CLEAR(VU);
811 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACy_CLEAR(VU);
812 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACz_CLEAR(VU);
813 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACw_CLEAR(VU);
814 VU_STAT_UPDATE(VU);
815 }/* last update 8/05/03 shadow */
816
817 void _vuMULAw(VURegs * VU) {
818 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACx_CLEAR(VU);
819 if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACy_CLEAR(VU);
820 if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACz_CLEAR(VU);
821 if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACw_CLEAR(VU);
822 VU_STAT_UPDATE(VU);
823 }/* last update 8/05/03 shadow */
824
825 void _vuMADD(VURegs * VU) {
826 VECTOR * dst;
827 if (_Fd_ == 0) dst = &RDzero;
828 else dst = &VU->VF[_Fd_];
829
830 if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.x))); else VU_MACx_CLEAR(VU);
831 if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.y))); else VU_MACy_CLEAR(VU);
832 if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.z))); else VU_MACz_CLEAR(VU);
833 if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.w))); else VU_MACw_CLEAR(VU);
834 VU_STAT_UPDATE(VU);
835 }/* last update 10/05/03 shadow */
836
837
838 void _vuMADDi(VURegs * VU) {
839 VECTOR * dst;
840 if (_Fd_ == 0) dst = &RDzero;
841 else dst = &VU->VF[_Fd_];
842
843 if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + (vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VI[REG_I].UL))); else VU_MACx_CLEAR(VU);
844 if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + (vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VI[REG_I].UL))); else VU_MACy_CLEAR(VU);
845 if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + (vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VI[REG_I].UL))); else VU_MACz_CLEAR(VU);
846 if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + (vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VI[REG_I].UL))); else VU_MACw_CLEAR(VU);
847 VU_STAT_UPDATE(VU);
848 }/* last update 10/05/03 shadow */
849
850 /* No need to presave . asadr */
851 void _vuMADDq(VURegs * VU) {
852 VECTOR * dst;
853 if (_Fd_ == 0) dst = &RDzero;
854 else dst = &VU->VF[_Fd_];
855
856 if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + (vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VI[REG_Q].UL))); else VU_MACx_CLEAR(VU);
857 if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + (vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VI[REG_Q].UL))); else VU_MACy_CLEAR(VU);
858 if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + (vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VI[REG_Q].UL))); else VU_MACz_CLEAR(VU);
859 if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + (vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VI[REG_Q].UL))); else VU_MACw_CLEAR(VU);
860 VU_STAT_UPDATE(VU);
861 }/* last update 10/05/03 shadow */
862
863 void _vuMADDx(VURegs * VU) {
864 float ftx;
865 VECTOR * dst;
866 if (_Fd_ == 0) dst = &RDzero;
867 else dst = &VU->VF[_Fd_];
868
869 ftx=vuDouble(VU->VF[_Ft_].i.x);
870 if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + (vuDouble(VU->VF[_Fs_].i.x) * ftx)); else VU_MACx_CLEAR(VU);
871 if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + (vuDouble(VU->VF[_Fs_].i.y) * ftx)); else VU_MACy_CLEAR(VU);
872 if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + (vuDouble(VU->VF[_Fs_].i.z) * ftx)); else VU_MACz_CLEAR(VU);
873 if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + (vuDouble(VU->VF[_Fs_].i.w) * ftx)); else VU_MACw_CLEAR(VU);
874 VU_STAT_UPDATE(VU);
875 }/* last update 10/05/03 shadow */
876
877 void _vuMADDy(VURegs * VU) {
878 float fty;
879 VECTOR * dst;
880 if (_Fd_ == 0) dst = &RDzero;
881 else dst = &VU->VF[_Fd_];
882
883 fty=vuDouble(VU->VF[_Ft_].i.y);
884 if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + (vuDouble(VU->VF[_Fs_].i.x) * fty)); else VU_MACx_CLEAR(VU);
885 if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + (vuDouble(VU->VF[_Fs_].i.y) * fty)); else VU_MACy_CLEAR(VU);
886 if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + (vuDouble(VU->VF[_Fs_].i.z) * fty)); else VU_MACz_CLEAR(VU);
887 if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + (vuDouble(VU->VF[_Fs_].i.w) * fty)); else VU_MACw_CLEAR(VU);
888 VU_STAT_UPDATE(VU);
889 }/* last update 10/05/03 shadow */
890
891 void _vuMADDz(VURegs * VU) {
892 float ftz;
893 VECTOR * dst;
894 if (_Fd_ == 0) dst = &RDzero;
895 else dst = &VU->VF[_Fd_];
896
897 ftz=vuDouble(VU->VF[_Ft_].i.z);
898 if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + (vuDouble(VU->VF[_Fs_].i.x) * ftz)); else VU_MACx_CLEAR(VU);
899 if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + (vuDouble(VU->VF[_Fs_].i.y) * ftz)); else VU_MACy_CLEAR(VU);
900 if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + (vuDouble(VU->VF[_Fs_].i.z) * ftz)); else VU_MACz_CLEAR(VU);
901 if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + (vuDouble(VU->VF[_Fs_].i.w) * ftz)); else VU_MACw_CLEAR(VU);
902 VU_STAT_UPDATE(VU);
903 }/* last update 10/05/03 shadow */
904
905 void _vuMADDw(VURegs * VU) {
906 float ftw;
907 VECTOR * dst;
908 if (_Fd_ == 0) dst = &RDzero;
909 else dst = &VU->VF[_Fd_];
910
911 ftw=vuDouble(VU->VF[_Ft_].i.w);
912 if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + (vuDouble(VU->VF[_Fs_].i.x) * ftw)); else VU_MACx_CLEAR(VU);
913 if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + (vuDouble(VU->VF[_Fs_].i.y) * ftw)); else VU_MACy_CLEAR(VU);
914 if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + (vuDouble(VU->VF[_Fs_].i.z) * ftw)); else VU_MACz_CLEAR(VU);
915 if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + (vuDouble(VU->VF[_Fs_].i.w) * ftw)); else VU_MACw_CLEAR(VU);
916 VU_STAT_UPDATE(VU);
917 }/* last update 10/05/03 shadow */
918
919 void _vuMADDA(VURegs * VU) {
920 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + (vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.x))); else VU_MACx_CLEAR(VU);
921 if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + (vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.y))); else VU_MACy_CLEAR(VU);
922 if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + (vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.z))); else VU_MACz_CLEAR(VU);
923 if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + (vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.w))); else VU_MACw_CLEAR(VU);
924 VU_STAT_UPDATE(VU);
925 }/*last updated 10/05/03 shadow*/
926
927 void _vuMADDAi(VURegs * VU) {
928 float ti = vuDouble(VU->VI[REG_I].UL);
929
930 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + ( vuDouble(VU->VF[_Fs_].i.x) * ti)); else VU_MACx_CLEAR(VU);
931 if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + ( vuDouble(VU->VF[_Fs_].i.y) * ti)); else VU_MACy_CLEAR(VU);
932 if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + ( vuDouble(VU->VF[_Fs_].i.z) * ti)); else VU_MACz_CLEAR(VU);
933 if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + ( vuDouble(VU->VF[_Fs_].i.w) * ti)); else VU_MACw_CLEAR(VU);
934 VU_STAT_UPDATE(VU);
935 }/*last updated 10/05/03 shadow*/
936
937 void _vuMADDAq(VURegs * VU) {
938 float tq = vuDouble(VU->VI[REG_Q].UL);
939
940 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + ( vuDouble(VU->VF[_Fs_].i.x) * tq)); else VU_MACx_CLEAR(VU);
941 if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + ( vuDouble(VU->VF[_Fs_].i.y) * tq)); else VU_MACy_CLEAR(VU);
942 if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + ( vuDouble(VU->VF[_Fs_].i.z) * tq)); else VU_MACz_CLEAR(VU);
943 if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + ( vuDouble(VU->VF[_Fs_].i.w) * tq)); else VU_MACw_CLEAR(VU);
944 VU_STAT_UPDATE(VU);
945 }/*last update 10/05/03 shadow*/
946
947 void _vuMADDAx(VURegs * VU) {
948 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.x))); else VU_MACx_CLEAR(VU);
949 if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.x))); else VU_MACy_CLEAR(VU);
950 if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.x))); else VU_MACz_CLEAR(VU);
951 if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.x))); else VU_MACw_CLEAR(VU);
952 VU_STAT_UPDATE(VU);
953 }/*last update 11/05/03 shadow*/
954
955 void _vuMADDAy(VURegs * VU) {
956 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.y))); else VU_MACx_CLEAR(VU);
957 if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.y))); else VU_MACy_CLEAR(VU);
958 if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.y))); else VU_MACz_CLEAR(VU);
959 if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.y))); else VU_MACw_CLEAR(VU);
960 VU_STAT_UPDATE(VU);
961 }/*last update 11/05/03 shadow*/
962
963 void _vuMADDAz(VURegs * VU) {
964 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.z))); else VU_MACx_CLEAR(VU);
965 if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.z))); else VU_MACy_CLEAR(VU);
966 if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.z))); else VU_MACz_CLEAR(VU);
967 if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.z))); else VU_MACw_CLEAR(VU);
968 VU_STAT_UPDATE(VU);
969 }/*last update 11/05/03 shadow*/
970
971 void _vuMADDAw(VURegs * VU) {
972 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.w))); else VU_MACx_CLEAR(VU);
973 if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.w))); else VU_MACy_CLEAR(VU);
974 if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.w))); else VU_MACz_CLEAR(VU);
975 if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.w))); else VU_MACw_CLEAR(VU);
976 VU_STAT_UPDATE(VU);
977 }/*last update 11/05/03 shadow*/
978
979 void _vuMSUB(VURegs * VU) {
980 VECTOR * dst;
981 if (_Fd_ == 0) dst = &RDzero;
982 else dst = &VU->VF[_Fd_];
983
984 if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.x))); else VU_MACx_CLEAR(VU);
985 if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.y))); else VU_MACy_CLEAR(VU);
986 if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.z))); else VU_MACz_CLEAR(VU);
987 if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.w))); else VU_MACw_CLEAR(VU);
988 VU_STAT_UPDATE(VU);
989 }/* last update 11/05/03 shadow */
990
991 void _vuMSUBi(VURegs * VU) {
992 float ti = vuDouble(VU->VI[REG_I].UL);
993 VECTOR * dst;
994 if (_Fd_ == 0) dst = &RDzero;
995 else dst = &VU->VF[_Fd_];
996
997 if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * ti ) ); else VU_MACx_CLEAR(VU);
998 if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * ti ) ); else VU_MACy_CLEAR(VU);
999 if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * ti ) ); else VU_MACz_CLEAR(VU);
1000 if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * ti ) ); else VU_MACw_CLEAR(VU);
1001 VU_STAT_UPDATE(VU);
1002 }/* last update 11/05/03 shadow */
1003
1004 void _vuMSUBq(VURegs * VU) {
1005 float tq = vuDouble(VU->VI[REG_Q].UL);
1006 VECTOR * dst;
1007 if (_Fd_ == 0) dst = &RDzero;
1008 else dst = &VU->VF[_Fd_];
1009
1010 if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * tq ) ); else VU_MACx_CLEAR(VU);
1011 if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * tq ) ); else VU_MACy_CLEAR(VU);
1012 if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * tq ) ); else VU_MACz_CLEAR(VU);
1013 if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * tq ) ); else VU_MACw_CLEAR(VU);
1014 VU_STAT_UPDATE(VU);
1015 }/* last update 11/05/03 shadow */
1016
1017
1018 void _vuMSUBx(VURegs * VU) {
1019 float ftx;
1020 VECTOR * dst;
1021 if (_Fd_ == 0) dst = &RDzero;
1022 else dst = &VU->VF[_Fd_];
1023
1024 ftx=vuDouble(VU->VF[_Ft_].i.x);
1025 if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * ftx ) ); else VU_MACx_CLEAR(VU);
1026 if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * ftx ) ); else VU_MACy_CLEAR(VU);
1027 if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * ftx ) ); else VU_MACz_CLEAR(VU);
1028 if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * ftx ) ); else VU_MACw_CLEAR(VU);
1029 VU_STAT_UPDATE(VU);
1030 }/* last update 11/05/03 shadow */
1031
1032
1033 void _vuMSUBy(VURegs * VU) {
1034 float fty;
1035 VECTOR * dst;
1036 if (_Fd_ == 0) dst = &RDzero;
1037 else dst = &VU->VF[_Fd_];
1038
1039 fty=vuDouble(VU->VF[_Ft_].i.y);
1040 if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * fty ) ); else VU_MACx_CLEAR(VU);
1041 if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * fty ) ); else VU_MACy_CLEAR(VU);
1042 if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * fty ) ); else VU_MACz_CLEAR(VU);
1043 if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * fty ) ); else VU_MACw_CLEAR(VU);
1044 VU_STAT_UPDATE(VU);
1045 }/* last update 11/05/03 shadow */
1046
1047
1048 void _vuMSUBz(VURegs * VU) {
1049 float ftz;
1050 VECTOR * dst;
1051 if (_Fd_ == 0) dst = &RDzero;
1052 else dst = &VU->VF[_Fd_];
1053
1054 ftz=vuDouble(VU->VF[_Ft_].i.z);
1055 if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * ftz ) ); else VU_MACx_CLEAR(VU);
1056 if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * ftz ) ); else VU_MACy_CLEAR(VU);
1057 if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * ftz ) ); else VU_MACz_CLEAR(VU);
1058 if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * ftz ) ); else VU_MACw_CLEAR(VU);
1059 VU_STAT_UPDATE(VU);
1060 }/* last update 11/05/03 shadow */
1061
1062 void _vuMSUBw(VURegs * VU) {
1063 float ftw;
1064 VECTOR * dst;
1065 if (_Fd_ == 0) dst = &RDzero;
1066 else dst = &VU->VF[_Fd_];
1067
1068 ftw=vuDouble(VU->VF[_Ft_].i.w);
1069 if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * ftw ) ); else VU_MACx_CLEAR(VU);
1070 if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * ftw ) ); else VU_MACy_CLEAR(VU);
1071 if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * ftw ) ); else VU_MACz_CLEAR(VU);
1072 if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * ftw ) ); else VU_MACw_CLEAR(VU);
1073 VU_STAT_UPDATE(VU);
1074 }/* last update 11/05/03 shadow */
1075
1076
1077 void _vuMSUBA(VURegs * VU) {
1078 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.x))); else VU_MACx_CLEAR(VU);
1079 if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.y))); else VU_MACy_CLEAR(VU);
1080 if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.z))); else VU_MACz_CLEAR(VU);
1081 if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.w))); else VU_MACw_CLEAR(VU);
1082 VU_STAT_UPDATE(VU);
1083 }/*last updated 11/05/03 shadow*/
1084
1085 void _vuMSUBAi(VURegs * VU) {
1086 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VI[REG_I].UL))); else VU_MACx_CLEAR(VU);
1087 if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VI[REG_I].UL))); else VU_MACy_CLEAR(VU);
1088 if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VI[REG_I].UL))); else VU_MACz_CLEAR(VU);
1089 if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VI[REG_I].UL))); else VU_MACw_CLEAR(VU);
1090 VU_STAT_UPDATE(VU);
1091 }/*last updated 11/05/03 shadow*/
1092
1093 void _vuMSUBAq(VURegs * VU) {
1094 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VI[REG_Q].UL))); else VU_MACx_CLEAR(VU);
1095 if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VI[REG_Q].UL))); else VU_MACy_CLEAR(VU);
1096 if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VI[REG_Q].UL))); else VU_MACz_CLEAR(VU);
1097 if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VI[REG_Q].UL))); else VU_MACw_CLEAR(VU);
1098 VU_STAT_UPDATE(VU);
1099 }/*last updated 11/05/03 shadow*/
1100
1101 void _vuMSUBAx(VURegs * VU) {
1102 float tx = vuDouble(VU->VF[_Ft_].i.x);
1103
1104 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * tx)); else VU_MACx_CLEAR(VU);
1105 if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * tx)); else VU_MACy_CLEAR(VU);
1106 if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * tx)); else VU_MACz_CLEAR(VU);
1107 if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * tx)); else VU_MACw_CLEAR(VU);
1108 VU_STAT_UPDATE(VU);
1109 }/*last updated 11/05/03 shadow*/
1110
1111 void _vuMSUBAy(VURegs * VU) {
1112 float ty = vuDouble(VU->VF[_Ft_].i.y);
1113
1114 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * ty)); else VU_MACx_CLEAR(VU);
1115 if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * ty)); else VU_MACy_CLEAR(VU);
1116 if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * ty)); else VU_MACz_CLEAR(VU);
1117 if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * ty)); else VU_MACw_CLEAR(VU);
1118 VU_STAT_UPDATE(VU);
1119 }/*last updated 11/05/03 shadow*/
1120
1121 void _vuMSUBAz(VURegs * VU) {
1122 float tz = vuDouble(VU->VF[_Ft_].i.z);
1123
1124 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * tz)); else VU_MACx_CLEAR(VU);
1125 if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * tz)); else VU_MACy_CLEAR(VU);
1126 if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * tz)); else VU_MACz_CLEAR(VU);
1127 if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * tz)); else VU_MACw_CLEAR(VU);
1128 VU_STAT_UPDATE(VU);
1129 }/*last updated 11/05/03 shadow*/
1130
1131 void _vuMSUBAw(VURegs * VU) {
1132 float tw = vuDouble(VU->VF[_Ft_].i.w);
1133
1134 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * tw)); else VU_MACx_CLEAR(VU);
1135 if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * tw)); else VU_MACy_CLEAR(VU);
1136 if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * tw)); else VU_MACz_CLEAR(VU);
1137 if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * tw)); else VU_MACw_CLEAR(VU);
1138 VU_STAT_UPDATE(VU);
1139 }/*last updated 11/05/03 shadow*/
1140
1141 u32 _MAX(u32 a, u32 b) {
1142 if (a & 0x80000000) { // -a
1143 if (b & 0x80000000) { // -b
1144 return (a & 0x7fffffff) > (b & 0x7fffffff) ? b : a;
1145 } else { // +b
1146 return b;
1147 }
1148 } else { // +a
1149 if (b & 0x80000000) { // -b
1150 return a;
1151 } else { // +b
1152 return (a & 0x7fffffff) > (b & 0x7fffffff) ? a : b;
1153 }
1154 }
1155
1156 return 0;
1157 }
1158
1159 void _vuMAX(VURegs * VU) {
1160 if (_Fd_ == 0) return;
1161
1162 /* ft is bc */
1163 if (_X) VU->VF[_Fd_].i.x = _MAX(VU->VF[_Fs_].i.x, (s32)VU->VF[_Ft_].i.x);
1164 if (_Y) VU->VF[_Fd_].i.y = _MAX(VU->VF[_Fs_].i.y, (s32)VU->VF[_Ft_].i.y);
1165 if (_Z) VU->VF[_Fd_].i.z = _MAX(VU->VF[_Fs_].i.z, (s32)VU->VF[_Ft_].i.z);
1166 if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, (s32)VU->VF[_Ft_].i.w);
1167 }//checked 13/05/03 shadow
1168
1169 void _vuMAXi(VURegs * VU) {
1170 if (_Fd_ == 0) return;
1171
1172 /* ft is bc */
1173 if (_X) VU->VF[_Fd_].i.x = _MAX(VU->VF[_Fs_].i.x, VU->VI[REG_I].UL);
1174 if (_Y) VU->VF[_Fd_].i.y = _MAX(VU->VF[_Fs_].i.y, VU->VI[REG_I].UL);
1175 if (_Z) VU->VF[_Fd_].i.z = _MAX(VU->VF[_Fs_].i.z, VU->VI[REG_I].UL);
1176 if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, VU->VI[REG_I].UL);
1177 }//checked 13/05/03 shadow
1178
1179 void _vuMAXx(VURegs * VU) {
1180 s32 ftx;
1181 if (_Fd_ == 0) return;
1182
1183 ftx=(s32)VU->VF[_Ft_].i.x;
1184 if (_X) VU->VF[_Fd_].i.x = _MAX(VU->VF[_Fs_].i.x, ftx);
1185 if (_Y) VU->VF[_Fd_].i.y = _MAX(VU->VF[_Fs_].i.y, ftx);
1186 if (_Z) VU->VF[_Fd_].i.z = _MAX(VU->VF[_Fs_].i.z, ftx);
1187 if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, ftx);
1188 }
1189 //checked 13/05/03 shadow
1190
1191 void _vuMAXy(VURegs * VU) {
1192 s32 fty;
1193 if (_Fd_ == 0) return;
1194
1195 fty=(s32)VU->VF[_Ft_].i.y;
1196 if (_X) VU->VF[_Fd_].i.x = _MAX(VU->VF[_Fs_].i.x, fty);
1197 if (_Y) VU->VF[_Fd_].i.y = _MAX(VU->VF[_Fs_].i.y, fty);
1198 if (_Z) VU->VF[_Fd_].i.z = _MAX(VU->VF[_Fs_].i.z, fty);
1199 if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, fty);
1200 }//checked 13/05/03 shadow
1201
1202 void _vuMAXz(VURegs * VU) {
1203 s32 ftz;
1204 if (_Fd_ == 0) return;
1205
1206 ftz=(s32)VU->VF[_Ft_].i.z;
1207 if (_X) VU->VF[_Fd_].i.x = _MAX(VU->VF[_Fs_].i.x, ftz);
1208 if (_Y) VU->VF[_Fd_].i.y = _MAX(VU->VF[_Fs_].i.y, ftz);
1209 if (_Z) VU->VF[_Fd_].i.z = _MAX(VU->VF[_Fs_].i.z, ftz);
1210 if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, ftz);
1211 }
1212
1213 void _vuMAXw(VURegs * VU) {
1214 s32 ftw;
1215 if (_Fd_ == 0) return;
1216
1217 ftw=(s32)VU->VF[_Ft_].i.w;
1218 if (_X) VU->VF[_Fd_].i.x = _MAX(VU->VF[_Fs_].i.x, ftw);
1219 if (_Y) VU->VF[_Fd_].i.y = _MAX(VU->VF[_Fs_].i.y, ftw);
1220 if (_Z) VU->VF[_Fd_].i.z = _MAX(VU->VF[_Fs_].i.z, ftw);
1221 if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, ftw);
1222 }
1223
1224 u32 _MINI(u32 a, u32 b) {
1225 if (a & 0x80000000) { // -a
1226 if (b & 0x80000000) { // -b
1227 return (a & 0x7fffffff) < (b & 0x7fffffff) ? b : a;
1228 } else { // +b
1229 return a;
1230 }
1231 } else { // +a
1232 if (b & 0x80000000) { // -b
1233 return b;
1234 } else { // +b
1235 return (a & 0x7fffffff) < (b & 0x7fffffff) ? a : b;
1236 }
1237 }
1238
1239 return 0;
1240 }
1241
1242 void _vuMINI(VURegs * VU) {
1243 if (_Fd_ == 0) return;
1244
1245 /* ft is bc */
1246 if (_X) VU->VF[_Fd_].i.x = _MINI(VU->VF[_Fs_].i.x, (s32)VU->VF[_Ft_].i.x);
1247 if (_Y) VU->VF[_Fd_].i.y = _MINI(VU->VF[_Fs_].i.y, (s32)VU->VF[_Ft_].i.y);
1248 if (_Z) VU->VF[_Fd_].i.z = _MINI(VU->VF[_Fs_].i.z, (s32)VU->VF[_Ft_].i.z);
1249 if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, (s32)VU->VF[_Ft_].i.w);
1250 }//checked 13/05/03 shadow
1251
1252 void _vuMINIi(VURegs * VU) {
1253 if (_Fd_ == 0) return;
1254
1255 /* ft is bc */
1256 if (_X) VU->VF[_Fd_].i.x = _MINI(VU->VF[_Fs_].i.x, VU->VI[REG_I].UL);
1257 if (_Y) VU->VF[_Fd_].i.y = _MINI(VU->VF[_Fs_].i.y, VU->VI[REG_I].UL);
1258 if (_Z) VU->VF[_Fd_].i.z = _MINI(VU->VF[_Fs_].i.z, VU->VI[REG_I].UL);
1259 if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, VU->VI[REG_I].UL);
1260 }//checked 13/05/03 shadow
1261
1262 void _vuMINIx(VURegs * VU) {
1263 s32 ftx;
1264 if (_Fd_ == 0) return;
1265
1266 ftx=(s32)VU->VF[_Ft_].i.x;
1267 if (_X) VU->VF[_Fd_].i.x = _MINI(VU->VF[_Fs_].i.x, ftx);
1268 if (_Y) VU->VF[_Fd_].i.y = _MINI(VU->VF[_Fs_].i.y, ftx);
1269 if (_Z) VU->VF[_Fd_].i.z = _MINI(VU->VF[_Fs_].i.z, ftx);
1270 if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, ftx);
1271 }
1272 //checked 13/05/03 shadow
1273
1274 void _vuMINIy(VURegs * VU) {
1275 s32 fty;
1276 if (_Fd_ == 0) return;
1277
1278 fty=(s32)VU->VF[_Ft_].i.y;
1279 if (_X) VU->VF[_Fd_].i.x = _MINI(VU->VF[_Fs_].i.x, fty);
1280 if (_Y) VU->VF[_Fd_].i.y = _MINI(VU->VF[_Fs_].i.y, fty);
1281 if (_Z) VU->VF[_Fd_].i.z = _MINI(VU->VF[_Fs_].i.z, fty);
1282 if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, fty);
1283 }//checked 13/05/03 shadow
1284
1285 void _vuMINIz(VURegs * VU) {
1286 s32 ftz;
1287 if (_Fd_ == 0) return;
1288
1289 ftz=(s32)VU->VF[_Ft_].i.z;
1290 if (_X) VU->VF[_Fd_].i.x = _MINI(VU->VF[_Fs_].i.x, ftz);
1291 if (_Y) VU->VF[_Fd_].i.y = _MINI(VU->VF[_Fs_].i.y, ftz);
1292 if (_Z) VU->VF[_Fd_].i.z = _MINI(VU->VF[_Fs_].i.z, ftz);
1293 if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, ftz);
1294 }
1295
1296 void _vuMINIw(VURegs * VU) {
1297 s32 ftw;
1298 if (_Fd_ == 0) return;
1299
1300 ftw=(s32)VU->VF[_Ft_].i.w;
1301 if (_X) VU->VF[_Fd_].i.x = _MINI(VU->VF[_Fs_].i.x, ftw);
1302 if (_Y) VU->VF[_Fd_].i.y = _MINI(VU->VF[_Fs_].i.y, ftw);
1303 if (_Z) VU->VF[_Fd_].i.z = _MINI(VU->VF[_Fs_].i.z, ftw);
1304 if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, ftw);
1305 }
1306
1307 void _vuOPMULA(VURegs * VU) {
1308 VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.z));
1309 VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.x));
1310 VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.y));
1311 VU_STAT_UPDATE(VU);
1312 }/*last updated 8/05/03 shadow*/
1313
1314 void _vuOPMSUB(VURegs * VU) {
1315 VECTOR * dst;
1316 float ftx, fty, ftz;
1317 float fsx, fsy, fsz;
1318 if (_Fd_ == 0)
1319 dst = &RDzero;
1320 else
1321 dst = &VU->VF[_Fd_];
1322
1323 ftx = vuDouble(VU->VF[_Ft_].i.x); fty = vuDouble(VU->VF[_Ft_].i.y); ftz = vuDouble(VU->VF[_Ft_].i.z);
1324 fsx = vuDouble(VU->VF[_Fs_].i.x); fsy = vuDouble(VU->VF[_Fs_].i.y); fsz = vuDouble(VU->VF[_Fs_].i.z);
1325 dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - fsy * ftz);
1326 dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - fsz * ftx);
1327 dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - fsx * fty);
1328 VU_STAT_UPDATE(VU);
1329 }/*last updated 8/05/03 shadow*/
1330
1331 void _vuNOP(VURegs * VU) {
1332 }
1333
1334 void _vuFTOI0(VURegs * VU) {
1335 if (_Ft_ == 0) return;
1336
1337 if (_X) VU->VF[_Ft_].SL[0] = (s32)vuDouble(VU->VF[_Fs_].i.x);
1338 if (_Y) VU->VF[_Ft_].SL[1] = (s32)vuDouble(VU->VF[_Fs_].i.y);
1339 if (_Z) VU->VF[_Ft_].SL[2] = (s32)vuDouble(VU->VF[_Fs_].i.z);
1340 if (_W) VU->VF[_Ft_].SL[3] = (s32)vuDouble(VU->VF[_Fs_].i.w);
1341 }
1342
1343 void _vuFTOI4(VURegs * VU) {
1344 if (_Ft_ == 0) return;
1345
1346 if (_X) VU->VF[_Ft_].SL[0] = float_to_int4(vuDouble(VU->VF[_Fs_].i.x));
1347 if (_Y) VU->VF[_Ft_].SL[1] = float_to_int4(vuDouble(VU->VF[_Fs_].i.y));
1348 if (_Z) VU->VF[_Ft_].SL[2] = float_to_int4(vuDouble(VU->VF[_Fs_].i.z));
1349 if (_W) VU->VF[_Ft_].SL[3] = float_to_int4(vuDouble(VU->VF[_Fs_].i.w));
1350 }
1351
1352 void _vuFTOI12(VURegs * VU) {
1353 if (_Ft_ == 0) return;
1354
1355 if (_X) VU->VF[_Ft_].SL[0] = float_to_int12(vuDouble(VU->VF[_Fs_].i.x));
1356 if (_Y) VU->VF[_Ft_].SL[1] = float_to_int12(vuDouble(VU->VF[_Fs_].i.y));
1357 if (_Z) VU->VF[_Ft_].SL[2] = float_to_int12(vuDouble(VU->VF[_Fs_].i.z));
1358 if (_W) VU->VF[_Ft_].SL[3] = float_to_int12(vuDouble(VU->VF[_Fs_].i.w));
1359 }
1360
1361 void _vuFTOI15(VURegs * VU) {
1362 if (_Ft_ == 0) return;
1363
1364 if (_X) VU->VF[_Ft_].SL[0] = float_to_int15(vuDouble(VU->VF[_Fs_].i.x));
1365 if (_Y) VU->VF[_Ft_].SL[1] = float_to_int15(vuDouble(VU->VF[_Fs_].i.y));
1366 if (_Z) VU->VF[_Ft_].SL[2] = float_to_int15(vuDouble(VU->VF[_Fs_].i.z));
1367 if (_W) VU->VF[_Ft_].SL[3] = float_to_int15(vuDouble(VU->VF[_Fs_].i.w));
1368 }
1369
1370 void _vuITOF0(VURegs * VU) {
1371 if (_Ft_ == 0) return;
1372
1373 if (_X) VU->VF[_Ft_].f.x = (float)VU->VF[_Fs_].SL[0];
1374 if (_Y) VU->VF[_Ft_].f.y = (float)VU->VF[_Fs_].SL[1];
1375 if (_Z) VU->VF[_Ft_].f.z = (float)VU->VF[_Fs_].SL[2];
1376 if (_W) VU->VF[_Ft_].f.w = (float)VU->VF[_Fs_].SL[3];
1377 }
1378
1379 void _vuITOF4(VURegs * VU) {
1380 if (_Ft_ == 0) return;
1381
1382 if (_X) VU->VF[_Ft_].f.x = int4_to_float(VU->VF[_Fs_].SL[0]);
1383 if (_Y) VU->VF[_Ft_].f.y = int4_to_float(VU->VF[_Fs_].SL[1]);
1384 if (_Z) VU->VF[_Ft_].f.z = int4_to_float(VU->VF[_Fs_].SL[2]);
1385 if (_W) VU->VF[_Ft_].f.w = int4_to_float(VU->VF[_Fs_].SL[3]);
1386 }
1387
1388 void _vuITOF12(VURegs * VU) {
1389 if (_Ft_ == 0) return;
1390
1391 if (_X) VU->VF[_Ft_].f.x = int12_to_float(VU->VF[_Fs_].SL[0]);
1392 if (_Y) VU->VF[_Ft_].f.y = int12_to_float(VU->VF[_Fs_].SL[1]);
1393 if (_Z) VU->VF[_Ft_].f.z = int12_to_float(VU->VF[_Fs_].SL[2]);
1394 if (_W) VU->VF[_Ft_].f.w = int12_to_float(VU->VF[_Fs_].SL[3]);
1395 }
1396
1397 void _vuITOF15(VURegs * VU) {
1398 if (_Ft_ == 0) return;
1399
1400 if (_X) VU->VF[_Ft_].f.x = int15_to_float(VU->VF[_Fs_].SL[0]);
1401 if (_Y) VU->VF[_Ft_].f.y = int15_to_float(VU->VF[_Fs_].SL[1]);
1402 if (_Z) VU->VF[_Ft_].f.z = int15_to_float(VU->VF[_Fs_].SL[2]);
1403 if (_W) VU->VF[_Ft_].f.w = int15_to_float(VU->VF[_Fs_].SL[3]);
1404 }
1405
1406 /* Different type of clipping by presaving w. asadr */
1407 void _vuCLIP(VURegs * VU) {
1408 float value = fabs(vuDouble(VU->VF[_Ft_].i.w));
1409
1410 VU->clipflag <<= 6;
1411 if ( vuDouble(VU->VF[_Fs_].i.x) > +value ) VU->clipflag|= 0x01;
1412 if ( vuDouble(VU->VF[_Fs_].i.x) < -value ) VU->clipflag|= 0x02;
1413 if ( vuDouble(VU->VF[_Fs_].i.y) > +value ) VU->clipflag|= 0x04;
1414 if ( vuDouble(VU->VF[_Fs_].i.y) < -value ) VU->clipflag|= 0x08;
1415 if ( vuDouble(VU->VF[_Fs_].i.z) > +value ) VU->clipflag|= 0x10;
1416 if ( vuDouble(VU->VF[_Fs_].i.z) < -value ) VU->clipflag|= 0x20;
1417 VU->clipflag = VU->clipflag & 0xFFFFFF;
1418 VU->VI[REG_CLIP_FLAG].UL = VU->clipflag;
1419
1420
1421 }/*last update 16/07/05 refraction - Needs checking */
1422
1423
1424 /******************************/
1425 /* VU Lower instructions */
1426 /******************************/
1427
1428 void _vuDIV(VURegs * VU) {
1429 float ft = vuDouble(VU->VF[_Ft_].UL[_Ftf_]);
1430 float fs = vuDouble(VU->VF[_Fs_].UL[_Fsf_]);
1431
1432 VU->statusflag = (VU->statusflag&0xfcf)|((VU->statusflag&0x30)<<6);
1433
1434 if (ft == 0.0) {
1435 if (fs == 0.0) {
1436 VU->statusflag |= 0x10;
1437 } else {
1438 VU->statusflag |= 0x20;
1439 }
1440 if ((VU->VF[_Ft_].UL[_Ftf_] & 0x80000000) ^
1441 (VU->VF[_Fs_].UL[_Fsf_] & 0x80000000)) {
1442 VU->q.UL = 0xFF7FFFFF;
1443 } else {
1444 VU->q.UL = 0x7F7FFFFF;
1445 }
1446 } else {
1447 VU->q.F = fs / ft;
1448 VU->q.F = vuDouble(VU->q.UL);
1449 }
1450 } //last update 15/01/06 zerofrog
1451
1452 void _vuSQRT(VURegs * VU) {
1453 float ft = vuDouble(VU->VF[_Ft_].UL[_Ftf_]);
1454
1455 VU->statusflag = (VU->statusflag&0xfcf)|((VU->statusflag&0x30)<<6);
1456
1457 if (ft < 0.0 ) VU->statusflag |= 0x10;
1458 VU->q.F = sqrt(fabs(ft));
1459 VU->q.F = vuDouble(VU->q.UL);
1460 } //last update 15/01/06 zerofrog
1461
1462 /* Eminent Bug - Dvisior == 0 Check Missing ( D Flag Not Set ) */
1463 /* REFIXED....ASADR; rerefixed....zerofrog */
1464 void _vuRSQRT(VURegs * VU) {
1465 float ft = vuDouble(VU->VF[_Ft_].UL[_Ftf_]);
1466 float fs = vuDouble(VU->VF[_Fs_].UL[_Fsf_]);
1467 float temp;
1468
1469 VU->statusflag = (VU->statusflag&0xfcf)|((VU->statusflag&0x30)<<6);
1470
1471 if ( ft == 0.0 ) {
1472 VU->statusflag |= 0x20;
1473
1474 if( fs != 0 ) {
1475 if ((VU->VF[_Ft_].UL[_Ftf_] & 0x80000000) ^
1476 (VU->VF[_Fs_].UL[_Fsf_] & 0x80000000)) {
1477 VU->q.UL = 0xFF7FFFFF;
1478 } else {
1479 VU->q.UL = 0x7F7FFFFF;
1480 }
1481 }
1482 else {
1483 if ((VU->VF[_Ft_].UL[_Ftf_] & 0x80000000) ^
1484 (VU->VF[_Fs_].UL[_Fsf_] & 0x80000000)) {
1485 VU->q.UL = 0x80000000;
1486 } else {
1487 VU->q.UL = 0;
1488 }
1489
1490 VU->statusflag |= 0x10;
1491 }
1492
1493 } else {
1494 if (ft < 0.0) {
1495 VU->statusflag |= 0x10;
1496 }
1497
1498 temp = sqrt(fabs(ft));
1499 VU->q.F = fs / temp;
1500 VU->q.F = vuDouble(VU->q.UL);
1501 }
1502 } //last update 15/01/06 zerofrog
1503
1504 void _vuIADDI(VURegs * VU) {
1505 s16 imm = ((VU->code >> 6) & 0x1f);
1506 imm = ((imm & 0x10 ? 0xfff0 : 0) | (imm & 0xf));
1507 if(_It_ == 0) return;
1508 VU->VI[_It_].SS[0] = VU->VI[_Is_].SS[0] + imm;
1509 }//last checked 17/05/03 shadow NOTE: not quite sure about that
1510
1511 void _vuIADDIU(VURegs * VU) {
1512 if(_It_ == 0) return;
1513 VU->VI[_It_].SS[0] = VU->VI[_Is_].SS[0] + (((VU->code >> 10) & 0x7800) | (VU->code & 0x7ff));
1514 }//last checked 17/05/03 shadow
1515
1516 void _vuIADD(VURegs * VU) {
1517 if(_Id_ == 0) return;
1518 VU->VI[_Id_].SS[0] = VU->VI[_Is_].SS[0] + VU->VI[_It_].SS[0];
1519 }//last checked 17/05/03 shadow
1520
1521 void _vuIAND(VURegs * VU) {
1522 if(_Id_ == 0) return;
1523 VU->VI[_Id_].US[0] = VU->VI[_Is_].US[0] & VU->VI[_It_].US[0];
1524 }//last checked 17/05/03 shadow
1525
1526 void _vuIOR(VURegs * VU) {
1527 if(_Id_ == 0) return;
1528 VU->VI[_Id_].US[0] = VU->VI[_Is_].US[0] | VU->VI[_It_].US[0];
1529 }
1530
1531 void _vuISUB(VURegs * VU) {
1532 if(_Id_ == 0) return;
1533 VU->VI[_Id_].SS[0] = VU->VI[_Is_].SS[0] - VU->VI[_It_].SS[0];
1534 }
1535
1536 void _vuISUBIU(VURegs * VU) {
1537 if(_It_ == 0) return;
1538 VU->VI[_It_].SS[0] = VU->VI[_Is_].SS[0] - (((VU->code >> 10) & 0x7800) | (VU->code & 0x7ff));
1539 }
1540
1541 void _vuMOVE(VURegs * VU) {
1542 if(_Ft_ == 0) return;
1543
1544 if (_X) VU->VF[_Ft_].UL[0] = VU->VF[_Fs_].UL[0];
1545 if (_Y) VU->VF[_Ft_].UL[1] = VU->VF[_Fs_].UL[1];
1546 if (_Z) VU->VF[_Ft_].UL[2] = VU->VF[_Fs_].UL[2];
1547 if (_W) VU->VF[_Ft_].UL[3] = VU->VF[_Fs_].UL[3];
1548 }//last checked 17/05/03 shadow
1549
1550 void _vuMFIR(VURegs * VU) {
1551 if (_Ft_ == 0) return;
1552
1553 if (_X) VU->VF[_Ft_].SL[0] = (s32)VU->VI[_Is_].SS[0];
1554 if (_Y) VU->VF[_Ft_].SL[1] = (s32)VU->VI[_Is_].SS[0];
1555 if (_Z) VU->VF[_Ft_].SL[2] = (s32)VU->VI[_Is_].SS[0];
1556 if (_W) VU->VF[_Ft_].SL[3] = (s32)VU->VI[_Is_].SS[0];
1557 }
1558
1559 // Big bug!!! mov from fs to ft not ft to fs. asadr
1560 void _vuMTIR(VURegs * VU) {
1561 if(_It_ == 0) return;
1562 VU->VI[_It_].US[0] = *(u16*)&VU->VF[_Fs_].F[_Fsf_];
1563 }
1564
1565 void _vuMR32(VURegs * VU) {
1566 u32 tx;
1567 if (_Ft_ == 0) return;
1568
1569 tx = VU->VF[_Fs_].i.x;
1570 if (_X) VU->VF[_Ft_].i.x = VU->VF[_Fs_].i.y;
1571 if (_Y) VU->VF[_Ft_].i.y = VU->VF[_Fs_].i.z;
1572 if (_Z) VU->VF[_Ft_].i.z = VU->VF[_Fs_].i.w;
1573 if (_W) VU->VF[_Ft_].i.w = tx;
1574 }//last updated 23/10/03 linuzappz
1575
1576 // --------------------------------------------------------------------------------------
1577 // Load / Store Instructions (VU Interpreter)
1578 // --------------------------------------------------------------------------------------
1579
1580 __forceinline u32* GET_VU_MEM(VURegs* VU, u32 addr) // non-static, also used by sVU for now.
1581 {
1582 if( VU == g_pVU1 ) return (u32*)(VU1.Mem+(addr&0x3fff));
1583 if( addr >= 0x4000 ) return (u32*)(VU0.Mem+(addr&0x43f0)); // get VF and VI regs (they're mapped to 0x4xx0 in VU0 mem!)
1584 return (u32*)(VU0.Mem+(addr&0x0fff)); // for addr 0x0000 to 0x4000 just wrap around
1585 }
1586
1587 void _vuLQ(VURegs * VU) {
1588 s16 imm;
1589 u16 addr;
1590 u32 *ptr;
1591
1592 if (_Ft_ == 0) return;
1593
1594 imm = (VU->code & 0x400) ? (VU->code & 0x3ff) | 0xfc00 : (VU->code & 0x3ff);
1595 addr = ((imm + VU->VI[_Is_].SS[0]) * 16)& (VU == &VU1 ? 0x3fff : 0xfff);
1596
1597 ptr = (u32*)GET_VU_MEM(VU, addr);
1598 if (_X) VU->VF[_Ft_].UL[0] = ptr[0];
1599 if (_Y) VU->VF[_Ft_].UL[1] = ptr[1];
1600 if (_Z) VU->VF[_Ft_].UL[2] = ptr[2];
1601 if (_W) VU->VF[_Ft_].UL[3] = ptr[3];
1602 }
1603
1604 void _vuLQD( VURegs * VU ) {
1605 u32 addr;
1606 u32 *ptr;
1607
1608 if (_Is_ != 0) VU->VI[_Is_].US[0]--;
1609 if (_Ft_ == 0) return;
1610
1611 addr = (VU->VI[_Is_].US[0] * 16) & (VU == &VU1 ? 0x3fff : 0xfff);
1612 ptr = (u32*)GET_VU_MEM(VU, addr);
1613 if (_X) VU->VF[_Ft_].UL[0] = ptr[0];
1614 if (_Y) VU->VF[_Ft_].UL[1] = ptr[1];
1615 if (_Z) VU->VF[_Ft_].UL[2] = ptr[2];
1616 if (_W) VU->VF[_Ft_].UL[3] = ptr[3];
1617 }
1618
1619 void _vuLQI(VURegs * VU) {
1620 if (_Ft_) {
1621 u32 addr;
1622 u32 *ptr;
1623
1624 addr = (VU->VI[_Is_].US[0] * 16)& (VU == &VU1 ? 0x3fff : 0xfff);
1625 ptr = (u32*)GET_VU_MEM(VU, addr);
1626 if (_X) VU->VF[_Ft_].UL[0] = ptr[0];
1627 if (_Y) VU->VF[_Ft_].UL[1] = ptr[1];
1628 if (_Z) VU->VF[_Ft_].UL[2] = ptr[2];
1629 if (_W) VU->VF[_Ft_].UL[3] = ptr[3];
1630 }
1631 if (_Fs_ != 0) VU->VI[_Is_].US[0]++;
1632 }
1633
1634 /* addr is now signed. Asadr */
1635 void _vuSQ(VURegs * VU) {
1636 s16 imm;
1637 u16 addr;
1638 u32 *ptr;
1639
1640 imm = (VU->code & 0x400) ? (VU->code & 0x3ff) | 0xfc00 : (VU->code & 0x3ff);
1641 addr = ((imm + VU->VI[_It_].SS[0]) * 16)& (VU == &VU1 ? 0x3fff : 0xfff);
1642 ptr = (u32*)GET_VU_MEM(VU, addr);
1643 if (_X) ptr[0] = VU->VF[_Fs_].UL[0];
1644 if (_Y) ptr[1] = VU->VF[_Fs_].UL[1];
1645 if (_Z) ptr[2] = VU->VF[_Fs_].UL[2];
1646 if (_W) ptr[3] = VU->VF[_Fs_].UL[3];
1647 }
1648
1649 void _vuSQD(VURegs * VU) {
1650 u32 addr;
1651 u32 *ptr;
1652
1653 if(_Ft_ != 0) VU->VI[_It_].US[0]--;
1654 addr = (VU->VI[_It_].US[0] * 16)& (VU == &VU1 ? 0x3fff : 0xfff);
1655 ptr = (u32*)GET_VU_MEM(VU, addr);
1656 if (_X) ptr[0] = VU->VF[_Fs_].UL[0];
1657 if (_Y) ptr[1] = VU->VF[_Fs_].UL[1];
1658 if (_Z) ptr[2] = VU->VF[_Fs_].UL[2];
1659 if (_W) ptr[3] = VU->VF[_Fs_].UL[3];
1660 }
1661
1662 void _vuSQI(VURegs * VU) {
1663 u32 addr;
1664 u32 *