?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3dxof: Small cleanup.
[wine/wine64.git] / dlls / d3dx8 / math.c
blobbcab3b4676eab6249d215f289097a8be45e42ebf
1 /*
2 * Copyright 2007 David Adam
3 * Copyright 2008 Jérôme Gardou
4 *
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.
9 *
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.
14 *
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
18 */
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <stdarg.h>
23 #include <assert.h>
24
25 #define NONAMELESSUNION
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "wingdi.h"
30 #include "d3dx8_private.h"
31
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(d3dx8);
35
36 static const ID3DXMatrixStackVtbl ID3DXMatrixStack_Vtbl;
37
38 /*_________________D3DXColor____________________*/
39
40 D3DXCOLOR* WINAPI D3DXColorAdjustContrast(D3DXCOLOR *pout, CONST D3DXCOLOR *pc, FLOAT s)
41 {
42 pout->r = 0.5f + s * (pc->r - 0.5f);
43 pout->g = 0.5f + s * (pc->g - 0.5f);
44 pout->b = 0.5f + s * (pc->b - 0.5f);
45 pout->a = pc->a;
46 return pout;
47 }
48
49 D3DXCOLOR* WINAPI D3DXColorAdjustSaturation(D3DXCOLOR *pout, CONST D3DXCOLOR *pc, FLOAT s)
50 {
51 FLOAT grey;
52
53 grey = pc->r * 0.2125f + pc->g * 0.7154f + pc->b * 0.0721f;
54 pout->r = grey + s * (pc->r - grey);
55 pout->g = grey + s * (pc->g - grey);
56 pout->b = grey + s * (pc->b - grey);
57 pout->a = pc->a;
58 return pout;
59 }
60
61 /*_________________D3DXMatrix____________________*/
62
63 D3DXMATRIX* WINAPI D3DXMatrixAffineTransformation(D3DXMATRIX *pout, FLOAT scaling, CONST D3DXVECTOR3 *rotationcenter, CONST D3DXQUATERNION *rotation, CONST D3DXVECTOR3 *translation)
64 {
65 D3DXMATRIX m1, m2, m3, m4, m5;
66
67 D3DXMatrixScaling(&m1, scaling, scaling, scaling);
68 if ( !rotationcenter )
69 {
70 D3DXMatrixIdentity(&m2);
71 D3DXMatrixIdentity(&m4);
72 }
73 else
74 {
75 D3DXMatrixTranslation(&m2, -rotationcenter->x, -rotationcenter->y, -rotationcenter->z);
76 D3DXMatrixTranslation(&m4, rotationcenter->x, rotationcenter->y, rotationcenter->z);
77 }
78 if ( !rotation )
79 {
80 D3DXMatrixIdentity(&m3);
81 }
82 else
83 {
84 D3DXMatrixRotationQuaternion(&m3, rotation);
85 }
86 if ( !translation )
87 {
88 D3DXMatrixIdentity(&m5);
89 }
90 else
91 {
92 D3DXMatrixTranslation(&m5, translation->x, translation->y, translation->z);
93 }
94 D3DXMatrixMultiply(&m1, &m1, &m2);
95 D3DXMatrixMultiply(&m1, &m1, &m3);
96 D3DXMatrixMultiply(&m1, &m1, &m4);
97 D3DXMatrixMultiply(pout, &m1, &m5);
98 return pout;
99 }
100
101 FLOAT WINAPI D3DXMatrixfDeterminant(CONST D3DXMATRIX *pm)
102 {
103 D3DXVECTOR4 minor, v1, v2, v3;
104 FLOAT det;
105
106 v1.x = pm->u.m[0][0]; v1.y = pm->u.m[1][0]; v1.z = pm->u.m[2][0]; v1.w = pm->u.m[3][0];
107 v2.x = pm->u.m[0][1]; v2.y = pm->u.m[1][1]; v2.z = pm->u.m[2][1]; v2.w = pm->u.m[3][1];
108 v3.x = pm->u.m[0][2]; v3.y = pm->u.m[1][2]; v3.z = pm->u.m[2][2]; v3.w = pm->u.m[3][2];
109 D3DXVec4Cross(&minor, &v1, &v2, &v3);
110 det = - (pm->u.m[0][3] * minor.x + pm->u.m[1][3] * minor.y + pm->u.m[2][3] * minor.z + pm->u.m[3][3] * minor.w);
111 return det;
112 }
113
114 D3DXMATRIX* WINAPI D3DXMatrixInverse(D3DXMATRIX *pout, FLOAT *pdeterminant, CONST D3DXMATRIX *pm)
115 {
116 int a, i, j;
117 D3DXVECTOR4 v, vec[3];
118 FLOAT det;
119
120 det = D3DXMatrixfDeterminant(pm);
121 if ( !det ) return NULL;
122 if ( pdeterminant ) *pdeterminant = det;
123 for (i=0; i<4; i++)
124 {
125 for (j=0; j<4; j++)
126 {
127 if (j != i )
128 {
129 a = j;
130 if ( j > i ) a = a-1;
131 vec[a].x = pm->u.m[j][0];
132 vec[a].y = pm->u.m[j][1];
133 vec[a].z = pm->u.m[j][2];
134 vec[a].w = pm->u.m[j][3];
135 }
136 }
137 D3DXVec4Cross(&v, &vec[0], &vec[1], &vec[2]);
138 pout->u.m[0][i] = pow(-1.0f, i) * v.x / det;
139 pout->u.m[1][i] = pow(-1.0f, i) * v.y / det;
140 pout->u.m[2][i] = pow(-1.0f, i) * v.z / det;
141 pout->u.m[3][i] = pow(-1.0f, i) * v.w / det;
142 }
143 return pout;
144 }
145
146 D3DXMATRIX* WINAPI D3DXMatrixLookAtLH(D3DXMATRIX *pout, CONST D3DXVECTOR3 *peye, CONST D3DXVECTOR3 *pat, CONST D3DXVECTOR3 *pup)
147 {
148 D3DXVECTOR3 right, rightn, up, upn, vec, vec2;
149
150 D3DXVec3Subtract(&vec2, pat, peye);
151 D3DXVec3Normalize(&vec, &vec2);
152 D3DXVec3Cross(&right, pup, &vec);
153 D3DXVec3Cross(&up, &vec, &right);
154 D3DXVec3Normalize(&rightn, &right);
155 D3DXVec3Normalize(&upn, &up);
156 pout->u.m[0][0] = rightn.x;
157 pout->u.m[1][0] = rightn.y;
158 pout->u.m[2][0] = rightn.z;
159 pout->u.m[3][0] = -D3DXVec3Dot(&rightn,peye);
160 pout->u.m[0][1] = upn.x;
161 pout->u.m[1][1] = upn.y;
162 pout->u.m[2][1] = upn.z;
163 pout->u.m[3][1] = -D3DXVec3Dot(&upn, peye);
164 pout->u.m[0][2] = vec.x;
165 pout->u.m[1][2] = vec.y;
166 pout->u.m[2][2] = vec.z;
167 pout->u.m[3][2] = -D3DXVec3Dot(&vec, peye);
168 pout->u.m[0][3] = 0.0f;
169 pout->u.m[1][3] = 0.0f;
170 pout->u.m[2][3] = 0.0f;
171 pout->u.m[3][3] = 1.0f;
172 return pout;
173 }
174
175 D3DXMATRIX* WINAPI D3DXMatrixLookAtRH(D3DXMATRIX *pout, CONST D3DXVECTOR3 *peye, CONST D3DXVECTOR3 *pat, CONST D3DXVECTOR3 *pup)
176 {
177 D3DXVECTOR3 right, rightn, up, upn, vec, vec2;
178
179 D3DXVec3Subtract(&vec2, pat, peye);
180 D3DXVec3Normalize(&vec, &vec2);
181 D3DXVec3Cross(&right, pup, &vec);
182 D3DXVec3Cross(&up, &vec, &right);
183 D3DXVec3Normalize(&rightn, &right);
184 D3DXVec3Normalize(&upn, &up);
185 pout->u.m[0][0] = -rightn.x;
186 pout->u.m[1][0] = -rightn.y;
187 pout->u.m[2][0] = -rightn.z;
188 pout->u.m[3][0] = D3DXVec3Dot(&rightn,peye);
189 pout->u.m[0][1] = upn.x;
190 pout->u.m[1][1] = upn.y;
191 pout->u.m[2][1] = upn.z;
192 pout->u.m[3][1] = -D3DXVec3Dot(&upn, peye);
193 pout->u.m[0][2] = -vec.x;
194 pout->u.m[1][2] = -vec.y;
195 pout->u.m[2][2] = -vec.z;
196 pout->u.m[3][2] = D3DXVec3Dot(&vec, peye);
197 pout->u.m[0][3] = 0.0f;
198 pout->u.m[1][3] = 0.0f;
199 pout->u.m[2][3] = 0.0f;
200 pout->u.m[3][3] = 1.0f;
201 return pout;
202 }
203
204 D3DXMATRIX* WINAPI D3DXMatrixMultiply(D3DXMATRIX *pout, CONST D3DXMATRIX *pm1, CONST D3DXMATRIX *pm2)
205 {
206 D3DXMATRIX out;
207 int i,j;
208
209 for (i=0; i<4; i++)
210 {
211 for (j=0; j<4; j++)
212 {
213 out.u.m[i][j] = pm1->u.m[i][0] * pm2->u.m[0][j] + pm1->u.m[i][1] * pm2->u.m[1][j] + pm1->u.m[i][2] * pm2->u.m[2][j] + pm1->u.m[i][3] * pm2->u.m[3][j];
214 }
215 }
216 *pout = out;
217 return pout;
218 }
219
220 D3DXMATRIX* WINAPI D3DXMatrixMultiplyTranspose(D3DXMATRIX *pout, CONST D3DXMATRIX *pm1, CONST D3DXMATRIX *pm2)
221 {
222 D3DXMatrixMultiply(pout, pm1, pm2);
223 D3DXMatrixTranspose(pout, pout);
224 return pout;
225 }
226
227 D3DXMATRIX* WINAPI D3DXMatrixOrthoLH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)
228 {
229 D3DXMatrixIdentity(pout);
230 pout->u.m[0][0] = 2.0f / w;
231 pout->u.m[1][1] = 2.0f / h;
232 pout->u.m[2][2] = 1.0f / (zf - zn);
233 pout->u.m[3][2] = zn / (zn - zf);
234 return pout;
235 }
236
237 D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterLH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf)
238 {
239 D3DXMatrixIdentity(pout);
240 pout->u.m[0][0] = 2.0f / (r - l);
241 pout->u.m[1][1] = 2.0f / (t - b);
242 pout->u.m[2][2] = 1.0f / (zf -zn);
243 pout->u.m[3][0] = -1.0f -2.0f *l / (r - l);
244 pout->u.m[3][1] = 1.0f + 2.0f * t / (b - t);
245 pout->u.m[3][2] = zn / (zn -zf);
246 return pout;
247 }
248
249 D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterRH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf)
250 {
251 D3DXMatrixIdentity(pout);
252 pout->u.m[0][0] = 2.0f / (r - l);
253 pout->u.m[1][1] = 2.0f / (t - b);
254 pout->u.m[2][2] = 1.0f / (zn -zf);
255 pout->u.m[3][0] = -1.0f -2.0f *l / (r - l);
256 pout->u.m[3][1] = 1.0f + 2.0f * t / (b - t);
257 pout->u.m[3][2] = zn / (zn -zf);
258 return pout;
259 }
260
261 D3DXMATRIX* WINAPI D3DXMatrixOrthoRH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)
262 {
263 D3DXMatrixIdentity(pout);
264 pout->u.m[0][0] = 2.0f / w;
265 pout->u.m[1][1] = 2.0f / h;
266 pout->u.m[2][2] = 1.0f / (zn - zf);
267 pout->u.m[3][2] = zn / (zn - zf);
268 return pout;
269 }
270
271 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovLH(D3DXMATRIX *pout, FLOAT fovy, FLOAT aspect, FLOAT zn, FLOAT zf)
272 {
273 D3DXMatrixIdentity(pout);
274 pout->u.m[0][0] = 1.0f / (aspect * tan(fovy/2.0f));
275 pout->u.m[1][1] = 1.0f / tan(fovy/2.0f);
276 pout->u.m[2][2] = zf / (zf - zn);
277 pout->u.m[2][3] = 1.0f;
278 pout->u.m[3][2] = (zf * zn) / (zn - zf);
279 pout->u.m[3][3] = 0.0f;
280 return pout;
281 }
282
283 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovRH(D3DXMATRIX *pout, FLOAT fovy, FLOAT aspect, FLOAT zn, FLOAT zf)
284 {
285 D3DXMatrixIdentity(pout);
286 pout->u.m[0][0] = 1.0f / (aspect * tan(fovy/2.0f));
287 pout->u.m[1][1] = 1.0f / tan(fovy/2.0f);
288 pout->u.m[2][2] = zf / (zn - zf);
289 pout->u.m[2][3] = -1.0f;
290 pout->u.m[3][2] = (zf * zn) / (zn - zf);
291 pout->u.m[3][3] = 0.0f;
292 return pout;
293 }
294
295 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveLH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)
296 {
297 D3DXMatrixIdentity(pout);
298 pout->u.m[0][0] = 2.0f * zn / w;
299 pout->u.m[1][1] = 2.0f * zn / h;
300 pout->u.m[2][2] = zf / (zf - zn);
301 pout->u.m[3][2] = (zn * zf) / (zn - zf);
302 pout->u.m[2][3] = 1.0f;
303 pout->u.m[3][3] = 0.0f;
304 return pout;
305 }
306
307 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterLH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf)
308 {
309 D3DXMatrixIdentity(pout);
310 pout->u.m[0][0] = 2.0f * zn / (r - l);
311 pout->u.m[1][1] = -2.0f * zn / (b - t);
312 pout->u.m[2][0] = -1.0f - 2.0f * l / (r - l);
313 pout->u.m[2][1] = 1.0f + 2.0f * t / (b - t);
314 pout->u.m[2][2] = - zf / (zn - zf);
315 pout->u.m[3][2] = (zn * zf) / (zn -zf);
316 pout->u.m[2][3] = 1.0f;
317 pout->u.m[3][3] = 0.0f;
318 return pout;
319 }
320
321 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterRH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf)
322 {
323 D3DXMatrixIdentity(pout);
324 pout->u.m[0][0] = 2.0f * zn / (r - l);
325 pout->u.m[1][1] = -2.0f * zn / (b - t);
326 pout->u.m[2][0] = 1.0f + 2.0f * l / (r - l);
327 pout->u.m[2][1] = -1.0f -2.0f * t / (b - t);
328 pout->u.m[2][2] = zf / (zn - zf);
329 pout->u.m[3][2] = (zn * zf) / (zn -zf);
330 pout->u.m[2][3] = -1.0f;
331 pout->u.m[3][3] = 0.0f;
332 return pout;
333 }
334
335 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveRH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)
336 {
337 D3DXMatrixIdentity(pout);
338 pout->u.m[0][0] = 2.0f * zn / w;
339 pout->u.m[1][1] = 2.0f * zn / h;
340 pout->u.m[2][2] = zf / (zn - zf);
341 pout->u.m[3][2] = (zn * zf) / (zn - zf);
342 pout->u.m[2][3] = -1.0f;
343 pout->u.m[3][3] = 0.0f;
344 return pout;
345 }
346
347 D3DXMATRIX* WINAPI D3DXMatrixReflect(D3DXMATRIX *pout, CONST D3DXPLANE *pplane)
348 {
349 D3DXPLANE Nplane;
350
351 D3DXPlaneNormalize(&Nplane, pplane);
352 D3DXMatrixIdentity(pout);
353 pout->u.m[0][0] = 1.0f - 2.0f * Nplane.a * Nplane.a;
354 pout->u.m[0][1] = -2.0f * Nplane.a * Nplane.b;
355 pout->u.m[0][2] = -2.0f * Nplane.a * Nplane.c;
356 pout->u.m[1][0] = -2.0f * Nplane.a * Nplane.b;
357 pout->u.m[1][1] = 1.0f - 2.0f * Nplane.b * Nplane.b;
358 pout->u.m[1][2] = -2.0f * Nplane.b * Nplane.c;
359 pout->u.m[2][0] = -2.0f * Nplane.c * Nplane.a;
360 pout->u.m[2][1] = -2.0f * Nplane.c * Nplane.b;
361 pout->u.m[2][2] = 1.0f - 2.0f * Nplane.c * Nplane.c;
362 pout->u.m[3][0] = -2.0f * Nplane.d * Nplane.a;
363 pout->u.m[3][1] = -2.0f * Nplane.d * Nplane.b;
364 pout->u.m[3][2] = -2.0f * Nplane.d * Nplane.c;
365 return pout;
366 }
367
368 D3DXMATRIX* WINAPI D3DXMatrixRotationAxis(D3DXMATRIX *pout, CONST D3DXVECTOR3 *pv, FLOAT angle)
369 {
370 D3DXVECTOR3 v;
371
372 D3DXVec3Normalize(&v,pv);
373 D3DXMatrixIdentity(pout);
374 pout->u.m[0][0] = (1.0f - cos(angle)) * v.x * v.x + cos(angle);
375 pout->u.m[1][0] = (1.0f - cos(angle)) * v.x * v.y - sin(angle) * v.z;
376 pout->u.m[2][0] = (1.0f - cos(angle)) * v.x * v.z + sin(angle) * v.y;
377 pout->u.m[0][1] = (1.0f - cos(angle)) * v.y * v.x + sin(angle) * v.z;
378 pout->u.m[1][1] = (1.0f - cos(angle)) * v.y * v.y + cos(angle);
379 pout->u.m[2][1] = (1.0f - cos(angle)) * v.y * v.z - sin(angle) * v.x;
380 pout->u.m[0][2] = (1.0f - cos(angle)) * v.z * v.x - sin(angle) * v.y;
381 pout->u.m[1][2] = (1.0f - cos(angle)) * v.z * v.y + sin(angle) * v.x;
382 pout->u.m[2][2] = (1.0f - cos(angle)) * v.z * v.z + cos(angle);
383 return pout;
384 }
385
386 D3DXMATRIX* WINAPI D3DXMatrixRotationQuaternion(D3DXMATRIX *pout, CONST D3DXQUATERNION *pq)
387 {
388 D3DXMatrixIdentity(pout);
389 pout->u.m[0][0] = 1.0f - 2.0f * (pq->y * pq->y + pq->z * pq->z);
390 pout->u.m[0][1] = 2.0f * (pq->x *pq->y + pq->z * pq->w);
391 pout->u.m[0][2] = 2.0f * (pq->x * pq->z - pq->y * pq->w);
392 pout->u.m[1][0] = 2.0f * (pq->x * pq->y - pq->z * pq->w);
393 pout->u.m[1][1] = 1.0f - 2.0f * (pq->x * pq->x + pq->z * pq->z);
394 pout->u.m[1][2] = 2.0f * (pq->y *pq->z + pq->x *pq->w);
395 pout->u.m[2][0] = 2.0f * (pq->x * pq->z + pq->y * pq->w);
396 pout->u.m[2][1] = 2.0f * (pq->y *pq->z - pq->x *pq->w);
397 pout->u.m[2][2] = 1.0f - 2.0f * (pq->x * pq->x + pq->y * pq->y);
398 return pout;
399 }
400
401 D3DXMATRIX* WINAPI D3DXMatrixRotationX(D3DXMATRIX *pout, FLOAT angle)
402 {
403 D3DXMatrixIdentity(pout);
404 pout->u.m[1][1] = cos(angle);
405 pout->u.m[2][2] = cos(angle);
406 pout->u.m[1][2] = sin(angle);
407 pout->u.m[2][1] = -sin(angle);
408 return pout;
409 }
410
411 D3DXMATRIX* WINAPI D3DXMatrixRotationY(D3DXMATRIX *pout, FLOAT angle)
412 {
413 D3DXMatrixIdentity(pout);
414 pout->u.m[0][0] = cos(angle);
415 pout->u.m[2][2] = cos(angle);
416 pout->u.m[0][2] = -sin(angle);
417 pout->u.m[2][0] = sin(angle);
418 return pout;
419 }
420
421 D3DXMATRIX* WINAPI D3DXMatrixRotationYawPitchRoll(D3DXMATRIX *pout, FLOAT yaw, FLOAT pitch, FLOAT roll)
422 {
423 D3DXMATRIX m;
424
425 D3DXMatrixIdentity(pout);
426 D3DXMatrixRotationZ(&m, roll);
427 D3DXMatrixMultiply(pout, pout, &m);
428 D3DXMatrixRotationX(&m, pitch);
429 D3DXMatrixMultiply(pout, pout, &m);
430 D3DXMatrixRotationY(&m, yaw);
431 D3DXMatrixMultiply(pout, pout, &m);
432 return pout;
433 }
434 D3DXMATRIX* WINAPI D3DXMatrixRotationZ(D3DXMATRIX *pout, FLOAT angle)
435 {
436 D3DXMatrixIdentity(pout);
437 pout->u.m[0][0] = cos(angle);
438 pout->u.m[1][1] = cos(angle);
439 pout->u.m[0][1] = sin(angle);
440 pout->u.m[1][0] = -sin(angle);
441 return pout;
442 }
443
444 D3DXMATRIX* WINAPI D3DXMatrixScaling(D3DXMATRIX *pout, FLOAT sx, FLOAT sy, FLOAT sz)
445 {
446 D3DXMatrixIdentity(pout);
447 pout->u.m[0][0] = sx;
448 pout->u.m[1][1] = sy;
449 pout->u.m[2][2] = sz;
450 return pout;
451 }
452
453 D3DXMATRIX* WINAPI D3DXMatrixShadow(D3DXMATRIX *pout, CONST D3DXVECTOR4 *plight, CONST D3DXPLANE *pplane)
454 {
455 D3DXPLANE Nplane;
456 FLOAT dot;
457
458 D3DXPlaneNormalize(&Nplane, pplane);
459 dot = D3DXPlaneDot(&Nplane, plight);
460 pout->u.m[0][0] = dot - Nplane.a * plight->x;
461 pout->u.m[0][1] = -Nplane.a * plight->y;
462 pout->u.m[0][2] = -Nplane.a * plight->z;
463 pout->u.m[0][3] = -Nplane.a * plight->w;
464 pout->u.m[1][0] = -Nplane.b * plight->x;
465 pout->u.m[1][1] = dot - Nplane.b * plight->y;
466 pout->u.m[1][2] = -Nplane.b * plight->z;
467 pout->u.m[1][3] = -Nplane.b * plight->w;
468 pout->u.m[2][0] = -Nplane.c * plight->x;
469 pout->u.m[2][1] = -Nplane.c * plight->y;
470 pout->u.m[2][2] = dot - Nplane.c * plight->z;
471 pout->u.m[2][3] = -Nplane.c * plight->w;
472 pout->u.m[3][0] = -Nplane.d * plight->x;
473 pout->u.m[3][1] = -Nplane.d * plight->y;
474 pout->u.m[3][2] = -Nplane.d * plight->z;
475 pout->u.m[3][3] = dot - Nplane.d * plight->w;
476 return pout;
477 }
478
479 D3DXMATRIX* WINAPI D3DXMatrixTransformation(D3DXMATRIX *pout, CONST D3DXVECTOR3 *pscalingcenter, CONST D3DXQUATERNION *pscalingrotation, CONST D3DXVECTOR3 *pscaling, CONST D3DXVECTOR3 *protationcenter, CONST D3DXQUATERNION *protation, CONST D3DXVECTOR3 *ptranslation)
480 {
481 D3DXMATRIX m1, m2, m3, m4, m5, m6, m7;
482 D3DXQUATERNION prc;
483 D3DXVECTOR3 psc, pt;
484
485 if ( !pscalingcenter )
486 {
487 psc.x = 0.0f;
488 psc.y = 0.0f;
489 psc.z = 0.0f;
490 }
491 else
492 {
493 psc.x = pscalingcenter->x;
494 psc.y = pscalingcenter->y;
495 psc.z = pscalingcenter->z;
496 }
497 if ( !protationcenter )
498 {
499 prc.x = 0.0f;
500 prc.y = 0.0f;
501 prc.z = 0.0f;
502 }
503 else
504 {
505 prc.x = protationcenter->x;
506 prc.y = protationcenter->y;
507 prc.z = protationcenter->z;
508 }
509 if ( !ptranslation )
510 {
511 pt.x = 0.0f;
512 pt.y = 0.0f;
513 pt.z = 0.0f;
514 }
515 else
516 {
517 pt.x = ptranslation->x;
518 pt.y = ptranslation->y;
519 pt.z = ptranslation->z;
520 }
521 D3DXMatrixTranslation(&m1, -psc.x, -psc.y, -psc.z);
522 if ( !pscalingrotation )
523 {
524 D3DXMatrixIdentity(&m2);
525 D3DXMatrixIdentity(&m4);
526 }
527 else
528 {
529 D3DXMatrixRotationQuaternion(&m4, pscalingrotation);
530 D3DXMatrixInverse(&m2, NULL, &m4);
531 }
532 if ( !pscaling )
533 {
534 D3DXMatrixIdentity(&m3);
535 }
536 else
537 {
538 D3DXMatrixScaling(&m3, pscaling->x, pscaling->y, pscaling->z);
539 }
540 if ( !protation )
541 {
542 D3DXMatrixIdentity(&m6);
543 }
544 else
545 {
546 D3DXMatrixRotationQuaternion(&m6, protation);
547 }
548 D3DXMatrixTranslation(&m5, psc.x - prc.x, psc.y - prc.y, psc.z - prc.z);
549 D3DXMatrixTranslation(&m7, prc.x + pt.x, prc.y + pt.y, prc.z + pt.z);
550 D3DXMatrixMultiply(&m1, &m1, &m2);
551 D3DXMatrixMultiply(&m1, &m1, &m3);
552 D3DXMatrixMultiply(&m1, &m1, &m4);
553 D3DXMatrixMultiply(&m1, &m1, &m5);
554 D3DXMatrixMultiply(&m1, &m1, &m6);
555 D3DXMatrixMultiply(pout, &m1, &m7);
556 return pout;
557 }
558
559 D3DXMATRIX* WINAPI D3DXMatrixTranslation(D3DXMATRIX *pout, FLOAT x, FLOAT y, FLOAT z)
560 {
561 D3DXMatrixIdentity(pout);
562 pout->u.m[3][0] = x;
563 pout->u.m[3][1] = y;
564 pout->u.m[3][2] = z;
565 return pout;
566 }
567
568 D3DXMATRIX* WINAPI D3DXMatrixTranspose(D3DXMATRIX *pout, CONST D3DXMATRIX *pm)
569 {
570 CONST D3DXMATRIX m = *pm;
571 int i,j;
572
573 for (i=0; i<4; i++)
574 {
575 for (j=0; j<4; j++)
576 {
577 pout->u.m[i][j] = m.u.m[j][i];
578 }
579 }
580 return pout;
581 }
582
583 /*_________________D3DXMatrixStack____________________*/
584
585 static const unsigned int INITIAL_STACK_SIZE = 32;
586
587 HRESULT WINAPI D3DXCreateMatrixStack(DWORD flags, LPD3DXMATRIXSTACK* ppstack)
588 {
589 ID3DXMatrixStackImpl* object;
590
591 TRACE("flags %#x, ppstack %p\n", flags, ppstack);
592
593 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ID3DXMatrixStackImpl));
594 if ( object == NULL )
595 {
596 *ppstack = NULL;
597 return E_OUTOFMEMORY;
598 }
599 object->lpVtbl = &ID3DXMatrixStack_Vtbl;
600 object->ref = 1;
601
602 object->stack = HeapAlloc(GetProcessHeap(), 0, INITIAL_STACK_SIZE * sizeof(D3DXMATRIX));
603 if (!object->stack)
604 {
605 HeapFree(GetProcessHeap(), 0, object);
606 *ppstack = NULL;
607 return E_OUTOFMEMORY;
608 }
609
610 object->current = 0;
611 object->stack_size = INITIAL_STACK_SIZE;
612 D3DXMatrixIdentity(&object->stack[0]);
613
614 TRACE("Created matrix stack %p\n", object);
615
616 *ppstack = (LPD3DXMATRIXSTACK)object;
617 return D3D_OK;
618 }
619
620 static HRESULT WINAPI ID3DXMatrixStackImpl_QueryInterface(ID3DXMatrixStack *iface, REFIID riid, void **ppobj)
621 {
622 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
623 if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ID3DXMatrixStack))
624 {
625 ID3DXMatrixStack_AddRef(iface);
626 *ppobj = This;
627 return S_OK;
628 }
629 *ppobj = NULL;
630 ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
631 return E_NOINTERFACE;
632 }
633
634 static ULONG WINAPI ID3DXMatrixStackImpl_AddRef(ID3DXMatrixStack *iface)
635 {
636 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
637 ULONG ref = InterlockedIncrement(&This->ref);
638 TRACE("(%p) : AddRef from %d\n", This, ref - 1);
639 return ref;
640 }
641
642 static ULONG WINAPI ID3DXMatrixStackImpl_Release(ID3DXMatrixStack* iface)
643 {
644 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
645 ULONG ref = InterlockedDecrement(&This->ref);
646 if (!ref)
647 {
648 HeapFree(GetProcessHeap(), 0, This->stack);
649 HeapFree(GetProcessHeap(), 0, This);
650 }
651 TRACE("(%p) : ReleaseRef to %d\n", This, ref);
652 return ref;
653 }
654
655 static D3DXMATRIX* WINAPI ID3DXMatrixStackImpl_GetTop(ID3DXMatrixStack *iface)
656 {
657 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
658
659 TRACE("iface %p\n", iface);
660
661 return &This->stack[This->current];
662 }
663
664 static HRESULT WINAPI ID3DXMatrixStackImpl_LoadIdentity(ID3DXMatrixStack *iface)
665 {
666 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
667
668 TRACE("iface %p\n", iface);
669
670 D3DXMatrixIdentity(&This->stack[This->current]);
671
672 return D3D_OK;
673 }
674
675 static HRESULT WINAPI ID3DXMatrixStackImpl_LoadMatrix(ID3DXMatrixStack *iface, CONST D3DXMATRIX *pm)
676 {
677 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
678
679 TRACE("iface %p\n", iface);
680
681 if (!pm) return D3DERR_INVALIDCALL;
682 This->stack[This->current] = *pm;
683
684 return D3D_OK;
685 }
686
687 static HRESULT WINAPI ID3DXMatrixStackImpl_MultMatrix(ID3DXMatrixStack *iface, CONST D3DXMATRIX *pm)
688 {
689 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
690
691 TRACE("iface %p\n", iface);
692
693 if (!pm) return D3DERR_INVALIDCALL;
694 D3DXMatrixMultiply(&This->stack[This->current], &This->stack[This->current], pm);
695
696 return D3D_OK;
697 }
698
699 static HRESULT WINAPI ID3DXMatrixStackImpl_MultMatrixLocal(ID3DXMatrixStack *iface, CONST D3DXMATRIX *pm)
700 {
701 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
702
703 TRACE("iface %p\n", iface);
704
705 if (!pm) return D3DERR_INVALIDCALL;
706 D3DXMatrixMultiply(&This->stack[This->current], pm, &This->stack[This->current]);
707
708 return D3D_OK;
709 }
710
711 static HRESULT WINAPI ID3DXMatrixStackImpl_Pop(ID3DXMatrixStack *iface)
712 {
713 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
714
715 TRACE("iface %p\n", iface);
716
717 /* Popping the last element on the stack returns D3D_OK, but does nothing. */
718 if (!This->current) return D3D_OK;
719
720 if (This->current <= This->stack_size / 4 && This->stack_size >= INITIAL_STACK_SIZE * 2)
721 {
722 unsigned int new_size;
723 D3DXMATRIX *new_stack;
724
725 new_size = This->stack_size / 2;
726 new_stack = HeapReAlloc(GetProcessHeap(), 0, This->stack, new_size * sizeof(D3DXMATRIX));
727 if (new_stack)
728 {
729 This->stack_size = new_size;
730 This->stack = new_stack;
731 }
732 }
733
734 --This->current;
735
736 return D3D_OK;
737 }
738
739 static HRESULT WINAPI ID3DXMatrixStackImpl_Push(ID3DXMatrixStack *iface)
740 {
741 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
742
743 TRACE("iface %p\n", iface);
744
745 if (This->current == This->stack_size - 1)
746 {
747 unsigned int new_size;
748 D3DXMATRIX *new_stack;
749
750 if (This->stack_size > UINT_MAX / 2) return E_OUTOFMEMORY;
751
752 new_size = This->stack_size * 2;
753 new_stack = HeapReAlloc(GetProcessHeap(), 0, This->stack, new_size * sizeof(D3DXMATRIX));
754 if (!new_stack) return E_OUTOFMEMORY;
755
756 This->stack_size = new_size;
757 This->stack = new_stack;
758 }
759
760 ++This->current;
761 This->stack[This->current] = This->stack[This->current - 1];
762
763 return D3D_OK;
764 }
765
766 static HRESULT WINAPI ID3DXMatrixStackImpl_RotateAxis(ID3DXMatrixStack *iface, CONST D3DXVECTOR3 *pv, FLOAT angle)
767 {
768 D3DXMATRIX temp;
769 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
770
771 TRACE("iface %p\n", iface);
772
773 if (!pv) return D3DERR_INVALIDCALL;
774 D3DXMatrixRotationAxis(&temp, pv, angle);
775 D3DXMatrixMultiply(&This->stack[This->current], &This->stack[This->current], &temp);
776
777 return D3D_OK;
778 }
779
780 static HRESULT WINAPI ID3DXMatrixStackImpl_RotateAxisLocal(ID3DXMatrixStack *iface, CONST D3DXVECTOR3 *pv, FLOAT angle)
781 {
782 D3DXMATRIX temp;
783 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
784
785 TRACE("iface %p\n", iface);
786
787 if (!pv) return D3DERR_INVALIDCALL;
788 D3DXMatrixRotationAxis(&temp, pv, angle);
789 D3DXMatrixMultiply(&This->stack[This->current], &temp, &This->stack[This->current]);
790
791 return D3D_OK;
792 }
793
794 static HRESULT WINAPI ID3DXMatrixStackImpl_RotateYawPitchRoll(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
795 {
796 D3DXMATRIX temp;
797 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
798
799 TRACE("iface %p\n", iface);
800
801 D3DXMatrixRotationYawPitchRoll(&temp, x, y, z);
802 D3DXMatrixMultiply(&This->stack[This->current], &This->stack[This->current], &temp);
803
804 return D3D_OK;
805 }
806
807 static HRESULT WINAPI ID3DXMatrixStackImpl_RotateYawPitchRollLocal(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
808 {
809 D3DXMATRIX temp;
810 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
811
812 TRACE("iface %p\n", iface);
813
814 D3DXMatrixRotationYawPitchRoll(&temp, x, y, z);
815 D3DXMatrixMultiply(&This->stack[This->current], &temp, &This->stack[This->current]);
816
817 return D3D_OK;
818 }
819
820 static HRESULT WINAPI ID3DXMatrixStackImpl_Scale(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
821 {
822 D3DXMATRIX temp;
823 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
824
825 TRACE("iface %p\n", iface);
826
827 D3DXMatrixScaling(&temp, x, y, z);
828 D3DXMatrixMultiply(&This->stack[This->current], &This->stack[This->current], &temp);
829
830 return D3D_OK;
831 }
832
833 static HRESULT WINAPI ID3DXMatrixStackImpl_ScaleLocal(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
834 {
835 D3DXMATRIX temp;
836 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
837
838 TRACE("iface %p\n", iface);
839
840 D3DXMatrixScaling(&temp, x, y, z);
841 D3DXMatrixMultiply(&This->stack[This->current], &temp, &This->stack[This->current]);
842
843 return D3D_OK;
844 }
845
846 static HRESULT WINAPI ID3DXMatrixStackImpl_Translate(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
847 {
848 D3DXMATRIX temp;
849 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
850
851 TRACE("iface %p\n", iface);
852
853 D3DXMatrixTranslation(&temp, x, y, z);
854 D3DXMatrixMultiply(&This->stack[This->current], &This->stack[This->current], &temp);
855
856 return D3D_OK;
857 }
858
859 static HRESULT WINAPI ID3DXMatrixStackImpl_TranslateLocal(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
860 {
861 D3DXMATRIX temp;
862 ID3DXMatrixStackImpl *This = (ID3DXMatrixStackImpl *)iface;
863
864 TRACE("iface %p\n", iface);
865
866 D3DXMatrixTranslation(&temp, x, y, z);
867 D3DXMatrixMultiply(&This->stack[This->current], &temp,&This->stack[This->current]);
868
869 return D3D_OK;
870 }
871
872 static const ID3DXMatrixStackVtbl ID3DXMatrixStack_Vtbl =
873 {
874 ID3DXMatrixStackImpl_QueryInterface,
875 ID3DXMatrixStackImpl_AddRef,
876 ID3DXMatrixStackImpl_Release,
877 ID3DXMatrixStackImpl_Pop,
878 ID3DXMatrixStackImpl_Push,
879 ID3DXMatrixStackImpl_LoadIdentity,
880 ID3DXMatrixStackImpl_LoadMatrix,
881 ID3DXMatrixStackImpl_MultMatrix,
882 ID3DXMatrixStackImpl_MultMatrixLocal,
883 ID3DXMatrixStackImpl_RotateAxis,
884 ID3DXMatrixStackImpl_RotateAxisLocal,
885 ID3DXMatrixStackImpl_RotateYawPitchRoll,
886 ID3DXMatrixStackImpl_RotateYawPitchRollLocal,
887 ID3DXMatrixStackImpl_Scale,
888 ID3DXMatrixStackImpl_ScaleLocal,
889 ID3DXMatrixStackImpl_Translate,
890 ID3DXMatrixStackImpl_TranslateLocal,
891 ID3DXMatrixStackImpl_GetTop
892 };
893
894 /*_________________D3DXPLANE________________*/
895
896 D3DXPLANE* WINAPI D3DXPlaneFromPointNormal(D3DXPLANE *pout, CONST D3DXVECTOR3 *pvpoint, CONST D3DXVECTOR3 *pvnormal)
897 {
898 pout->a = pvnormal->x;
899 pout->b = pvnormal->y;
900 pout->c = pvnormal->z;
901 pout->d = -D3DXVec3Dot(pvpoint, pvnormal);
902 return pout;
903 }
904
905 D3DXPLANE* WINAPI D3DXPlaneFromPoints(D3DXPLANE *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3)
906 {
907 D3DXVECTOR3 edge1, edge2, normal, Nnormal;
908
909 edge1.x = 0.0f; edge1.y = 0.0f; edge1.z = 0.0f;
910 edge2.x = 0.0f; edge2.y = 0.0f; edge2.z = 0.0f;
911 D3DXVec3Subtract(&edge1, pv2, pv1);
912 D3DXVec3Subtract(&edge2, pv3, pv1);
913 D3DXVec3Cross(&normal, &edge1, &edge2);
914 D3DXVec3Normalize(&Nnormal, &normal);
915 D3DXPlaneFromPointNormal(pout, pv1, &Nnormal);
916 return pout;
917 }
918
919 D3DXVECTOR3* WINAPI D3DXPlaneIntersectLine(D3DXVECTOR3 *pout, CONST D3DXPLANE *pp, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
920 {
921 D3DXVECTOR3 direction, normal;
922 FLOAT dot, temp;
923
924 normal.x = pp->a;
925 normal.y = pp->b;
926 normal.z = pp->c;
927 direction.x = pv2->x - pv1->x;
928 direction.y = pv2->y - pv1->y;
929 direction.z = pv2->z - pv1->z;
930 dot = D3DXVec3Dot(&normal, &direction);
931 if ( !dot ) return NULL;
932 temp = ( pp->d + D3DXVec3Dot(&normal, pv1) ) / dot;
933 pout->x = pv1->x - temp * direction.x;
934 pout->y = pv1->y - temp * direction.y;
935 pout->z = pv1->z - temp * direction.z;
936 return pout;
937 }
938
939 D3DXPLANE* WINAPI D3DXPlaneNormalize(D3DXPLANE *pout, CONST D3DXPLANE *pp)
940 {
941 FLOAT norm;
942
943 norm = sqrt(pp->a * pp->a + pp->b * pp->b + pp->c * pp->c);
944 if ( norm )
945 {
946 pout->a = pp->a / norm;
947 pout->b = pp->b / norm;
948 pout->c = pp->c / norm;
949 pout->d = pp->d / norm;
950 }
951 else
952 {
953 pout->a = 0.0f;
954 pout->b = 0.0f;
955 pout->c = 0.0f;
956 pout->d = 0.0f;
957 }
958 return pout;
959 }
960
961 D3DXPLANE* WINAPI D3DXPlaneTransform(D3DXPLANE *pout, CONST D3DXPLANE *pplane, CONST D3DXMATRIX *pm)
962 {
963 CONST D3DXPLANE plane = *pplane;
964 pout->a = pm->u.m[0][0] * plane.a + pm->u.m[1][0] * plane.b + pm->u.m[2][0] * plane.c + pm->u.m[3][0] * plane.d;
965 pout->b = pm->u.m[0][1] * plane.a + pm->u.m[1][1] * plane.b + pm->u.m[2][1] * plane.c + pm->u.m[3][1] * plane.d;
966 pout->c = pm->u.m[0][2] * plane.a + pm->u.m[1][2] * plane.b + pm->u.m[2][2] * plane.c + pm->u.m[3][2] * plane.d;
967 pout->d = pm->u.m[0][3] * plane.a + pm->u.m[1][3] * plane.b + pm->u.m[2][3] * plane.c + pm->u.m[3][3] * plane.d;
968 return pout;
969 }
970
971 /*_________________D3DXQUATERNION________________*/
972
973 D3DXQUATERNION* WINAPI D3DXQuaternionBaryCentric(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, CONST D3DXQUATERNION *pq3, FLOAT f, FLOAT g)
974 {
975 D3DXQUATERNION temp1, temp2;
976 D3DXQuaternionSlerp(pout, D3DXQuaternionSlerp(&temp1, pq1, pq2, f + g), D3DXQuaternionSlerp(&temp2, pq1, pq3, f+g), g / (f + g));
977 return pout;
978 }
979
980 D3DXQUATERNION* WINAPI D3DXQuaternionExp(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
981 {
982 FLOAT norm;
983
984 norm = sqrt(pq->x * pq->x + pq->y * pq->y + pq->z * pq->z);
985 if (norm )
986 {
987 pout->x = sin(norm) * pq->x / norm;
988 pout->y = sin(norm) * pq->y / norm;
989 pout->z = sin(norm) * pq->z / norm;
990 pout->w = cos(norm);
991 }
992 else
993 {
994 pout->x = 0.0f;
995 pout->y = 0.0f;
996 pout->z = 0.0f;
997 pout->w = 1.0f;
998 }
999 return pout;
1000 }
1001
1002 D3DXQUATERNION* WINAPI D3DXQuaternionInverse(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
1003 {
1004 FLOAT norm;
1005
1006 norm = D3DXQuaternionLengthSq(pq);
1007 if ( !norm )
1008 {
1009 pout->x = 0.0f;
1010 pout->y = 0.0f;
1011 pout->z = 0.0f;
1012 pout->w = 0.0f;
1013 }
1014 else
1015 {
1016 pout->x = -pq->x / norm;
1017 pout->y = -pq->y / norm;
1018 pout->z = -pq->z / norm;
1019 pout->w = pq->w / norm;
1020 }
1021 return pout;
1022 }
1023
1024 D3DXQUATERNION* WINAPI D3DXQuaternionLn(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
1025 {
1026 FLOAT norm, normvec, theta;
1027
1028 norm = D3DXQuaternionLengthSq(pq);
1029 if ( norm > 1.0001f )
1030 {
1031 pout->x = pq->x;
1032 pout->y = pq->y;
1033 pout->z = pq->z;
1034 pout->w = 0.0f;
1035 }
1036 else if( norm > 0.99999f)
1037 {
1038 normvec = sqrt( pq->x * pq->x + pq->y * pq->y + pq->z * pq->z );
1039 theta = atan2(normvec, pq->w) / normvec;
1040 pout->x = theta * pq->x;
1041 pout->y = theta * pq->y;
1042 pout->z = theta * pq->z;
1043 pout->w = 0.0f;
1044 }
1045 else
1046 {
1047 FIXME("The quaternion (%f, %f, %f, %f) has a norm <1. This should not happen. Windows returns a result anyway. This case is not implemented yet.\n", pq->x, pq->y, pq->z, pq->w);
1048 }
1049 return pout;
1050 }
1051
1052 D3DXQUATERNION* WINAPI D3DXQuaternionMultiply(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2)
1053 {
1054 D3DXQUATERNION out;
1055 out.x = pq2->w * pq1->x + pq2->x * pq1->w + pq2->y * pq1->z - pq2->z * pq1->y;
1056 out.y = pq2->w * pq1->y - pq2->x * pq1->z + pq2->y * pq1->w + pq2->z * pq1->x;
1057 out.z = pq2->w * pq1->z + pq2->x * pq1->y - pq2->y * pq1->x + pq2->z * pq1->w;
1058 out.w = pq2->w * pq1->w - pq2->x * pq1->x - pq2->y * pq1->y - pq2->z * pq1->z;
1059 *pout = out;
1060 return pout;
1061 }
1062
1063 D3DXQUATERNION* WINAPI D3DXQuaternionNormalize(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
1064 {
1065 FLOAT norm;
1066
1067 norm = D3DXQuaternionLength(pq);
1068 if ( !norm )
1069 {
1070 pout->x = 0.0f;
1071 pout->y = 0.0f;
1072 pout->z = 0.0f;
1073 pout->w = 0.0f;
1074 }
1075 else
1076 {
1077 pout->x = pq->x / norm;
1078 pout->y = pq->y / norm;
1079 pout->z = pq->z / norm;
1080 pout->w = pq->w / norm;
1081 }
1082 return pout;
1083 }
1084
1085 D3DXQUATERNION* WINAPI D3DXQuaternionRotationAxis(D3DXQUATERNION *pout, CONST D3DXVECTOR3 *pv, FLOAT angle)
1086 {
1087 D3DXVECTOR3 temp;
1088
1089 D3DXVec3Normalize(&temp, pv);
1090 pout->x = sin( angle / 2.0f ) * temp.x;
1091 pout->y = sin( angle / 2.0f ) * temp.y;
1092 pout->z = sin( angle / 2.0f ) * temp.z;
1093 pout->w = cos( angle / 2.0f );
1094 return pout;
1095 }
1096
1097 D3DXQUATERNION* WINAPI D3DXQuaternionRotationMatrix(D3DXQUATERNION *pout, CONST D3DXMATRIX *pm)
1098 {
1099 int i, maxi;
1100 FLOAT maxdiag, S, trace;
1101
1102 trace = pm->u.m[0][0] + pm->u.m[1][1] + pm->u.m[2][2] + 1.0f;
1103 if ( trace > 1.0f)
1104 {
1105 pout->x = ( pm->u.m[1][2] - pm->u.m[2][1] ) / ( 2.0f * sqrt(trace) );
1106 pout->y = ( pm->u.m[2][0] - pm->u.m[0][2] ) / ( 2.0f * sqrt(trace) );
1107 pout->z = ( pm->u.m[0][1] - pm->u.m[1][0] ) / ( 2.0f * sqrt(trace) );
1108 pout->w = sqrt(trace) / 2.0f;
1109 return pout;
1110 }
1111 maxi = 0;
1112 maxdiag = pm->u.m[0][0];
1113 for (i=1; i<3; i++)
1114 {
1115 if ( pm->u.m[i][i] > maxdiag )
1116 {
1117 maxi = i;
1118 maxdiag = pm->u.m[i][i];
1119 }
1120 }
1121 switch( maxi )
1122 {
1123 case 0:
1124 S = 2.0f * sqrt(1.0f + pm->u.m[0][0] - pm->u.m[1][1] - pm->u.m[2][2]);
1125 pout->x = 0.25f * S;
1126 pout->y = ( pm->u.m[0][1] + pm->u.m[1][0] ) / S;
1127 pout->z = ( pm->u.m[0][2] + pm->u.m[2][0] ) / S;
1128 pout->w = ( pm->u.m[1][2] - pm->u.m[2][1] ) / S;
1129 break;
1130 case 1:
1131 S = 2.0f * sqrt(1.0f + pm->u.m[1][1] - pm->u.m[0][0] - pm->u.m[2][2]);
1132 pout->x = ( pm->u.m[0][1] + pm->u.m[1][0] ) / S;
1133 pout->y = 0.25f * S;
1134 pout->z = ( pm->u.m[1][2] + pm->u.m[2][1] ) / S;
1135 pout->w = ( pm->u.m[2][0] - pm->u.m[0][2] ) / S;
1136 break;
1137 case 2:
1138 S = 2.0f * sqrt(1.0f + pm->u.m[2][2] - pm->u.m[0][0] - pm->u.m[1][1]);
1139 pout->x = ( pm->u.m[0][2] + pm->u.m[2][0] ) / S;
1140 pout->y = ( pm->u.m[1][2] + pm->u.m[2][1] ) / S;
1141 pout->z = 0.25f * S;
1142 pout->w = ( pm->u.m[0][1] - pm->u.m[1][0] ) / S;
1143 break;
1144 }
1145 return pout;
1146 }
1147
1148 D3DXQUATERNION* WINAPI D3DXQuaternionRotationYawPitchRoll(D3DXQUATERNION *pout, FLOAT yaw, FLOAT pitch, FLOAT roll)
1149 {
1150 pout->x = sin( yaw / 2.0f) * cos(pitch / 2.0f) * sin(roll / 2.0f) + cos(yaw / 2.0f) * sin(pitch / 2.0f) * cos(roll / 2.0f);
1151 pout->y = sin( yaw / 2.0f) * cos(pitch / 2.0f) * cos(roll / 2.0f) - cos(yaw / 2.0f) * sin(pitch / 2.0f) * sin(roll / 2.0f);
1152 pout->z = cos(yaw / 2.0f) * cos(pitch / 2.0f) * sin(roll / 2.0f) - sin( yaw / 2.0f) * sin(pitch / 2.0f) * cos(roll / 2.0f);
1153 pout->w = cos( yaw / 2.0f) * cos(pitch / 2.0f) * cos(roll / 2.0f) + sin(yaw / 2.0f) * sin(pitch / 2.0f) * sin(roll / 2.0f);
1154 return pout;
1155 }
1156
1157 D3DXQUATERNION* WINAPI D3DXQuaternionSlerp(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, FLOAT t)
1158 {
1159 FLOAT dot, epsilon;
1160
1161 epsilon = 1.0f;
1162 dot = D3DXQuaternionDot(pq1, pq2);
1163 if ( dot < 0.0f) epsilon = -1.0f;
1164 pout->x = (1.0f - t) * pq1->x + epsilon * t * pq2->x;
1165 pout->y = (1.0f - t) * pq1->y + epsilon * t * pq2->y;
1166 pout->z = (1.0f - t) * pq1->z + epsilon * t * pq2->z;
1167 pout->w = (1.0f - t) * pq1->w + epsilon * t * pq2->w;
1168 return pout;
1169 }
1170
1171 D3DXQUATERNION* WINAPI D3DXQuaternionSquad(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, CONST D3DXQUATERNION *pq3, CONST D3DXQUATERNION *pq4, FLOAT t)
1172 {
1173 D3DXQUATERNION temp1, temp2;
1174
1175 D3DXQuaternionSlerp(pout, D3DXQuaternionSlerp(&temp1, pq1, pq4, t), D3DXQuaternionSlerp(&temp2, pq2, pq3, t), 2.0f * t * (1.0f - t));
1176 return pout;
1177 }
1178
1179 void WINAPI D3DXQuaternionToAxisAngle(CONST D3DXQUATERNION *pq, D3DXVECTOR3 *paxis, FLOAT *pangle)
1180 {
1181 FLOAT norm;
1182
1183 *pangle = 0.0f;
1184 norm = D3DXQuaternionLength(pq);
1185 if ( norm )
1186 {
1187 paxis->x = pq->x / norm;
1188 paxis->y = pq->y / norm;
1189 paxis->z = pq->z / norm;
1190 if ( fabs( pq->w ) <= 1.0f ) *pangle = 2.0f * acos(pq->w);
1191 }
1192 else
1193 {
1194 paxis->x = 1.0f;
1195 paxis->y = 0.0f;
1196 paxis->z = 0.0f;
1197 }
1198 }
1199
1200 /*_________________D3DXVec2_____________________*/
1201
1202 D3DXVECTOR2* WINAPI D3DXVec2BaryCentric(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pv3, FLOAT f, FLOAT g)
1203 {
1204 pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
1205 pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
1206 return pout;
1207 }
1208
1209 D3DXVECTOR2* WINAPI D3DXVec2CatmullRom(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv0, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pv3, FLOAT s)
1210 {
1211 pout->x = 0.5f * (2.0f * pv1->x + (pv2->x - pv0->x) *s + (2.0f *pv0->x - 5.0f * pv1->x + 4.0f * pv2->x - pv3->x) * s * s + (pv3->x -3.0f * pv2->x + 3.0f * pv1->x - pv0->x) * s * s * s);
1212 pout->y = 0.5f * (2.0f * pv1->y + (pv2->y - pv0->y) *s + (2.0f *pv0->y - 5.0f * pv1->y + 4.0f * pv2->y - pv3->y) * s * s + (pv3->y -3.0f * pv2->y + 3.0f * pv1->y - pv0->y) * s * s * s);
1213 return pout;
1214 }
1215
1216 D3DXVECTOR2* WINAPI D3DXVec2Hermite(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pt1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pt2, FLOAT s)
1217 {
1218 FLOAT h1, h2, h3, h4;
1219
1220 h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
1221 h2 = s * s * s - 2.0f * s * s + s;
1222 h3 = -2.0f * s * s * s + 3.0f * s * s;
1223 h4 = s * s * s - s * s;
1224
1225 pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
1226 pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
1227 return pout;
1228 }
1229
1230 D3DXVECTOR2* WINAPI D3DXVec2Normalize(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv)
1231 {
1232 FLOAT norm;
1233
1234 norm = D3DXVec2Length(pv);
1235 if ( !norm )
1236 {
1237 pout->x = 0.0f;
1238 pout->y = 0.0f;
1239 }
1240 else
1241 {
1242 pout->x = pv->x / norm;
1243 pout->y = pv->y / norm;
1244 }
1245 return pout;
1246 }
1247
1248 D3DXVECTOR4* WINAPI D3DXVec2Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
1249 {
1250 pout->x = pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y + pm->u.m[3][0];
1251 pout->y = pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y + pm->u.m[3][1];
1252 pout->z = pm->u.m[0][2] * pv->x + pm->u.m[1][2] * pv->y + pm->u.m[3][2];
1253 pout->w = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y + pm->u.m[3][3];
1254 return pout;
1255 }
1256
1257 D3DXVECTOR2* WINAPI D3DXVec2TransformCoord(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
1258 {
1259 FLOAT norm;
1260
1261 norm = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y + pm->u.m[3][3];
1262 if ( norm )
1263 {
1264 CONST D3DXVECTOR2 v = *pv;
1265 pout->x = (pm->u.m[0][0] * v.x + pm->u.m[1][0] * v.y + pm->u.m[3][0]) / norm;
1266 pout->y = (pm->u.m[0][1] * v.x + pm->u.m[1][1] * v.y + pm->u.m[3][1]) / norm;
1267 }
1268 else
1269 {
1270 pout->x = 0.0f;
1271 pout->y = 0.0f;
1272 }
1273 return pout;
1274 }
1275
1276 D3DXVECTOR2* WINAPI D3DXVec2TransformNormal(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
1277 {
1278 CONST D3DXVECTOR2 v = *pv;
1279 pout->x = pm->u.m[0][0] * v.x + pm->u.m[1][0] * v.y;
1280 pout->y = pm->u.m[0][1] * v.x + pm->u.m[1][1] * v.y;
1281 return pout;
1282 }
1283
1284 /*_________________D3DXVec3_____________________*/
1285
1286 D3DXVECTOR3* WINAPI D3DXVec3BaryCentric(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3, FLOAT f, FLOAT g)
1287 {
1288 pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
1289 pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
1290 pout->z = (1.0f-f-g) * (pv1->z) + f * (pv2->z) + g * (pv3->z);
1291 return pout;
1292 }
1293
1294 D3DXVECTOR3* WINAPI D3DXVec3CatmullRom( D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv0, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3, FLOAT s)
1295 {
1296 pout->x = 0.5f * (2.0f * pv1->x + (pv2->x - pv0->x) *s + (2.0f *pv0->x - 5.0f * pv1->x + 4.0f * pv2->x - pv3->x) * s * s + (pv3->x -3.0f * pv2->x + 3.0f * pv1->x - pv0->x) * s * s * s);
1297 pout->y = 0.5f * (2.0f * pv1->y + (pv2->y - pv0->y) *s + (2.0f *pv0->y - 5.0f * pv1->y + 4.0f * pv2->y - pv3->y) * s * s + (pv3->y -3.0f * pv2->y + 3.0f * pv1->y - pv0->y) * s * s * s);
1298 pout->z = 0.5f * (2.0f * pv1->z + (pv2->z - pv0->z) *s + (2.0f *pv0->z - 5.0f * pv1->z + 4.0f * pv2->z - pv3->z) * s * s + (pv3->z -3.0f * pv2->z + 3.0f * pv1->z - pv0->z) * s * s * s);
1299 return pout;
1300 }
1301
1302 D3DXVECTOR3* WINAPI D3DXVec3Hermite(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pt1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pt2, FLOAT s)
1303 {
1304 FLOAT h1, h2, h3, h4;
1305
1306 h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
1307 h2 = s * s * s - 2.0f * s * s + s;
1308 h3 = -2.0f * s * s * s + 3.0f * s * s;
1309 h4 = s * s * s - s * s;
1310
1311 pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
1312 pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
1313 pout->z = h1 * (pv1->z) + h2 * (pt1->z) + h3 * (pv2->z) + h4 * (pt2->z);
1314 return pout;
1315 }
1316
1317 D3DXVECTOR3* WINAPI D3DXVec3Normalize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv)
1318 {
1319 FLOAT norm;
1320
1321 norm = D3DXVec3Length(pv);
1322 if ( !norm )
1323 {
1324 pout->x = 0.0f;
1325 pout->y = 0.0f;
1326 pout->z = 0.0f;
1327 }
1328 else
1329 {
1330 pout->x = pv->x / norm;
1331 pout->y = pv->y / norm;
1332 pout->z = pv->z / norm;
1333 }
1334 return pout;
1335 }
1336
1337 D3DXVECTOR3* WINAPI D3DXVec3Project(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DVIEWPORT8 *pviewport, CONST D3DXMATRIX *pprojection, CONST D3DXMATRIX *pview, CONST D3DXMATRIX *pworld)
1338 {
1339 D3DXMATRIX m1, m2;
1340 D3DXVECTOR3 vec;
1341
1342 D3DXMatrixMultiply(&m1, pworld, pview);
1343 D3DXMatrixMultiply(&m2, &m1, pprojection);
1344 D3DXVec3TransformCoord(&vec, pv, &m2);
1345 pout->x = pviewport->X + ( 1.0f + vec.x ) * pviewport->Width / 2.0f;
1346 pout->y = pviewport->Y + ( 1.0f - vec.y ) * pviewport->Height / 2.0f;
1347 pout->z = pviewport->MinZ + vec.z * ( pviewport->MaxZ - pviewport->MinZ );
1348 return pout;
1349 }
1350
1351 D3DXVECTOR4* WINAPI D3DXVec3Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
1352 {
1353 pout->x = pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y + pm->u.m[2][0] * pv->z + pm->u.m[3][0];
1354 pout->y = pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y + pm->u.m[2][1] * pv->z + pm->u.m[3][1];
1355 pout->z = pm->u.m[0][2] * pv->x + pm->u.m[1][2] * pv->y + pm->u.m[2][2] * pv->z + pm->u.m[3][2];
1356 pout->w = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y + pm->u.m[2][3] * pv->z + pm->u.m[3][3];
1357 return pout;
1358 }
1359
1360 D3DXVECTOR3* WINAPI D3DXVec3TransformCoord(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
1361 {
1362 FLOAT norm;
1363
1364 norm = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y + pm->u.m[2][3] *pv->z + pm->u.m[3][3];
1365
1366 if ( norm )
1367 {
1368 CONST D3DXVECTOR3 v = *pv;
1369 pout->x = (pm->u.m[0][0] * v.x + pm->u.m[1][0] * v.y + pm->u.m[2][0] * v.z + pm->u.m[3][0]) / norm;
1370 pout->y = (pm->u.m[0][1] * v.x + pm->u.m[1][1] * v.y + pm->u.m[2][1] * v.z + pm->u.m[3][1]) / norm;
1371 pout->z = (pm->u.m[0][2] * v.x + pm->u.m[1][2] * v.y + pm->u.m[2][2] * v.z + pm->u.m[3][2]) / norm;
1372 }
1373 else
1374 {
1375 pout->x = 0.0f;
1376 pout->y = 0.0f;
1377 pout->z = 0.0f;
1378 }
1379 return pout;
1380 }
1381
1382 D3DXVECTOR3* WINAPI D3DXVec3TransformNormal(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
1383 {
1384 CONST D3DXVECTOR3 v = *pv;
1385 pout->x = pm->u.m[0][0] * v.x + pm->u.m[1][0] * v.y + pm->u.m[2][0] * v.z;
1386 pout->y = pm->u.m[0][1] * v.x + pm->u.m[1][1] * v.y + pm->u.m[2][1] * v.z;
1387 pout->z = pm->u.m[0][2] * v.x + pm->u.m[1][2] * v.y + pm->u.m[2][2] * v.z;
1388 return pout;
1389
1390 }
1391
1392 D3DXVECTOR3* WINAPI D3DXVec3Unproject(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DVIEWPORT8 *pviewport, CONST D3DXMATRIX *pprojection, CONST D3DXMATRIX *pview, CONST D3DXMATRIX *pworld)
1393 {
1394 D3DXMATRIX m1, m2, m3;
1395 D3DXVECTOR3 vec;
1396
1397 D3DXMatrixMultiply(&m1, pworld, pview);
1398 D3DXMatrixMultiply(&m2, &m1, pprojection);
1399 D3DXMatrixInverse(&m3, NULL, &m2);
1400 vec.x = 2.0f * ( pv->x - pviewport->X ) / pviewport->Width - 1.0f;
1401 vec.y = 1.0f - 2.0f * ( pv->y - pviewport->Y ) / pviewport->Height;
1402 vec.z = ( pv->z - pviewport->MinZ) / ( pviewport->MaxZ - pviewport->MinZ );
1403 D3DXVec3TransformCoord(pout, &vec, &m3);
1404 return pout;
1405 }
1406
1407 /*_________________D3DXVec4_____________________*/
1408
1409 D3DXVECTOR4* WINAPI D3DXVec4BaryCentric(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3, FLOAT f, FLOAT g)
1410 {
1411 pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
1412 pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
1413 pout->z = (1.0f-f-g) * (pv1->z) + f * (pv2->z) + g * (pv3->z);
1414 pout->w = (1.0f-f-g) * (pv1->w) + f * (pv2->w) + g * (pv3->w);
1415 return pout;
1416 }
1417
1418 D3DXVECTOR4* WINAPI D3DXVec4CatmullRom(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv0, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3, FLOAT s)
1419 {
1420 pout->x = 0.5f * (2.0f * pv1->x + (pv2->x - pv0->x) *s + (2.0f *pv0->x - 5.0f * pv1->x + 4.0f * pv2->x - pv3->x) * s * s + (pv3->x -3.0f * pv2->x + 3.0f * pv1->x - pv0->x) * s * s * s);
1421 pout->y = 0.5f * (2.0f * pv1->y + (pv2->y - pv0->y) *s + (2.0f *pv0->y - 5.0f * pv1->y + 4.0f * pv2->y - pv3->y) * s * s + (pv3->y -3.0f * pv2->y + 3.0f * pv1->y - pv0->y) * s * s * s);
1422 pout->z = 0.5f * (2.0f * pv1->z + (pv2->z - pv0->z) *s + (2.0f *pv0->z - 5.0f * pv1->z + 4.0f * pv2->z - pv3->z) * s * s + (pv3->z -3.0f * pv2->z + 3.0f * pv1->z - pv0->z) * s * s * s);
1423 pout->w = 0.5f * (2.0f * pv1->w + (pv2->w - pv0->w) *s + (2.0f *pv0->w - 5.0f * pv1->w + 4.0f * pv2->w - pv3->w) * s * s + (pv3->w -3.0f * pv2->w + 3.0f * pv1->w - pv0->w) * s * s * s);
1424 return pout;
1425 }
1426
1427 D3DXVECTOR4* WINAPI D3DXVec4Cross(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3)
1428 {
1429 D3DXVECTOR4 out;
1430 out.x = pv1->y * (pv2->z * pv3->w - pv3->z * pv2->w) - pv1->z * (pv2->y * pv3->w - pv3->y * pv2->w) + pv1->w * (pv2->y * pv3->z - pv2->z *pv3->y);
1431 out.y = -(pv1->x * (pv2->z * pv3->w - pv3->z * pv2->w) - pv1->z * (pv2->x * pv3->w - pv3->x * pv2->w) + pv1->w * (pv2->x * pv3->z - pv3->x * pv2->z));
1432 out.z = pv1->x * (pv2->y * pv3->w - pv3->y * pv2->w) - pv1->y * (pv2->x *pv3->w - pv3->x * pv2->w) + pv1->w * (pv2->x * pv3->y - pv3->x * pv2->y);
1433 out.w = -(pv1->x * (pv2->y * pv3->z - pv3->y * pv2->z) - pv1->y * (pv2->x * pv3->z - pv3->x *pv2->z) + pv1->z * (pv2->x * pv3->y - pv3->x * pv2->y));
1434 *pout = out;
1435 return pout;
1436 }
1437
1438 D3DXVECTOR4* WINAPI D3DXVec4Hermite(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pt1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pt2, FLOAT s)
1439 {
1440 FLOAT h1, h2, h3, h4;
1441
1442 h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
1443 h2 = s * s * s - 2.0f * s * s + s;
1444 h3 = -2.0f * s * s * s + 3.0f * s * s;
1445 h4 = s * s * s - s * s;
1446
1447 pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
1448 pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
1449 pout->z = h1 * (pv1->z) + h2 * (pt1->z) + h3 * (pv2->z) + h4 * (pt2->z);
1450 pout->w = h1 * (pv1->w) + h2 * (pt1->w) + h3 * (pv2->w) + h4 * (pt2->w);
1451 return pout;
1452 }
1453
1454 D3DXVECTOR4* WINAPI D3DXVec4Normalize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv)
1455 {
1456 FLOAT norm;
1457
1458 norm = D3DXVec4Length(pv);
1459 if ( !norm )
1460 {
1461 pout->x = 0.0f;
1462 pout->y = 0.0f;
1463 pout->z = 0.0f;
1464 pout->w = 0.0f;
1465 }
1466 else
1467 {
1468 pout->x = pv->x / norm;
1469 pout->y = pv->y / norm;
1470 pout->z = pv->z / norm;
1471 pout->w = pv->w / norm;
1472 }
1473 return pout;
1474 }
1475
1476 D3DXVECTOR4* WINAPI D3DXVec4Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv, CONST D3DXMATRIX *pm)
1477 {
1478 D3DXVECTOR4 out;
1479 out.x = pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y + pm->u.m[2][0] * pv->z + pm->u.m[3][0] * pv->w;
1480 out.y = pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y + pm->u.m[2][1] * pv->z + pm->u.m[3][1] * pv->w;
1481 out.z = pm->u.m[0][2] * pv->x + pm->u.m[1][2] * pv->y + pm->u.m[2][2] * pv->z + pm->u.m[3][2] * pv->w;
1482 out.w = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y + pm->u.m[2][3] * pv->z + pm->u.m[3][3] * pv->w;
1483 *pout = out;
1484 return pout;
1485 }