ps2sdk  1.1
A collection of Open Source libraries used for developing applications on Sony's PlayStation 2® (PS2).
Functions
vuhw.c File Reference
#include <libvux.h>
+ Include dependency graph for vuhw.c:

Go to the source code of this file.

Functions

void Vu0IdMatrix (VU_MATRIX *m)
 
void Vu0ResetMatrix (VU_MATRIX *m)
 
void Vu0TransMatrix (VU_MATRIX *m, VU_VECTOR *t)
 
void Vu0TransMatrixXYZ (VU_MATRIX *m, float x, float y, float z)
 
void Vu0ScaleMatrix (VU_MATRIX *m, VU_VECTOR *s)
 
void Vu0ScaleMatrixXYZ (VU_MATRIX *m, float x, float y, float z)
 
void Vu0MulMatrix (VU_MATRIX *m0, VU_MATRIX *m1, VU_MATRIX *out)
 
void Vu0InverseMatrix (VU_MATRIX *in, VU_MATRIX *out)
 
void Vu0ApplyMatrix (VU_MATRIX *m, VU_VECTOR *v0, VU_VECTOR *out)
 
void Vu0ApplyRotMatrix (VU_MATRIX *m, VU_VECTOR *v0, VU_VECTOR *out)
 
void Vu0CopyMatrix (VU_MATRIX *dest, VU_MATRIX *src)
 
float Vu0DotProduct (VU_VECTOR *v0, VU_VECTOR *v1)
 

Function Documentation

◆ Vu0ApplyMatrix()

void Vu0ApplyMatrix ( VU_MATRIX *  m,
VU_VECTOR *  v0,
VU_VECTOR *  out 
)

Definition at line 218 of file vuhw.c.

219 {
220  /*
221  out->x = m->m[0][0]*v0->x + m->m[1][0]*v0->y + m->m[2][0]*v0->z + m->m[3][0]*v0->w;
222  out->y = m->m[0][1]*v0->x + m->m[1][1]*v0->y + m->m[2][1]*v0->z + m->m[3][1]*v0->w;
223  out->z = m->m[0][2]*v0->x + m->m[1][2]*v0->y + m->m[2][2]*v0->z + m->m[3][2]*v0->w;
224  out->w = m->m[0][3]*v0->x + m->m[1][3]*v0->y + m->m[2][3]*v0->z + m->m[3][3]*v0->w;
225  */
226 
227  asm __volatile__(
228 #if __GNUC__ > 3
229  "lqc2 $vf20, 0x00(%1) \n"
230  "lqc2 $vf16, 0x00(%0) \n"
231  "lqc2 $vf17, 0x10(%0) \n"
232  "lqc2 $vf18, 0x20(%0) \n"
233  "lqc2 $vf19, 0x30(%0) \n"
234  "vmulax.xyzw $ACC, $vf16,$vf20 \n"
235  "vmadday.xyzw $ACC, $vf17,$vf20 \n"
236  "vmaddaz.xyzw $ACC, $vf18,$vf20 \n"
237  "vmaddw.xyzw $vf20, $vf19,$vf20 \n"
238  "sqc2 $vf20,0x00(%2) \n"
239 #else
240  "lqc2 vf20, 0x00(%1) \n"
241  "lqc2 vf16, 0x00(%0) \n"
242  "lqc2 vf17, 0x10(%0) \n"
243  "lqc2 vf18, 0x20(%0) \n"
244  "lqc2 vf19, 0x30(%0) \n"
245  "vmulax.xyzw ACC, vf16,vf20 \n"
246  "vmadday.xyzw ACC, vf17,vf20 \n"
247  "vmaddaz.xyzw ACC, vf18,vf20 \n"
248  "vmaddw.xyzw vf20, vf19,vf20 \n"
249  "sqc2 vf20,0x00(%2) \n"
250 #endif
251  : : "r"(m), "r"(v0), "r"(out)
252  );
253 
254 }
v0
#define v0
Definition: as_reg_compat.h:35

References v0.

◆ Vu0ApplyRotMatrix()

void Vu0ApplyRotMatrix ( VU_MATRIX *  m,
VU_VECTOR *  v0,
VU_VECTOR *  out 
)

