2 * Copyright 2007 Vijay Kiran Kamuju
3 * Copyright 2007 David Adam
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #include "wine/test.h"
26 #define PI (4*atan(1.0))
27 #define admit_error 0.000001
29 #define expect_mat( expectedmat, gotmat)\
36 if (fabs(expectedmat[i][j]-gotmat[i][j])>admit_error)\
42 ok(equal, "Expected matrix=\n(%f,%f,%f,%f\n %f,%f,%f,%f\n %f,%f,%f,%f\n %f,%f,%f,%f\n)\n\n" \
43 "Got matrix=\n(%f,%f,%f,%f\n %f,%f,%f,%f\n %f,%f,%f,%f\n %f,%f,%f,%f)\n", \
44 expectedmat[0][0],expectedmat[0][1],expectedmat[0][2],expectedmat[0][3], \
45 expectedmat[1][0],expectedmat[1][1],expectedmat[1][2],expectedmat[1][3], \
46 expectedmat[2][0],expectedmat[2][1],expectedmat[2][2],expectedmat[2][3], \
47 expectedmat[3][0],expectedmat[3][1],expectedmat[3][2],expectedmat[3][3], \
48 gotmat[0][0],gotmat[0][1],gotmat[0][2],gotmat[0][3], \
49 gotmat[1][0],gotmat[1][1],gotmat[1][2],gotmat[1][3], \
50 gotmat[2][0],gotmat[2][1],gotmat[2][2],gotmat[2][3], \
51 gotmat[3][0],gotmat[3][1],gotmat[3][2],gotmat[3][3] ); \
54 #define expect_quat(expectedquat,gotquat) \
55 ok( (fabs(U1(expectedquat.v).x-U1(gotquat.v).x)<admit_error) && \
56 (fabs(U2(expectedquat.v).y-U2(gotquat.v).y)<admit_error) && \
57 (fabs(U3(expectedquat.v).z-U3(gotquat.v).z)<admit_error) && \
58 (fabs(expectedquat.s-gotquat.s)<admit_error), \
59 "Expected Quaternion %f %f %f %f , Got Quaternion %f %f %f %f\n", \
60 expectedquat.s,U1(expectedquat.v).x,U2(expectedquat.v).y,U3(expectedquat.v).z, \
61 gotquat.s,U1(gotquat.v).x,U2(gotquat.v).y,U3(gotquat.v).z);
63 #define expect_vec(expectedvec,gotvec) \
64 ok( ((fabs(U1(expectedvec).x-U1(gotvec).x)<admit_error)&&(fabs(U2(expectedvec).y-U2(gotvec).y)<admit_error)&&(fabs(U3(expectedvec).z-U3(gotvec).z)<admit_error)), \
65 "Expected Vector= (%f, %f, %f)\n , Got Vector= (%f, %f, %f)\n", \
66 U1(expectedvec).x,U2(expectedvec).y,U3(expectedvec).z, U1(gotvec).x, U2(gotvec).y, U3(gotvec).z);
68 static void VectorTest(void)
70 D3DVALUE mod
,par
,theta
;
71 D3DVECTOR e
,r
,u
,v
,w
,axis
,casnul
,norm
,ray
;
73 U1(u
).x
=2.0;U2(u
).y
=2.0;U3(u
).z
=1.0;
74 U1(v
).x
=4.0;U2(v
).y
=4.0;U3(v
).z
=0.0;
76 /*______________________VectorAdd_________________________________*/
77 D3DRMVectorAdd(&r
,&u
,&v
);
78 U1(e
).x
=6.0;U2(e
).y
=6.0;U3(e
).z
=1.0;
81 /*_______________________VectorSubtract__________________________*/
82 D3DRMVectorSubtract(&r
,&u
,&v
);
83 U1(e
).x
=-2.0;U2(e
).y
=-2.0;U3(e
).z
=1.0;
86 /*_______________________VectorCrossProduct_______________________*/
87 D3DRMVectorCrossProduct(&r
,&u
,&v
);
88 U1(e
).x
=-4.0;U2(e
).y
=4.0;U3(e
).z
=0.0;
91 /*_______________________VectorDotProduct__________________________*/
92 mod
=D3DRMVectorDotProduct(&u
,&v
);
93 ok((mod
== 16.0), "Expected 16.0, Got %f\n",mod
);
95 /*_______________________VectorModulus_____________________________*/
96 mod
=D3DRMVectorModulus(&u
);
97 ok((mod
== 3.0), "Expected 3.0, Got %f\n",mod
);
99 /*_______________________VectorNormalize___________________________*/
100 D3DRMVectorNormalize(&u
);
101 U1(e
).x
=2.0/3.0;U2(e
).y
=2.0/3.0;U3(e
).z
=1.0/3.0;
104 /* If u is the NULL vector, MSDN says that the return vector is NULL. In fact, the returned vector is (1,0,0). The following test case prove it. */
106 U1(casnul
).x
=0.0; U2(casnul
).y
=0.0; U3(casnul
).z
=0.0;
107 D3DRMVectorNormalize(&casnul
);
108 U1(e
).x
=1.0; U2(e
).y
=0.0; U3(e
).z
=0.0;
109 expect_vec(e
,casnul
);
111 /*____________________VectorReflect_________________________________*/
112 U1(ray
).x
=3.0; U2(ray
).y
=-4.0; U3(ray
).z
=5.0;
113 U1(norm
).x
=1.0; U2(norm
).y
=-2.0; U3(norm
).z
=6.0;
114 U1(e
).x
=79.0; U2(e
).y
=-160.0; U3(e
).z
=487.0;
115 D3DRMVectorReflect(&r
,&ray
,&norm
);
118 /*_______________________VectorRotate_______________________________*/
119 U1(w
).x
=3.0; U2(w
).y
=4.0; U3(w
).z
=0.0;
120 U1(axis
).x
=0.0; U2(axis
).y
=0.0; U3(axis
).z
=1.0;
122 D3DRMVectorRotate(&r
,&w
,&axis
,theta
);
123 U1(e
).x
=-0.3-0.4*sqrt(3.0); U2(e
).y
=0.3*sqrt(3.0)-0.4; U3(e
).z
=0.0;
126 /* The same formula gives D3DRMVectorRotate, for theta in [-PI/2;+PI/2] or not. The following test proves this fact.*/
128 D3DRMVectorRotate(&r
,&w
,&axis
,-PI
/4);
129 U1(e
).x
=1.4/sqrt(2.0); U2(e
).y
=0.2/sqrt(2.0); U3(e
).z
=0.0;
132 /*_______________________VectorScale__________________________*/
134 D3DRMVectorScale(&r
,&v
,par
);
135 U1(e
).x
=10.0; U2(e
).y
=10.0; U3(e
).z
=0.0;
139 static void MatrixTest(void)
142 D3DRMMATRIX4D exp
,mat
;
144 exp
[0][0]=-49.0; exp
[0][1]=4.0; exp
[0][2]=22.0; exp
[0][3]=0.0;
145 exp
[1][0]=20.0; exp
[1][1]=-39.0; exp
[1][2]=20.0; exp
[1][3]=0.0;
146 exp
[2][0]=10.0; exp
[2][1]=28.0; exp
[2][2]=-25.0; exp
[2][3]=0.0;
147 exp
[3][0]=0.0; exp
[3][1]=0.0; exp
[3][2]=0.0; exp
[3][3]=1.0;
148 q
.s
=1.0; U1(q
.v
).x
=2.0; U2(q
.v
).y
=3.0; U3(q
.v
).z
=4.0;
150 D3DRMMatrixFromQuaternion(mat
,&q
);
154 static void QuaternionTest(void)
157 D3DVALUE g
,h
,epsilon
,par
,theta
;
158 D3DRMQUATERNION q
,q1
,q2
,r
;
160 /*_________________QuaternionFromRotation___________________*/
161 U1(axis
).x
=1.0; U2(axis
).y
=1.0; U3(axis
).z
=1.0;
163 D3DRMQuaternionFromRotation(&r
,&axis
,theta
);
164 q
.s
=0.5; U1(q
.v
).x
=0.5; U2(q
.v
).y
=0.5; U3(q
.v
).z
=0.5;
167 /*_________________QuaternionSlerp_________________________*/
168 /* Interpolation slerp is in fact a linear interpolation, not a spherical linear
169 * interpolation. Moreover, if the angle of the two quaternions is in ]PI/2;3PI/2[, QuaternionSlerp
170 * interpolates between the first quaternion and the opposite of the second one. The test proves
171 * these two facts. */
173 q1
.s
=1.0; U1(q1
.v
).x
=2.0; U2(q1
.v
).y
=3.0; U3(q1
.v
).z
=50.0;
174 q2
.s
=-4.0; U1(q2
.v
).x
=6.0; U2(q2
.v
).y
=7.0; U3(q2
.v
).z
=8.0;
175 /* The angle between q1 and q2 is in [-PI/2,PI/2]. So, one interpolates between q1 and q2. */
177 g
=1.0-par
; h
=epsilon
*par
;
178 /* Part of the test proving that the interpolation is linear. */
180 U1(q
.v
).x
=g
*U1(q1
.v
).x
+h
*U1(q2
.v
).x
;
181 U2(q
.v
).y
=g
*U2(q1
.v
).y
+h
*U2(q2
.v
).y
;
182 U3(q
.v
).z
=g
*U3(q1
.v
).z
+h
*U3(q2
.v
).z
;
183 D3DRMQuaternionSlerp(&r
,&q1
,&q2
,par
);
186 q1
.s
=1.0; U1(q1
.v
).x
=2.0; U2(q1
.v
).y
=3.0; U3(q1
.v
).z
=50.0;
187 q2
.s
=-94.0; U1(q2
.v
).x
=6.0; U2(q2
.v
).y
=7.0; U3(q2
.v
).z
=-8.0;
188 /* The angle between q1 and q2 is not in [-PI/2,PI/2]. So, one interpolates between q1 and -q2. */
190 g
=1.0-par
; h
=epsilon
*par
;
192 U1(q
.v
).x
=g
*U1(q1
.v
).x
+h
*U1(q2
.v
).x
;
193 U2(q
.v
).y
=g
*U2(q1
.v
).y
+h
*U2(q2
.v
).y
;
194 U3(q
.v
).z
=g
*U3(q1
.v
).z
+h
*U3(q2
.v
).z
;
195 D3DRMQuaternionSlerp(&r
,&q1
,&q2
,par
);