Definition at line 256 of file vuhw.c.

257 {
258  /*
259  out->x = m->m[0][0]*v0->x + m->m[1][0]*v0->y + m->m[2][0]*v0->z;
260  out->y = m->m[0][1]*v0->x + m->m[1][1]*v0->y + m->m[2][1]*v0->z;
261  out->z = m->m[0][2]*v0->x + m->m[1][2]*v0->y + m->m[2][2]*v0->z;
262  */
263 
264  asm __volatile__(
265 #if __GNUC__ > 3
266  "lqc2 $vf20, 0x00(%1) \n"
267  "lqc2 $vf16, 0x00(%0) \n"
268  "lqc2 $vf17, 0x10(%0) \n"
269  "lqc2 $vf18, 0x20(%0) \n"
270  "vmulax.xyz $ACC, $vf16,$vf20 \n"
271  "vmadday.xyz $ACC, $vf17,$vf20 \n"
272  "vmaddz.xyz $vf20, $vf18,$vf20 \n"
273  "vmulw.w $vf20, $vf0, $vf0 \n" // out->w = 1.0f
274  "sqc2 $vf20, 0x00(%2) \n" // copy result to out
275 #else
276  "lqc2 vf20, 0x00(%1) \n"
277  "lqc2 vf16, 0x00(%0) \n"
278  "lqc2 vf17, 0x10(%0) \n"
279  "lqc2 vf18, 0x20(%0) \n"
280  "vmulax.xyz ACC, vf16,vf20 \n"
281  "vmadday.xyz ACC, vf17,vf20 \n"
282  "vmaddz.xyz vf20, vf18,vf20 \n"
283  "vmulw.w vf20, vf0, vf0 \n" // out->w = 1.0f
284  "sqc2 vf20, 0x00(%2) \n" // copy result to out
285 #endif
286  : : "r"(m), "r"(v0), "r"(out)
287  );
288 
289 }

References v0.

◆ Vu0CopyMatrix()

void Vu0CopyMatrix ( VU_MATRIX *  dest,
VU_MATRIX *  src 
)

Definition at line 291 of file vuhw.c.

292 {
293 
294  asm __volatile__ (
295 #if __GNUC__ > 3
296  "lqc2 $vf1, 0(%1) \n" // load 1 qword from ee
297  "lqc2 $vf2, 16(%1) \n" // load 1 qword from ee
298  "lqc2 $vf3, 32(%1) \n" // load 1 qword from ee
299  "lqc2 $vf4, 48(%1) \n" // load 1 qword from ee
300 
301  "sqc2 $vf1, 0(%0) \n" // store 1 qword in ee
302  "sqc2 $vf2, 16(%0) \n" // store 1 qword in ee
303  "sqc2 $vf3, 32(%0) \n" // store 1 qword in ee
304  "sqc2 $vf4, 48(%0) \n" // store 1 qword in ee
305 #else
306  "lqc2 vf1, 0(%1) \n" // load 1 qword from ee
307  "lqc2 vf2, 16(%1) \n" // load 1 qword from ee
308  "lqc2 vf3, 32(%1) \n" // load 1 qword from ee
309  "lqc2 vf4, 48(%1) \n" // load 1 qword from ee
310 
311  "sqc2 vf1, 0(%0) \n" // store 1 qword in ee
312  "sqc2 vf2, 16(%0) \n" // store 1 qword in ee
313  "sqc2 vf3, 32(%0) \n" // store 1 qword in ee
314  "sqc2 vf4, 48(%0) \n" // store 1 qword in ee
315 #endif
316 
317  : : "r" (dest), "r" (src)
318  );
319 }

◆ Vu0DotProduct()

float Vu0DotProduct ( VU_VECTOR *  v0,
VU_VECTOR *  v1 
)

Definition at line 321 of file vuhw.c.

322 {
323  float ret=0;
324 
325  /* ret = (v0.x*v1.x + v0.y*v1.y + v0.z*v1.z);*/
326 
327  asm __volatile__ (
328 #if __GNUC__ > 3
329  "lqc2 $vf1, 0(%1) \n" // load 1 qword from ee
330  "lqc2 $vf2, 0(%2) \n" // load 1 qword from ee
331 
332  "vmul.xyz $vf3, $vf1, $vf2 \n" // mul v0 by v1
333 
334  "vaddy.x $vf3, $vf3, $vf3y \n" // add x+y and store in x
335  "vaddz.x $vf3, $vf3, $vf3z \n" // add z+x and store in x
336 
337  "qmfc2 %0, $vf3 \n" // copy vector to ee reg
338 #else
339  "lqc2 vf1, 0(%1) \n" // load 1 qword from ee
340  "lqc2 vf2, 0(%2) \n" // load 1 qword from ee
341 
342  "vmul.xyz vf3, vf1, vf2 \n" // mul v0 by v1
343 
344  "vaddy.x vf3, vf3, vf3y \n" // add x+y and store in x
345  "vaddz.x vf3, vf3, vf3z \n" // add z+x and store in x
346 
347  "qmfc2 %0, vf3 \n" // copy vector to ee reg
348 #endif
349  : "=r" (ret) : "r" (v0), "r" (v1)
350  );
351 
352  return ret;
353 }
v1
#define v1
Definition: as_reg_compat.h:36

References v0, and v1.

◆ Vu0IdMatrix()

void Vu0IdMatrix ( VU_MATRIX *  m)

Definition at line 13 of file vuhw.c.

14 {
15  Vu0ResetMatrix(m);
16 }
Vu0ResetMatrix
void Vu0ResetMatrix(VU_MATRIX *m)
Definition: vuhw.c:18

References Vu0ResetMatrix().

◆ Vu0InverseMatrix()

void Vu0InverseMatrix ( VU_MATRIX *  in,
VU_MATRIX *  out 
)

Definition at line 215 of file vuhw.c.

216 {}

◆ Vu0MulMatrix()

void Vu0MulMatrix ( VU_MATRIX *  m0,
VU_MATRIX *  m1,
VU_MATRIX *  out 
)

Definition at line 148 of file vuhw.c.

149 {
150 
151  asm __volatile__ (
152 #if __GNUC__ > 3
153  "lqc2 $vf1, 0x00(%0) \n"
154  "lqc2 $vf2, 0x10(%0) \n"
155  "lqc2 $vf3, 0x20(%0) \n"
156  "lqc2 $vf4, 0x30(%0) \n"
157  "lqc2 $vf5, 0x00(%1) \n"
158  "lqc2 $vf6, 0x10(%1) \n"
159  "lqc2 $vf7, 0x20(%1) \n"
160  "lqc2 $vf8, 0x30(%1) \n"
161  "vmulax.xyzw $ACC, $vf5, $vf1 \n"
162  "vmadday.xyzw $ACC, $vf6, $vf1 \n"
163  "vmaddaz.xyzw $ACC, $vf7, $vf1 \n"
164  "vmaddw.xyzw $vf1, $vf8, $vf1 \n"
165  "vmulax.xyzw $ACC, $vf5, $vf2 \n"
166  "vmadday.xyzw $ACC, $vf6, $vf2 \n"
167  "vmaddaz.xyzw $ACC, $vf7, $vf2 \n"
168  "vmaddw.xyzw $vf2, $vf8, $vf2 \n"
169  "vmulax.xyzw $ACC, $vf5, $vf3 \n"
170  "vmadday.xyzw $ACC, $vf6, $vf3 \n"
171  "vmaddaz.xyzw $ACC, $vf7, $vf3 \n"
172  "vmaddw.xyzw $vf3, $vf8, $vf3 \n"
173  "vmulax.xyzw $ACC, $vf5, $vf4 \n"
174  "vmadday.xyzw $ACC, $vf6, $vf4 \n"
175  "vmaddaz.xyzw $ACC, $vf7, $vf4 \n"
176  "vmaddw.xyzw $vf4, $vf8, $vf4 \n"
177  "sqc2 $vf1, 0x00(%2) \n"
178  "sqc2 $vf2, 0x10(%2) \n"
179  "sqc2 $vf3, 0x20(%2) \n"
180  "sqc2 $vf4, 0x30(%2) \n"
181 #else
182  "lqc2 vf1, 0x00(%0) \n"
183  "lqc2 vf2, 0x10(%0) \n"
184  "lqc2 vf3, 0x20(%0) \n"
185  "lqc2 vf4, 0x30(%0) \n"
186  "lqc2 vf5, 0x00(%1) \n"
187  "lqc2 vf6, 0x10(%1) \n"
188  "lqc2 vf7, 0x20(%1) \n"
189  "lqc2 vf8, 0x30(%1) \n"
190  "vmulax.xyzw ACC, vf5, vf1 \n"
191  "vmadday.xyzw ACC, vf6, vf1 \n"
192  "vmaddaz.xyzw ACC, vf7, vf1 \n"
193  "vmaddw.xyzw vf1, vf8, vf1 \n"
194  "vmulax.xyzw ACC, vf5, vf2 \n"
195  "vmadday.xyzw ACC, vf6, vf2 \n"
196  "vmaddaz.xyzw ACC, vf7, vf2 \n"
197  "vmaddw.xyzw vf2, vf8, vf2 \n"
198  "vmulax.xyzw ACC, vf5, vf3 \n"
199  "vmadday.xyzw ACC, vf6, vf3 \n"
200  "vmaddaz.xyzw ACC, vf7, vf3 \n"
201  "vmaddw.xyzw vf3, vf8, vf3 \n"
202  "vmulax.xyzw ACC, vf5, vf4 \n"
203  "vmadday.xyzw ACC, vf6, vf4 \n"
204  "vmaddaz.xyzw ACC, vf7, vf4 \n"
205  "vmaddw.xyzw vf4, vf8, vf4 \n"
206  "sqc2 vf1, 0x00(%2) \n"
207  "sqc2 vf2, 0x10(%2) \n"
208  "sqc2 vf3, 0x20(%2) \n"
209  "sqc2 vf4, 0x30(%2) \n"
210 #endif
211  : : "r" (m0), "r" (m1), "r" (out)
212  );
213 }

◆ Vu0ResetMatrix()

void Vu0ResetMatrix ( VU_MATRIX *  m)

Definition at line 18 of file vuhw.c.

19 {
20  asm __volatile__(
21 #if __GNUC__ > 3
22  "vmr32.xyzw $vf18, $vf0 \n"
23  "sqc2 $vf0, 0x30(%0) \n"
24  "vmr32.xyzw $vf17, $vf18 \n"
25  "sqc2 $vf18, 0x20(%0) \n"
26  "vmr32.xyzw $vf16, $vf17 \n"
27  "sqc2 $vf17, 0x10(%0) \n"
28  "sqc2 $vf16, 0x00(%0) \n"
29 #else
30  "vmr32.xyzw vf18, vf00 \n"
31  "sqc2 vf00, 0x30(%0) \n"
32  "vmr32.xyzw vf17, vf18 \n"
33  "sqc2 vf18, 0x20(%0) \n"
34  "vmr32.xyzw vf16, vf17 \n"
35  "sqc2 vf17, 0x10(%0) \n"
36  "sqc2 vf16, 0x00(%0) \n"
37 #endif
38 
39  : : "r"(m)
40  );
41 }

Referenced by Vu0IdMatrix().

◆ Vu0ScaleMatrix()

void Vu0ScaleMatrix ( VU_MATRIX *  m,
VU_VECTOR *  s 
)

Definition at line 93 of file vuhw.c.

94 {
95 
96  asm __volatile__ (
97 #if __GNUC__ > 3
98  "lqc2 $vf1, 0(%1) \n" // load 1 qword from 't' to vu's vf1
99  "lqc2 $vf10, 0(%0) \n" // load m[0][0]
100  "lqc2 $vf11, 16(%0) \n" // load m[1][0]
101  "lqc2 $vf12, 32(%0) \n" // load m[2][0]
102  // "lqc2 $vf123,48(%0) \n" // load m[3][0]
103 
104  "vmulx.x $vf10, $vf10, $vf1x \n" // multiply [0][0] by s->x and store in [0][0]
105  "vmuly.y $vf11, $vf11, $vf1y \n"
106  "vmulz.z $vf12, $vf12, $vf1z \n"
107 
108 
109  "sqc2 $vf10, 0(%0) \n" // store v m[0][0]
110  "sqc2 $vf11, 16(%0) \n" // store v m[1][0]
111  "sqc2 $vf12, 32(%0) \n" // store v m[2][0]
112 // "sqc2 $vf1, 48(%0) \n" // store v m[3][0]
113 #else
114  "lqc2 vf1, 0(%1) \n" // load 1 qword from 't' to vu's vf1
115  "lqc2 vf10, 0(%0) \n" // load m[0][0]
116  "lqc2 vf11, 16(%0) \n" // load m[1][0]
117  "lqc2 vf12, 32(%0) \n" // load m[2][0]
118  // "lqc2 vf123,48(%0) \n" // load m[3][0]
119 
120  "vmulx.x vf10, vf10, vf1x \n" // multiply [0][0] by s->x and store in [0][0]
121  "vmuly.y vf11, vf11, vf1y \n"
122  "vmulz.z vf12, vf12, vf1z \n"
123 
124 
125  "sqc2 vf10, 0(%0) \n" // store v m[0][0]
126  "sqc2 vf11, 16(%0) \n" // store v m[1][0]
127  "sqc2 vf12, 32(%0) \n" // store v m[2][0]
128 // "sqc2 vf1, 48(%0) \n" // store v m[3][0]
129 #endif
130 
131  : : "r" (m), "r" (s)
132  );
133 
134 }
s
s32 s
Definition: ps2ipc.c:30

References s.

Referenced by Vu0ScaleMatrixXYZ().

◆ Vu0ScaleMatrixXYZ()

void Vu0ScaleMatrixXYZ ( VU_MATRIX *  m,
float  x,
float  y,
float  z 
)

Definition at line 136 of file vuhw.c.

137 {
138  VU_VECTOR s;
139  s.x = x;
140  s.y = y;
141  s.z = z;
142  s.w = 1.0f;
143 
144  Vu0ScaleMatrix(m, &s);
145 
146 }
x
s32 x
Definition: libmouse.c:34
y
s32 y
Definition: libmouse.c:34
VU_VECTOR
Definition: libvux.h:44
Vu0ScaleMatrix
void Vu0ScaleMatrix(VU_MATRIX *m, VU_VECTOR *s)
Definition: vuhw.c:93

References s, Vu0ScaleMatrix(), x, and y.

◆ Vu0TransMatrix()

void Vu0TransMatrix ( VU_MATRIX *  m,
VU_VECTOR *  t 
)

Definition at line 61 of file vuhw.c.

62 {
63 
64  asm __volatile__ (
65 #if __GNUC__ > 3
66  "lqc2 $vf1, 0(%1) \n" // load 1 qword from 't' to vu's vf1
67  "sqc2 $vf1, 48(%0) \n" // store vf1 data in 'm' with 48 bytes offset which is m[3][0]
68 #else
69  "lqc2 vf1, 0(%1) \n" // load 1 qword from 't' to vu's vf1
70  "sqc2 vf1, 48(%0) \n" // store vf1 data in 'm' with 48 bytes offset which is m[3][0]
71 #endif
72 
73  : : "r" (m), "r" (t)
74  );
75 }

Referenced by Vu0TransMatrixXYZ().

◆ Vu0TransMatrixXYZ()

void Vu0TransMatrixXYZ ( VU_MATRIX *  m,
float  x,
float  y,
float  z 
)

Definition at line 77 of file vuhw.c.

78 {
79  VU_VECTOR t;
80 
81  t.x = x;
82  t.y = y;
83  t.z = z;
84  t.w = 1.0f;
85 
86  Vu0TransMatrix(m, &t);
87 }
VU_VECTOR::w
float w
Definition: libvux.h:48
VU_VECTOR::x
float x
Definition: libvux.h:45
VU_VECTOR::z
float z
Definition: libvux.h:47
VU_VECTOR::y
float y
Definition: libvux.h:46
Vu0TransMatrix
void Vu0TransMatrix(VU_MATRIX *m, VU_VECTOR *t)
Definition: vuhw.c:61

References Vu0TransMatrix(), VU_VECTOR::w, VU_VECTOR::x, x, VU_VECTOR::y, y, and VU_VECTOR::z.