?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3dx9: Add support for D3DFMT_A16B16G16R16F.
[wine.git] / dlls / d3dx9_36 / math.c
blobf26d1bee4a2663f6af147687f95b9b0719a437b6
1 /*
2 * Mathematical operations specific to D3DX9.
3 *
4 * Copyright (C) 2008 David Adam
5 * Copyright (C) 2008 Luis Busquets
6 * Copyright (C) 2008 Jérôme Gardou
7 * Copyright (C) 2008 Philip Nilsson
8 * Copyright (C) 2008 Henri Verbeet
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25 #define NONAMELESSUNION
26
27 #include "config.h"
28 #include "wine/port.h"
29
30 #include "windef.h"
31 #include "wingdi.h"
32 #include "d3dx9_36_private.h"
33
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
37
38 static const ID3DXMatrixStackVtbl ID3DXMatrixStack_Vtbl;
39
40 struct ID3DXMatrixStackImpl
41 {
42 ID3DXMatrixStack ID3DXMatrixStack_iface;
43 LONG ref;
44
45 unsigned int current;
46 unsigned int stack_size;
47 D3DXMATRIX *stack;
48 };
49
50
51 /*_________________D3DXColor____________________*/
52
53 D3DXCOLOR* WINAPI D3DXColorAdjustContrast(D3DXCOLOR *pout, CONST D3DXCOLOR *pc, FLOAT s)
54 {
55 TRACE("(%p, %p, %f)\n", pout, pc, s);
56
57 pout->r = 0.5f + s * (pc->r - 0.5f);
58 pout->g = 0.5f + s * (pc->g - 0.5f);
59 pout->b = 0.5f + s * (pc->b - 0.5f);
60 pout->a = pc->a;
61 return pout;
62 }
63
64 D3DXCOLOR* WINAPI D3DXColorAdjustSaturation(D3DXCOLOR *pout, CONST D3DXCOLOR *pc, FLOAT s)
65 {
66 FLOAT grey;
67
68 TRACE("(%p, %p, %f)\n", pout, pc, s);
69
70 grey = pc->r * 0.2125f + pc->g * 0.7154f + pc->b * 0.0721f;
71 pout->r = grey + s * (pc->r - grey);
72 pout->g = grey + s * (pc->g - grey);
73 pout->b = grey + s * (pc->b - grey);
74 pout->a = pc->a;
75 return pout;
76 }
77
78 /*_________________Misc__________________________*/
79
80 FLOAT WINAPI D3DXFresnelTerm(FLOAT costheta, FLOAT refractionindex)
81 {
82 FLOAT a, d, g, result;
83
84 TRACE("costheta %f, refractionindex %f\n", costheta, refractionindex);
85
86 g = sqrtf(refractionindex * refractionindex + costheta * costheta - 1.0f);
87 a = g + costheta;
88 d = g - costheta;
89 result = (costheta * a - 1.0f) * (costheta * a - 1.0f) / ((costheta * d + 1.0f) * (costheta * d + 1.0f)) + 1.0f;
90 result *= 0.5f * d * d / (a * a);
91
92 return result;
93 }
94
95 /*_________________D3DXMatrix____________________*/
96
97 D3DXMATRIX * WINAPI D3DXMatrixAffineTransformation(D3DXMATRIX *out, FLOAT scaling, const D3DXVECTOR3 *rotationcenter,
98 const D3DXQUATERNION *rotation, const D3DXVECTOR3 *translation)
99 {
100 TRACE("out %p, scaling %f, rotationcenter %p, rotation %p, translation %p\n",
101 out, scaling, rotationcenter, rotation, translation);
102
103 D3DXMatrixIdentity(out);
104
105 if (rotationcenter)
106 {
107 out->u.m[3][0] = -rotationcenter->x;
108 out->u.m[3][1] = -rotationcenter->y;
109 out->u.m[3][2] = -rotationcenter->z;
110 }
111
112 if (rotation)
113 {
114 FLOAT temp00, temp01, temp02, temp10, temp11, temp12, temp20, temp21, temp22;
115
116 temp00 = 1.0f - 2.0f * (rotation->y * rotation->y + rotation->z * rotation->z);
117 temp01 = 2.0f * (rotation->x * rotation->y + rotation->z * rotation->w);
118 temp02 = 2.0f * (rotation->x * rotation->z - rotation->y * rotation->w);
119 temp10 = 2.0f * (rotation->x * rotation->y - rotation->z * rotation->w);
120 temp11 = 1.0f - 2.0f * (rotation->x * rotation->x + rotation->z * rotation->z);
121 temp12 = 2.0f * (rotation->y * rotation->z + rotation->x * rotation->w);
122 temp20 = 2.0f * (rotation->x * rotation->z + rotation->y * rotation->w);
123 temp21 = 2.0f * (rotation->y * rotation->z - rotation->x * rotation->w);
124 temp22 = 1.0f - 2.0f * (rotation->x * rotation->x + rotation->y * rotation->y);
125
126 out->u.m[0][0] = scaling * temp00;
127 out->u.m[0][1] = scaling * temp01;
128 out->u.m[0][2] = scaling * temp02;
129 out->u.m[1][0] = scaling * temp10;
130 out->u.m[1][1] = scaling * temp11;
131 out->u.m[1][2] = scaling * temp12;
132 out->u.m[2][0] = scaling * temp20;
133 out->u.m[2][1] = scaling * temp21;
134 out->u.m[2][2] = scaling * temp22;
135
136 if (rotationcenter)
137 {
138 FLOAT x, y, z;
139
140 x = out->u.m[3][0];
141 y = out->u.m[3][1];
142 z = out->u.m[3][2];
143
144 out->u.m[3][0] = x * temp00 + y * temp10 + z * temp20;
145 out->u.m[3][1] = x * temp01 + y * temp11 + z * temp21;
146 out->u.m[3][2] = x * temp02 + y * temp12 + z * temp22;
147 }
148 }
149 else
150 {
151 out->u.m[0][0] = scaling;
152 out->u.m[1][1] = scaling;
153 out->u.m[2][2] = scaling;
154 }
155
156 if (rotationcenter)
157 {
158 out->u.m[3][0] += rotationcenter->x;
159 out->u.m[3][1] += rotationcenter->y;
160 out->u.m[3][2] += rotationcenter->z;
161 }
162
163 if (translation)
164 {
165 out->u.m[3][0] += translation->x;
166 out->u.m[3][1] += translation->y;
167 out->u.m[3][2] += translation->z;
168 }
169
170 return out;
171 }
172
173 D3DXMATRIX * WINAPI D3DXMatrixAffineTransformation2D(D3DXMATRIX *out, FLOAT scaling,
174 const D3DXVECTOR2 *rotationcenter, FLOAT rotation, const D3DXVECTOR2 *translation)
175 {
176 FLOAT tmp1, tmp2, s;
177
178 TRACE("out %p, scaling %f, rotationcenter %p, rotation %f, translation %p\n",
179 out, scaling, rotationcenter, rotation, translation);
180
181 s = sinf(rotation / 2.0f);
182 tmp1 = 1.0f - 2.0f * s * s;
183 tmp2 = 2.0 * s * cosf(rotation / 2.0f);
184
185 D3DXMatrixIdentity(out);
186 out->u.m[0][0] = scaling * tmp1;
187 out->u.m[0][1] = scaling * tmp2;
188 out->u.m[1][0] = -scaling * tmp2;
189 out->u.m[1][1] = scaling * tmp1;
190
191 if (rotationcenter)
192 {
193 FLOAT x, y;
194
195 x = rotationcenter->x;
196 y = rotationcenter->y;
197
198 out->u.m[3][0] = y * tmp2 - x * tmp1 + x;
199 out->u.m[3][1] = -x * tmp2 - y * tmp1 + y;
200 }
201
202 if (translation)
203 {
204 out->u.m[3][0] += translation->x;
205 out->u.m[3][1] += translation->y;
206 }
207
208 return out;
209 }
210
211 HRESULT WINAPI D3DXMatrixDecompose(D3DXVECTOR3 *poutscale, D3DXQUATERNION *poutrotation, D3DXVECTOR3 *pouttranslation, CONST D3DXMATRIX *pm)
212 {
213 D3DXMATRIX normalized;
214 D3DXVECTOR3 vec;
215
216 TRACE("(%p, %p, %p, %p)\n", poutscale, poutrotation, pouttranslation, pm);
217
218 /*Compute the scaling part.*/
219 vec.x=pm->u.m[0][0];
220 vec.y=pm->u.m[0][1];
221 vec.z=pm->u.m[0][2];
222 poutscale->x=D3DXVec3Length(&vec);
223
224 vec.x=pm->u.m[1][0];
225 vec.y=pm->u.m[1][1];
226 vec.z=pm->u.m[1][2];
227 poutscale->y=D3DXVec3Length(&vec);
228
229 vec.x=pm->u.m[2][0];
230 vec.y=pm->u.m[2][1];
231 vec.z=pm->u.m[2][2];
232 poutscale->z=D3DXVec3Length(&vec);
233
234 /*Compute the translation part.*/
235 pouttranslation->x=pm->u.m[3][0];
236 pouttranslation->y=pm->u.m[3][1];
237 pouttranslation->z=pm->u.m[3][2];
238
239 /*Let's calculate the rotation now*/
240 if ( (poutscale->x == 0.0f) || (poutscale->y == 0.0f) || (poutscale->z == 0.0f) ) return D3DERR_INVALIDCALL;
241
242 normalized.u.m[0][0]=pm->u.m[0][0]/poutscale->x;
243 normalized.u.m[0][1]=pm->u.m[0][1]/poutscale->x;
244 normalized.u.m[0][2]=pm->u.m[0][2]/poutscale->x;
245 normalized.u.m[1][0]=pm->u.m[1][0]/poutscale->y;
246 normalized.u.m[1][1]=pm->u.m[1][1]/poutscale->y;
247 normalized.u.m[1][2]=pm->u.m[1][2]/poutscale->y;
248 normalized.u.m[2][0]=pm->u.m[2][0]/poutscale->z;
249 normalized.u.m[2][1]=pm->u.m[2][1]/poutscale->z;
250 normalized.u.m[2][2]=pm->u.m[2][2]/poutscale->z;
251
252 D3DXQuaternionRotationMatrix(poutrotation,&normalized);
253 return S_OK;
254 }
255
256 FLOAT WINAPI D3DXMatrixDeterminant(CONST D3DXMATRIX *pm)
257 {
258 D3DXVECTOR4 minor, v1, v2, v3;
259 FLOAT det;
260
261 TRACE("(%p)\n", pm);
262
263 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];
264 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];
265 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];
266 D3DXVec4Cross(&minor, &v1, &v2, &v3);
267 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);
268 return det;
269 }
270
271 D3DXMATRIX* WINAPI D3DXMatrixInverse(D3DXMATRIX *pout, FLOAT *pdeterminant, CONST D3DXMATRIX *pm)
272 {
273 int a, i, j;
274 D3DXMATRIX out;
275 D3DXVECTOR4 v, vec[3];
276 FLOAT det;
277
278 TRACE("(%p, %p, %p)\n", pout, pdeterminant, pm);
279
280 det = D3DXMatrixDeterminant(pm);
281 if ( !det ) return NULL;
282 if ( pdeterminant ) *pdeterminant = det;
283 for (i=0; i<4; i++)
284 {
285 for (j=0; j<4; j++)
286 {
287 if (j != i )
288 {
289 a = j;
290 if ( j > i ) a = a-1;
291 vec[a].x = pm->u.m[j][0];
292 vec[a].y = pm->u.m[j][1];
293 vec[a].z = pm->u.m[j][2];
294 vec[a].w = pm->u.m[j][3];
295 }
296 }
297 D3DXVec4Cross(&v, &vec[0], &vec[1], &vec[2]);
298 out.u.m[0][i] = pow(-1.0f, i) * v.x / det;
299 out.u.m[1][i] = pow(-1.0f, i) * v.y / det;
300 out.u.m[2][i] = pow(-1.0f, i) * v.z / det;
301 out.u.m[3][i] = pow(-1.0f, i) * v.w / det;
302 }
303
304 *pout = out;
305 return pout;
306 }
307
308 D3DXMATRIX* WINAPI D3DXMatrixLookAtLH(D3DXMATRIX *pout, CONST D3DXVECTOR3 *peye, CONST D3DXVECTOR3 *pat, CONST D3DXVECTOR3 *pup)
309 {
310 D3DXVECTOR3 right, rightn, up, upn, vec, vec2;
311
312 TRACE("(%p, %p, %p, %p)\n", pout, peye, pat, pup);
313
314 D3DXVec3Subtract(&vec2, pat, peye);
315 D3DXVec3Normalize(&vec, &vec2);
316 D3DXVec3Cross(&right, pup, &vec);
317 D3DXVec3Cross(&up, &vec, &right);
318 D3DXVec3Normalize(&rightn, &right);
319 D3DXVec3Normalize(&upn, &up);
320 pout->u.m[0][0] = rightn.x;
321 pout->u.m[1][0] = rightn.y;
322 pout->u.m[2][0] = rightn.z;
323 pout->u.m[3][0] = -D3DXVec3Dot(&rightn,peye);
324 pout->u.m[0][1] = upn.x;
325 pout->u.m[1][1] = upn.y;
326 pout->u.m[2][1] = upn.z;
327 pout->u.m[3][1] = -D3DXVec3Dot(&upn, peye);
328 pout->u.m[0][2] = vec.x;
329 pout->u.m[1][2] = vec.y;
330 pout->u.m[2][2] = vec.z;
331 pout->u.m[3][2] = -D3DXVec3Dot(&vec, peye);
332 pout->u.m[0][3] = 0.0f;
333 pout->u.m[1][3] = 0.0f;
334 pout->u.m[2][3] = 0.0f;
335 pout->u.m[3][3] = 1.0f;
336 return pout;
337 }
338
339 D3DXMATRIX* WINAPI D3DXMatrixLookAtRH(D3DXMATRIX *pout, CONST D3DXVECTOR3 *peye, CONST D3DXVECTOR3 *pat, CONST D3DXVECTOR3 *pup)
340 {
341 D3DXVECTOR3 right, rightn, up, upn, vec, vec2;
342
343 TRACE("(%p, %p, %p, %p)\n", pout, peye, pat, pup);
344
345 D3DXVec3Subtract(&vec2, pat, peye);
346 D3DXVec3Normalize(&vec, &vec2);
347 D3DXVec3Cross(&right, pup, &vec);
348 D3DXVec3Cross(&up, &vec, &right);
349 D3DXVec3Normalize(&rightn, &right);
350 D3DXVec3Normalize(&upn, &up);
351 pout->u.m[0][0] = -rightn.x;
352 pout->u.m[1][0] = -rightn.y;
353 pout->u.m[2][0] = -rightn.z;
354 pout->u.m[3][0] = D3DXVec3Dot(&rightn,peye);
355 pout->u.m[0][1] = upn.x;
356 pout->u.m[1][1] = upn.y;
357 pout->u.m[2][1] = upn.z;
358 pout->u.m[3][1] = -D3DXVec3Dot(&upn, peye);
359 pout->u.m[0][2] = -vec.x;
360 pout->u.m[1][2] = -vec.y;
361 pout->u.m[2][2] = -vec.z;
362 pout->u.m[3][2] = D3DXVec3Dot(&vec, peye);
363 pout->u.m[0][3] = 0.0f;
364 pout->u.m[1][3] = 0.0f;
365 pout->u.m[2][3] = 0.0f;
366 pout->u.m[3][3] = 1.0f;
367 return pout;
368 }
369
370 D3DXMATRIX* WINAPI D3DXMatrixMultiply(D3DXMATRIX *pout, CONST D3DXMATRIX *pm1, CONST D3DXMATRIX *pm2)
371 {
372 D3DXMATRIX out;
373 int i,j;
374
375 TRACE("(%p, %p, %p)\n", pout, pm1, pm2);
376
377 for (i=0; i<4; i++)
378 {
379 for (j=0; j<4; j++)
380 {
381 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];
382 }
383 }
384
385 *pout = out;
386 return pout;
387 }
388
389 D3DXMATRIX* WINAPI D3DXMatrixMultiplyTranspose(D3DXMATRIX *pout, CONST D3DXMATRIX *pm1, CONST D3DXMATRIX *pm2)
390 {
391 TRACE("%p, %p, %p)\n", pout, pm1, pm2);
392
393 D3DXMatrixMultiply(pout, pm1, pm2);
394 D3DXMatrixTranspose(pout, pout);
395 return pout;
396 }
397
398 D3DXMATRIX* WINAPI D3DXMatrixOrthoLH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)
399 {
400 TRACE("(%p, %f, %f, %f, %f)\n", pout, w, h, zn, zf);
401
402 D3DXMatrixIdentity(pout);
403 pout->u.m[0][0] = 2.0f / w;
404 pout->u.m[1][1] = 2.0f / h;
405 pout->u.m[2][2] = 1.0f / (zf - zn);
406 pout->u.m[3][2] = zn / (zn - zf);
407 return pout;
408 }
409
410 D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterLH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf)
411 {
412 TRACE("(%p, %f, %f, %f, %f, %f, %f)\n", pout, l, r, b, t, zn, zf);
413
414 D3DXMatrixIdentity(pout);
415 pout->u.m[0][0] = 2.0f / (r - l);
416 pout->u.m[1][1] = 2.0f / (t - b);
417 pout->u.m[2][2] = 1.0f / (zf -zn);
418 pout->u.m[3][0] = -1.0f -2.0f *l / (r - l);
419 pout->u.m[3][1] = 1.0f + 2.0f * t / (b - t);
420 pout->u.m[3][2] = zn / (zn -zf);
421 return pout;
422 }
423
424 D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterRH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf)
425 {
426 TRACE("(%p, %f, %f, %f, %f, %f, %f)\n", pout, l, r, b, t, zn, zf);
427
428 D3DXMatrixIdentity(pout);
429 pout->u.m[0][0] = 2.0f / (r - l);
430 pout->u.m[1][1] = 2.0f / (t - b);
431 pout->u.m[2][2] = 1.0f / (zn -zf);
432 pout->u.m[3][0] = -1.0f -2.0f *l / (r - l);
433 pout->u.m[3][1] = 1.0f + 2.0f * t / (b - t);
434 pout->u.m[3][2] = zn / (zn -zf);
435 return pout;
436 }
437
438 D3DXMATRIX* WINAPI D3DXMatrixOrthoRH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)
439 {
440 TRACE("(%p, %f, %f, %f, %f)\n", pout, w, h, zn, zf);
441
442 D3DXMatrixIdentity(pout);
443 pout->u.m[0][0] = 2.0f / w;
444 pout->u.m[1][1] = 2.0f / h;
445 pout->u.m[2][2] = 1.0f / (zn - zf);
446 pout->u.m[3][2] = zn / (zn - zf);
447 return pout;
448 }
449
450 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovLH(D3DXMATRIX *pout, FLOAT fovy, FLOAT aspect, FLOAT zn, FLOAT zf)
451 {
452 TRACE("(%p, %f, %f, %f, %f)\n", pout, fovy, aspect, zn, zf);
453
454 D3DXMatrixIdentity(pout);
455 pout->u.m[0][0] = 1.0f / (aspect * tan(fovy/2.0f));
456 pout->u.m[1][1] = 1.0f / tan(fovy/2.0f);
457 pout->u.m[2][2] = zf / (zf - zn);
458 pout->u.m[2][3] = 1.0f;
459 pout->u.m[3][2] = (zf * zn) / (zn - zf);
460 pout->u.m[3][3] = 0.0f;
461 return pout;
462 }
463
464 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovRH(D3DXMATRIX *pout, FLOAT fovy, FLOAT aspect, FLOAT zn, FLOAT zf)
465 {
466 TRACE("(%p, %f, %f, %f, %f)\n", pout, fovy, aspect, zn, zf);
467
468 D3DXMatrixIdentity(pout);
469 pout->u.m[0][0] = 1.0f / (aspect * tan(fovy/2.0f));
470 pout->u.m[1][1] = 1.0f / tan(fovy/2.0f);
471 pout->u.m[2][2] = zf / (zn - zf);
472 pout->u.m[2][3] = -1.0f;
473 pout->u.m[3][2] = (zf * zn) / (zn - zf);
474 pout->u.m[3][3] = 0.0f;
475 return pout;
476 }
477
478 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveLH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)
479 {
480 TRACE("(%p, %f, %f, %f, %f)\n", pout, w, h, zn, zf);
481
482 D3DXMatrixIdentity(pout);
483 pout->u.m[0][0] = 2.0f * zn / w;
484 pout->u.m[1][1] = 2.0f * zn / h;
485 pout->u.m[2][2] = zf / (zf - zn);
486 pout->u.m[3][2] = (zn * zf) / (zn - zf);
487 pout->u.m[2][3] = 1.0f;
488 pout->u.m[3][3] = 0.0f;
489 return pout;
490 }
491
492 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterLH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf)
493 {
494 TRACE("(%p, %f, %f, %f, %f, %f, %f)\n", pout, l, r, b, t, zn, zf);
495
496 D3DXMatrixIdentity(pout);
497 pout->u.m[0][0] = 2.0f * zn / (r - l);
498 pout->u.m[1][1] = -2.0f * zn / (b - t);
499 pout->u.m[2][0] = -1.0f - 2.0f * l / (r - l);
500 pout->u.m[2][1] = 1.0f + 2.0f * t / (b - t);
501 pout->u.m[2][2] = - zf / (zn - zf);
502 pout->u.m[3][2] = (zn * zf) / (zn -zf);
503 pout->u.m[2][3] = 1.0f;
504 pout->u.m[3][3] = 0.0f;
505 return pout;
506 }
507
508 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterRH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf)
509 {
510 TRACE("(%p, %f, %f, %f, %f, %f, %f)\n", pout, l, r, b, t, zn, zf);
511
512 D3DXMatrixIdentity(pout);
513 pout->u.m[0][0] = 2.0f * zn / (r - l);
514 pout->u.m[1][1] = -2.0f * zn / (b - t);
515 pout->u.m[2][0] = 1.0f + 2.0f * l / (r - l);
516 pout->u.m[2][1] = -1.0f -2.0f * t / (b - t);
517 pout->u.m[2][2] = zf / (zn - zf);
518 pout->u.m[3][2] = (zn * zf) / (zn -zf);
519 pout->u.m[2][3] = -1.0f;
520 pout->u.m[3][3] = 0.0f;
521 return pout;
522 }
523
524 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveRH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)
525 {
526 TRACE("(%p, %f, %f, %f, %f)\n", pout, w, h, zn, zf);
527
528 D3DXMatrixIdentity(pout);
529 pout->u.m[0][0] = 2.0f * zn / w;
530 pout->u.m[1][1] = 2.0f * zn / h;
531 pout->u.m[2][2] = zf / (zn - zf);
532 pout->u.m[3][2] = (zn * zf) / (zn - zf);
533 pout->u.m[2][3] = -1.0f;
534 pout->u.m[3][3] = 0.0f;
535 return pout;
536 }
537
538 D3DXMATRIX* WINAPI D3DXMatrixReflect(D3DXMATRIX *pout, CONST D3DXPLANE *pplane)
539 {
540 D3DXPLANE Nplane;
541
542 TRACE("(%p, %p)\n", pout, pplane);
543
544 D3DXPlaneNormalize(&Nplane, pplane);
545 D3DXMatrixIdentity(pout);
546 pout->u.m[0][0] = 1.0f - 2.0f * Nplane.a * Nplane.a;
547 pout->u.m[0][1] = -2.0f * Nplane.a * Nplane.b;
548 pout->u.m[0][2] = -2.0f * Nplane.a * Nplane.c;
549 pout->u.m[1][0] = -2.0f * Nplane.a * Nplane.b;
550 pout->u.m[1][1] = 1.0f - 2.0f * Nplane.b * Nplane.b;
551 pout->u.m[1][2] = -2.0f * Nplane.b * Nplane.c;
552 pout->u.m[2][0] = -2.0f * Nplane.c * Nplane.a;
553 pout->u.m[2][1] = -2.0f * Nplane.c * Nplane.b;
554 pout->u.m[2][2] = 1.0f - 2.0f * Nplane.c * Nplane.c;
555 pout->u.m[3][0] = -2.0f * Nplane.d * Nplane.a;
556 pout->u.m[3][1] = -2.0f * Nplane.d * Nplane.b;
557 pout->u.m[3][2] = -2.0f * Nplane.d * Nplane.c;
558 return pout;
559 }
560
561 D3DXMATRIX * WINAPI D3DXMatrixRotationAxis(D3DXMATRIX *out, const D3DXVECTOR3 *v, FLOAT angle)
562 {
563 D3DXVECTOR3 nv;
564 FLOAT sangle, cangle, cdiff;
565
566 TRACE("out %p, v %p, angle %f\n", out, v, angle);
567
568 D3DXVec3Normalize(&nv, v);
569 sangle = sinf(angle);
570 cangle = cosf(angle);
571 cdiff = 1.0f - cangle;
572
573 out->u.m[0][0] = cdiff * nv.x * nv.x + cangle;
574 out->u.m[1][0] = cdiff * nv.x * nv.y - sangle * nv.z;
575 out->u.m[2][0] = cdiff * nv.x * nv.z + sangle * nv.y;
576 out->u.m[3][0] = 0.0f;
577 out->u.m[0][1] = cdiff * nv.y * nv.x + sangle * nv.z;
578 out->u.m[1][1] = cdiff * nv.y * nv.y + cangle;
579 out->u.m[2][1] = cdiff * nv.y * nv.z - sangle * nv.x;
580 out->u.m[3][1] = 0.0f;
581 out->u.m[0][2] = cdiff * nv.z * nv.x - sangle * nv.y;
582 out->u.m[1][2] = cdiff * nv.z * nv.y + sangle * nv.x;
583 out->u.m[2][2] = cdiff * nv.z * nv.z + cangle;
584 out->u.m[3][2] = 0.0f;
585 out->u.m[0][3] = 0.0f;
586 out->u.m[1][3] = 0.0f;
587 out->u.m[2][3] = 0.0f;
588 out->u.m[3][3] = 1.0f;
589
590 return out;
591 }
592
593 D3DXMATRIX* WINAPI D3DXMatrixRotationQuaternion(D3DXMATRIX *pout, CONST D3DXQUATERNION *pq)
594 {
595 TRACE("(%p, %p)\n", pout, pq);
596
597 D3DXMatrixIdentity(pout);
598 pout->u.m[0][0] = 1.0f - 2.0f * (pq->y * pq->y + pq->z * pq->z);
599 pout->u.m[0][1] = 2.0f * (pq->x *pq->y + pq->z * pq->w);
600 pout->u.m[0][2] = 2.0f * (pq->x * pq->z - pq->y * pq->w);
601 pout->u.m[1][0] = 2.0f * (pq->x * pq->y - pq->z * pq->w);
602 pout->u.m[1][1] = 1.0f - 2.0f * (pq->x * pq->x + pq->z * pq->z);
603 pout->u.m[1][2] = 2.0f * (pq->y *pq->z + pq->x *pq->w);
604 pout->u.m[2][0] = 2.0f * (pq->x * pq->z + pq->y * pq->w);
605 pout->u.m[2][1] = 2.0f * (pq->y *pq->z - pq->x *pq->w);
606 pout->u.m[2][2] = 1.0f - 2.0f * (pq->x * pq->x + pq->y * pq->y);
607 return pout;
608 }
609
610 D3DXMATRIX* WINAPI D3DXMatrixRotationX(D3DXMATRIX *pout, FLOAT angle)
611 {
612 TRACE("(%p, %f)\n", pout, angle);
613
614 D3DXMatrixIdentity(pout);
615 pout->u.m[1][1] = cos(angle);
616 pout->u.m[2][2] = cos(angle);
617 pout->u.m[1][2] = sin(angle);
618 pout->u.m[2][1] = -sin(angle);
619 return pout;
620 }
621
622 D3DXMATRIX* WINAPI D3DXMatrixRotationY(D3DXMATRIX *pout, FLOAT angle)
623 {
624 TRACE("(%p, %f)\n", pout, angle);
625
626 D3DXMatrixIdentity(pout);
627 pout->u.m[0][0] = cos(angle);
628 pout->u.m[2][2] = cos(angle);
629 pout->u.m[0][2] = -sin(angle);
630 pout->u.m[2][0] = sin(angle);
631 return pout;
632 }
633
634 D3DXMATRIX * WINAPI D3DXMatrixRotationYawPitchRoll(D3DXMATRIX *out, FLOAT yaw, FLOAT pitch, FLOAT roll)
635 {
636 FLOAT sroll, croll, spitch, cpitch, syaw, cyaw;
637
638 TRACE("out %p, yaw %f, pitch %f, roll %f\n", out, yaw, pitch, roll);
639
640 sroll = sinf(roll);
641 croll = cosf(roll);
642 spitch = sinf(pitch);
643 cpitch = cosf(pitch);
644 syaw = sinf(yaw);
645 cyaw = cosf(yaw);
646
647 out->u.m[0][0] = sroll * spitch * syaw + croll * cyaw;
648 out->u.m[0][1] = sroll * cpitch;
649 out->u.m[0][2] = sroll * spitch * cyaw - croll * syaw;
650 out->u.m[0][3] = 0.0f;
651 out->u.m[1][0] = croll * spitch * syaw - sroll * cyaw;
652 out->u.m[1][1] = croll * cpitch;
653 out->u.m[1][2] = croll * spitch * cyaw + sroll * syaw;
654 out->u.m[1][3] = 0.0f;
655 out->u.m[2][0] = cpitch * syaw;
656 out->u.m[2][1] = -spitch;
657 out->u.m[2][2] = cpitch * cyaw;
658 out->u.m[2][3] = 0.0f;
659 out->u.m[3][0] = 0.0f;
660 out->u.m[3][1] = 0.0f;
661 out->u.m[3][2] = 0.0f;
662 out->u.m[3][3] = 1.0f;
663
664 return out;
665 }
666
667 D3DXMATRIX* WINAPI D3DXMatrixRotationZ(D3DXMATRIX *pout, FLOAT angle)
668 {
669 TRACE("(%p, %f)\n", pout, angle);
670
671 D3DXMatrixIdentity(pout);
672 pout->u.m[0][0] = cos(angle);
673 pout->u.m[1][1] = cos(angle);
674 pout->u.m[0][1] = sin(angle);
675 pout->u.m[1][0] = -sin(angle);
676 return pout;
677 }
678
679 D3DXMATRIX* WINAPI D3DXMatrixScaling(D3DXMATRIX *pout, FLOAT sx, FLOAT sy, FLOAT sz)
680 {
681 TRACE("(%p, %f, %f, %f)\n", pout, sx, sy, sz);
682
683 D3DXMatrixIdentity(pout);
684 pout->u.m[0][0] = sx;
685 pout->u.m[1][1] = sy;
686 pout->u.m[2][2] = sz;
687 return pout;
688 }
689
690 D3DXMATRIX* WINAPI D3DXMatrixShadow(D3DXMATRIX *pout, CONST D3DXVECTOR4 *plight, CONST D3DXPLANE *pplane)
691 {
692 D3DXPLANE Nplane;
693 FLOAT dot;
694
695 TRACE("(%p, %p, %p)\n", pout, plight, pplane);
696
697 D3DXPlaneNormalize(&Nplane, pplane);
698 dot = D3DXPlaneDot(&Nplane, plight);
699 pout->u.m[0][0] = dot - Nplane.a * plight->x;
700 pout->u.m[0][1] = -Nplane.a * plight->y;
701 pout->u.m[0][2] = -Nplane.a * plight->z;
702 pout->u.m[0][3] = -Nplane.a * plight->w;
703 pout->u.m[1][0] = -Nplane.b * plight->x;
704 pout->u.m[1][1] = dot - Nplane.b * plight->y;
705 pout->u.m[1][2] = -Nplane.b * plight->z;
706 pout->u.m[1][3] = -Nplane.b * plight->w;
707 pout->u.m[2][0] = -Nplane.c * plight->x;
708 pout->u.m[2][1] = -Nplane.c * plight->y;
709 pout->u.m[2][2] = dot - Nplane.c * plight->z;
710 pout->u.m[2][3] = -Nplane.c * plight->w;
711 pout->u.m[3][0] = -Nplane.d * plight->x;
712 pout->u.m[3][1] = -Nplane.d * plight->y;
713 pout->u.m[3][2] = -Nplane.d * plight->z;
714 pout->u.m[3][3] = dot - Nplane.d * plight->w;
715 return pout;
716 }
717
718 D3DXMATRIX* WINAPI D3DXMatrixTransformation(D3DXMATRIX *pout, CONST D3DXVECTOR3 *pscalingcenter, CONST D3DXQUATERNION *pscalingrotation, CONST D3DXVECTOR3 *pscaling, CONST D3DXVECTOR3 *protationcenter, CONST D3DXQUATERNION *protation, CONST D3DXVECTOR3 *ptranslation)
719 {
720 D3DXMATRIX m1, m2, m3, m4, m5, m6, m7;
721 D3DXQUATERNION prc;
722 D3DXVECTOR3 psc, pt;
723
724 TRACE("(%p, %p, %p, %p, %p, %p, %p)\n", pout, pscalingcenter, pscalingrotation, pscaling, protationcenter, protation, ptranslation);
725
726 if ( !pscalingcenter )
727 {
728 psc.x = 0.0f;
729 psc.y = 0.0f;
730 psc.z = 0.0f;
731 }
732 else
733 {
734 psc.x = pscalingcenter->x;
735 psc.y = pscalingcenter->y;
736 psc.z = pscalingcenter->z;
737 }
738
739 if ( !protationcenter )
740 {
741 prc.x = 0.0f;
742 prc.y = 0.0f;
743 prc.z = 0.0f;
744 }
745 else
746 {
747 prc.x = protationcenter->x;
748 prc.y = protationcenter->y;
749 prc.z = protationcenter->z;
750 }
751
752 if ( !ptranslation )
753 {
754 pt.x = 0.0f;
755 pt.y = 0.0f;
756 pt.z = 0.0f;
757 }
758 else
759 {
760 pt.x = ptranslation->x;
761 pt.y = ptranslation->y;
762 pt.z = ptranslation->z;
763 }
764
765 D3DXMatrixTranslation(&m1, -psc.x, -psc.y, -psc.z);
766
767 if ( !pscalingrotation )
768 {
769 D3DXMatrixIdentity(&m2);
770 D3DXMatrixIdentity(&m4);
771 }
772 else
773 {
774 D3DXMatrixRotationQuaternion(&m4, pscalingrotation);
775 D3DXMatrixInverse(&m2, NULL, &m4);
776 }
777
778 if ( !pscaling ) D3DXMatrixIdentity(&m3);
779 else D3DXMatrixScaling(&m3, pscaling->x, pscaling->y, pscaling->z);
780
781 if ( !protation ) D3DXMatrixIdentity(&m6);
782 else D3DXMatrixRotationQuaternion(&m6, protation);
783
784 D3DXMatrixTranslation(&m5, psc.x - prc.x, psc.y - prc.y, psc.z - prc.z);
785 D3DXMatrixTranslation(&m7, prc.x + pt.x, prc.y + pt.y, prc.z + pt.z);
786 D3DXMatrixMultiply(&m1, &m1, &m2);
787 D3DXMatrixMultiply(&m1, &m1, &m3);
788 D3DXMatrixMultiply(&m1, &m1, &m4);
789 D3DXMatrixMultiply(&m1, &m1, &m5);
790 D3DXMatrixMultiply(&m1, &m1, &m6);
791 D3DXMatrixMultiply(pout, &m1, &m7);
792 return pout;
793 }
794
795 D3DXMATRIX* WINAPI D3DXMatrixTransformation2D(D3DXMATRIX *pout, CONST D3DXVECTOR2 *pscalingcenter, FLOAT scalingrotation, CONST D3DXVECTOR2 *pscaling, CONST D3DXVECTOR2 *protationcenter, FLOAT rotation, CONST D3DXVECTOR2 *ptranslation)
796 {
797 D3DXQUATERNION rot, sca_rot;
798 D3DXVECTOR3 rot_center, sca, sca_center, trans;
799
800 TRACE("(%p, %p, %f, %p, %p, %f, %p)\n", pout, pscalingcenter, scalingrotation, pscaling, protationcenter, rotation, ptranslation);
801
802 if ( pscalingcenter )
803 {
804 sca_center.x=pscalingcenter->x;
805 sca_center.y=pscalingcenter->y;
806 sca_center.z=0.0f;
807 }
808 else
809 {
810 sca_center.x=0.0f;
811 sca_center.y=0.0f;
812 sca_center.z=0.0f;
813 }
814
815 if ( pscaling )
816 {
817 sca.x=pscaling->x;
818 sca.y=pscaling->y;
819 sca.z=1.0f;
820 }
821 else
822 {
823 sca.x=1.0f;
824 sca.y=1.0f;
825 sca.z=1.0f;
826 }
827
828 if ( protationcenter )
829 {
830 rot_center.x=protationcenter->x;
831 rot_center.y=protationcenter->y;
832 rot_center.z=0.0f;
833 }
834 else
835 {
836 rot_center.x=0.0f;
837 rot_center.y=0.0f;
838 rot_center.z=0.0f;
839 }
840
841 if ( ptranslation )
842 {
843 trans.x=ptranslation->x;
844 trans.y=ptranslation->y;
845 trans.z=0.0f;
846 }
847 else
848 {
849 trans.x=0.0f;
850 trans.y=0.0f;
851 trans.z=0.0f;
852 }
853
854 rot.w=cos(rotation/2.0f);
855 rot.x=0.0f;
856 rot.y=0.0f;
857 rot.z=sin(rotation/2.0f);
858
859 sca_rot.w=cos(scalingrotation/2.0f);
860 sca_rot.x=0.0f;
861 sca_rot.y=0.0f;
862 sca_rot.z=sin(scalingrotation/2.0f);
863
864 D3DXMatrixTransformation(pout, &sca_center, &sca_rot, &sca, &rot_center, &rot, &trans);
865
866 return pout;
867 }
868
869 D3DXMATRIX* WINAPI D3DXMatrixTranslation(D3DXMATRIX *pout, FLOAT x, FLOAT y, FLOAT z)
870 {
871 TRACE("(%p, %f, %f, %f)\n", pout, x, y, z);
872
873 D3DXMatrixIdentity(pout);
874 pout->u.m[3][0] = x;
875 pout->u.m[3][1] = y;
876 pout->u.m[3][2] = z;
877 return pout;
878 }
879
880 D3DXMATRIX* WINAPI D3DXMatrixTranspose(D3DXMATRIX *pout, CONST D3DXMATRIX *pm)
881 {
882 CONST D3DXMATRIX m = *pm;
883 int i,j;
884
885 TRACE("(%p, %p)\n", pout, pm);
886
887 for (i=0; i<4; i++)
888 for (j=0; j<4; j++) pout->u.m[i][j] = m.u.m[j][i];
889
890 return pout;
891 }
892
893 /*_________________D3DXMatrixStack____________________*/
894
895 static const unsigned int INITIAL_STACK_SIZE = 32;
896
897 HRESULT WINAPI D3DXCreateMatrixStack(DWORD flags, ID3DXMatrixStack **ppstack)
898 {
899 struct ID3DXMatrixStackImpl *object;
900
901 TRACE("flags %#x, ppstack %p\n", flags, ppstack);
902
903 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
904 if (object == NULL)
905 {
906 *ppstack = NULL;
907 return E_OUTOFMEMORY;
908 }
909 object->ID3DXMatrixStack_iface.lpVtbl = &ID3DXMatrixStack_Vtbl;
910 object->ref = 1;
911
912 object->stack = HeapAlloc(GetProcessHeap(), 0, INITIAL_STACK_SIZE * sizeof(*object->stack));
913 if (!object->stack)
914 {
915 HeapFree(GetProcessHeap(), 0, object);
916 *ppstack = NULL;
917 return E_OUTOFMEMORY;
918 }
919
920 object->current = 0;
921 object->stack_size = INITIAL_STACK_SIZE;
922 D3DXMatrixIdentity(&object->stack[0]);
923
924 TRACE("Created matrix stack %p\n", object);
925
926 *ppstack = &object->ID3DXMatrixStack_iface;
927 return D3D_OK;
928 }
929
930 static inline struct ID3DXMatrixStackImpl *impl_from_ID3DXMatrixStack(ID3DXMatrixStack *iface)
931 {
932 return CONTAINING_RECORD(iface, struct ID3DXMatrixStackImpl, ID3DXMatrixStack_iface);
933 }
934
935 static HRESULT WINAPI ID3DXMatrixStackImpl_QueryInterface(ID3DXMatrixStack *iface, REFIID riid, void **out)
936 {
937 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
938
939 if (IsEqualGUID(riid, &IID_ID3DXMatrixStack)
940 || IsEqualGUID(riid, &IID_IUnknown))
941 {
942 ID3DXMatrixStack_AddRef(iface);
943 *out = iface;
944 return S_OK;
945 }
946
947 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
948
949 *out = NULL;
950 return E_NOINTERFACE;
951 }
952
953 static ULONG WINAPI ID3DXMatrixStackImpl_AddRef(ID3DXMatrixStack *iface)
954 {
955 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
956 ULONG ref = InterlockedIncrement(&This->ref);
957 TRACE("(%p) : AddRef from %d\n", This, ref - 1);
958 return ref;
959 }
960
961 static ULONG WINAPI ID3DXMatrixStackImpl_Release(ID3DXMatrixStack *iface)
962 {
963 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
964 ULONG ref = InterlockedDecrement(&This->ref);
965 if (!ref)
966 {
967 HeapFree(GetProcessHeap(), 0, This->stack);
968 HeapFree(GetProcessHeap(), 0, This);
969 }
970 TRACE("(%p) : ReleaseRef to %d\n", This, ref);
971 return ref;
972 }
973
974 static D3DXMATRIX* WINAPI ID3DXMatrixStackImpl_GetTop(ID3DXMatrixStack *iface)
975 {
976 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
977
978 TRACE("iface %p\n", iface);
979
980 return &This->stack[This->current];
981 }
982
983 static HRESULT WINAPI ID3DXMatrixStackImpl_LoadIdentity(ID3DXMatrixStack *iface)
984 {
985 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
986
987 TRACE("iface %p\n", iface);
988
989 D3DXMatrixIdentity(&This->stack[This->current]);
990
991 return D3D_OK;
992 }
993
994 static HRESULT WINAPI ID3DXMatrixStackImpl_LoadMatrix(ID3DXMatrixStack *iface, CONST D3DXMATRIX *pm)
995 {
996 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
997
998 TRACE("iface %p\n", iface);
999
1000 This->stack[This->current] = *pm;
1001
1002 return D3D_OK;
1003 }
1004
1005 static HRESULT WINAPI ID3DXMatrixStackImpl_MultMatrix(ID3DXMatrixStack *iface, CONST D3DXMATRIX *pm)
1006 {
1007 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1008
1009 TRACE("iface %p\n", iface);
1010
1011 D3DXMatrixMultiply(&This->stack[This->current], &This->stack[This->current], pm);
1012
1013 return D3D_OK;
1014 }
1015
1016 static HRESULT WINAPI ID3DXMatrixStackImpl_MultMatrixLocal(ID3DXMatrixStack *iface, CONST D3DXMATRIX *pm)
1017 {
1018 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1019
1020 TRACE("iface %p\n", iface);
1021
1022 D3DXMatrixMultiply(&This->stack[This->current], pm, &This->stack[This->current]);
1023
1024 return D3D_OK;
1025 }
1026
1027 static HRESULT WINAPI ID3DXMatrixStackImpl_Pop(ID3DXMatrixStack *iface)
1028 {
1029 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1030
1031 TRACE("iface %p\n", iface);
1032
1033 /* Popping the last element on the stack returns D3D_OK, but does nothing. */
1034 if (!This->current) return D3D_OK;
1035
1036 if (This->current <= This->stack_size / 4 && This->stack_size >= INITIAL_STACK_SIZE * 2)
1037 {
1038 unsigned int new_size;
1039 D3DXMATRIX *new_stack;
1040
1041 new_size = This->stack_size / 2;
1042 new_stack = HeapReAlloc(GetProcessHeap(), 0, This->stack, new_size * sizeof(*new_stack));
1043 if (new_stack)
1044 {
1045 This->stack_size = new_size;
1046 This->stack = new_stack;
1047 }
1048 }
1049
1050 --This->current;
1051
1052 return D3D_OK;
1053 }
1054
1055 static HRESULT WINAPI ID3DXMatrixStackImpl_Push(ID3DXMatrixStack *iface)
1056 {
1057 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1058
1059 TRACE("iface %p\n", iface);
1060
1061 if (This->current == This->stack_size - 1)
1062 {
1063 unsigned int new_size;
1064 D3DXMATRIX *new_stack;
1065
1066 if (This->stack_size > UINT_MAX / 2) return E_OUTOFMEMORY;
1067
1068 new_size = This->stack_size * 2;
1069 new_stack = HeapReAlloc(GetProcessHeap(), 0, This->stack, new_size * sizeof(*new_stack));
1070 if (!new_stack) return E_OUTOFMEMORY;
1071
1072 This->stack_size = new_size;
1073 This->stack = new_stack;
1074 }
1075
1076 ++This->current;
1077 This->stack[This->current] = This->stack[This->current - 1];
1078
1079 return D3D_OK;
1080 }
1081
1082 static HRESULT WINAPI ID3DXMatrixStackImpl_RotateAxis(ID3DXMatrixStack *iface, CONST D3DXVECTOR3 *pv, FLOAT angle)
1083 {
1084 D3DXMATRIX temp;
1085 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1086
1087 TRACE("iface %p\n", iface);
1088
1089 D3DXMatrixRotationAxis(&temp, pv, angle);
1090 D3DXMatrixMultiply(&This->stack[This->current], &This->stack[This->current], &temp);
1091
1092 return D3D_OK;
1093 }
1094
1095 static HRESULT WINAPI ID3DXMatrixStackImpl_RotateAxisLocal(ID3DXMatrixStack *iface, CONST D3DXVECTOR3 *pv, FLOAT angle)
1096 {
1097 D3DXMATRIX temp;
1098 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1099
1100 TRACE("iface %p\n", iface);
1101
1102 D3DXMatrixRotationAxis(&temp, pv, angle);
1103 D3DXMatrixMultiply(&This->stack[This->current], &temp, &This->stack[This->current]);
1104
1105 return D3D_OK;
1106 }
1107
1108 static HRESULT WINAPI ID3DXMatrixStackImpl_RotateYawPitchRoll(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
1109 {
1110 D3DXMATRIX temp;
1111 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1112
1113 TRACE("iface %p\n", iface);
1114
1115 D3DXMatrixRotationYawPitchRoll(&temp, x, y, z);
1116 D3DXMatrixMultiply(&This->stack[This->current], &This->stack[This->current], &temp);
1117
1118 return D3D_OK;
1119 }
1120
1121 static HRESULT WINAPI ID3DXMatrixStackImpl_RotateYawPitchRollLocal(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
1122 {
1123 D3DXMATRIX temp;
1124 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1125
1126 TRACE("iface %p\n", iface);
1127
1128 D3DXMatrixRotationYawPitchRoll(&temp, x, y, z);
1129 D3DXMatrixMultiply(&This->stack[This->current], &temp, &This->stack[This->current]);
1130
1131 return D3D_OK;
1132 }
1133
1134 static HRESULT WINAPI ID3DXMatrixStackImpl_Scale(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
1135 {
1136 D3DXMATRIX temp;
1137 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1138
1139 TRACE("iface %p\n", iface);
1140
1141 D3DXMatrixScaling(&temp, x, y, z);
1142 D3DXMatrixMultiply(&This->stack[This->current], &This->stack[This->current], &temp);
1143
1144 return D3D_OK;
1145 }
1146
1147 static HRESULT WINAPI ID3DXMatrixStackImpl_ScaleLocal(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
1148 {
1149 D3DXMATRIX temp;
1150 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1151
1152 TRACE("iface %p\n", iface);
1153
1154 D3DXMatrixScaling(&temp, x, y, z);
1155 D3DXMatrixMultiply(&This->stack[This->current], &temp, &This->stack[This->current]);
1156
1157 return D3D_OK;
1158 }
1159
1160 static HRESULT WINAPI ID3DXMatrixStackImpl_Translate(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
1161 {
1162 D3DXMATRIX temp;
1163 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1164
1165 TRACE("iface %p\n", iface);
1166
1167 D3DXMatrixTranslation(&temp, x, y, z);
1168 D3DXMatrixMultiply(&This->stack[This->current], &This->stack[This->current], &temp);
1169
1170 return D3D_OK;
1171 }
1172
1173 static HRESULT WINAPI ID3DXMatrixStackImpl_TranslateLocal(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
1174 {
1175 D3DXMATRIX temp;
1176 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1177
1178 TRACE("iface %p\n", iface);
1179
1180 D3DXMatrixTranslation(&temp, x, y, z);
1181 D3DXMatrixMultiply(&This->stack[This->current], &temp,&This->stack[This->current]);
1182
1183 return D3D_OK;
1184 }
1185
1186 static const ID3DXMatrixStackVtbl ID3DXMatrixStack_Vtbl =
1187 {
1188 ID3DXMatrixStackImpl_QueryInterface,
1189 ID3DXMatrixStackImpl_AddRef,
1190 ID3DXMatrixStackImpl_Release,
1191 ID3DXMatrixStackImpl_Pop,
1192 ID3DXMatrixStackImpl_Push,
1193 ID3DXMatrixStackImpl_LoadIdentity,
1194 ID3DXMatrixStackImpl_LoadMatrix,
1195 ID3DXMatrixStackImpl_MultMatrix,
1196 ID3DXMatrixStackImpl_MultMatrixLocal,
1197 ID3DXMatrixStackImpl_RotateAxis,
1198 ID3DXMatrixStackImpl_RotateAxisLocal,
1199 ID3DXMatrixStackImpl_RotateYawPitchRoll,
1200 ID3DXMatrixStackImpl_RotateYawPitchRollLocal,
1201 ID3DXMatrixStackImpl_Scale,
1202 ID3DXMatrixStackImpl_ScaleLocal,
1203 ID3DXMatrixStackImpl_Translate,
1204 ID3DXMatrixStackImpl_TranslateLocal,
1205 ID3DXMatrixStackImpl_GetTop
1206 };
1207
1208 /*_________________D3DXPLANE________________*/
1209
1210 D3DXPLANE* WINAPI D3DXPlaneFromPointNormal(D3DXPLANE *pout, CONST D3DXVECTOR3 *pvpoint, CONST D3DXVECTOR3 *pvnormal)
1211 {
1212 TRACE("(%p, %p, %p)\n", pout, pvpoint, pvnormal);
1213
1214 pout->a = pvnormal->x;
1215 pout->b = pvnormal->y;
1216 pout->c = pvnormal->z;
1217 pout->d = -D3DXVec3Dot(pvpoint, pvnormal);
1218 return pout;
1219 }
1220
1221 D3DXPLANE* WINAPI D3DXPlaneFromPoints(D3DXPLANE *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3)
1222 {
1223 D3DXVECTOR3 edge1, edge2, normal, Nnormal;
1224
1225 TRACE("(%p, %p, %p, %p)\n", pout, pv1, pv2, pv3);
1226
1227 edge1.x = 0.0f; edge1.y = 0.0f; edge1.z = 0.0f;
1228 edge2.x = 0.0f; edge2.y = 0.0f; edge2.z = 0.0f;
1229 D3DXVec3Subtract(&edge1, pv2, pv1);
1230 D3DXVec3Subtract(&edge2, pv3, pv1);
1231 D3DXVec3Cross(&normal, &edge1, &edge2);
1232 D3DXVec3Normalize(&Nnormal, &normal);
1233 D3DXPlaneFromPointNormal(pout, pv1, &Nnormal);
1234 return pout;
1235 }
1236
1237 D3DXVECTOR3* WINAPI D3DXPlaneIntersectLine(D3DXVECTOR3 *pout, CONST D3DXPLANE *pp, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
1238 {
1239 D3DXVECTOR3 direction, normal;
1240 FLOAT dot, temp;
1241
1242 TRACE("(%p, %p, %p, %p)\n", pout, pp, pv1, pv2);
1243
1244 normal.x = pp->a;
1245 normal.y = pp->b;
1246 normal.z = pp->c;
1247 direction.x = pv2->x - pv1->x;
1248 direction.y = pv2->y - pv1->y;
1249 direction.z = pv2->z - pv1->z;
1250 dot = D3DXVec3Dot(&normal, &direction);
1251 if ( !dot ) return NULL;
1252 temp = ( pp->d + D3DXVec3Dot(&normal, pv1) ) / dot;
1253 pout->x = pv1->x - temp * direction.x;
1254 pout->y = pv1->y - temp * direction.y;
1255 pout->z = pv1->z - temp * direction.z;
1256 return pout;
1257 }
1258
1259 D3DXPLANE * WINAPI D3DXPlaneNormalize(D3DXPLANE *out, const D3DXPLANE *p)
1260 {
1261 FLOAT norm;
1262
1263 TRACE("out %p, p %p\n", out, p);
1264
1265 norm = sqrtf(p->a * p->a + p->b * p->b + p->c * p->c);
1266 if (norm)
1267 {
1268 out->a = p->a / norm;
1269 out->b = p->b / norm;
1270 out->c = p->c / norm;
1271 out->d = p->d / norm;
1272 }
1273 else
1274 {
1275 out->a = 0.0f;
1276 out->b = 0.0f;
1277 out->c = 0.0f;
1278 out->d = 0.0f;
1279 }
1280
1281 return out;
1282 }
1283
1284 D3DXPLANE* WINAPI D3DXPlaneTransform(D3DXPLANE *pout, CONST D3DXPLANE *pplane, CONST D3DXMATRIX *pm)
1285 {
1286 CONST D3DXPLANE plane = *pplane;
1287
1288 TRACE("(%p, %p, %p)\n", pout, pplane, pm);
1289
1290 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;
1291 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;
1292 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;
1293 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;
1294 return pout;
1295 }
1296
1297 D3DXPLANE* WINAPI D3DXPlaneTransformArray(D3DXPLANE* out, UINT outstride, CONST D3DXPLANE* in, UINT instride, CONST D3DXMATRIX* matrix, UINT elements)
1298 {
1299 UINT i;
1300
1301 TRACE("(%p, %u, %p, %u, %p, %u)\n", out, outstride, in, instride, matrix, elements);
1302
1303 for (i = 0; i < elements; ++i) {
1304 D3DXPlaneTransform(
1305 (D3DXPLANE*)((char*)out + outstride * i),
1306 (CONST D3DXPLANE*)((const char*)in + instride * i),
1307 matrix);
1308 }
1309 return out;
1310 }
1311
1312 /*_________________D3DXQUATERNION________________*/
1313
1314 D3DXQUATERNION* WINAPI D3DXQuaternionBaryCentric(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, CONST D3DXQUATERNION *pq3, FLOAT f, FLOAT g)
1315 {
1316 D3DXQUATERNION temp1, temp2;
1317
1318 TRACE("(%p, %p, %p, %p, %f, %f)\n", pout, pq1, pq2, pq3, f, g);
1319
1320 D3DXQuaternionSlerp(pout, D3DXQuaternionSlerp(&temp1, pq1, pq2, f + g), D3DXQuaternionSlerp(&temp2, pq1, pq3, f+g), g / (f + g));
1321 return pout;
1322 }
1323
1324 D3DXQUATERNION * WINAPI D3DXQuaternionExp(D3DXQUATERNION *out, const D3DXQUATERNION *q)
1325 {
1326 FLOAT norm;
1327
1328 TRACE("out %p, q %p\n", out, q);
1329
1330 norm = sqrtf(q->x * q->x + q->y * q->y + q->z * q->z);
1331 if (norm)
1332 {
1333 out->x = sinf(norm) * q->x / norm;
1334 out->y = sinf(norm) * q->y / norm;
1335 out->z = sinf(norm) * q->z / norm;
1336 out->w = cosf(norm);
1337 }
1338 else
1339 {
1340 out->x = 0.0f;
1341 out->y = 0.0f;
1342 out->z = 0.0f;
1343 out->w = 1.0f;
1344 }
1345
1346 return out;
1347 }
1348
1349 D3DXQUATERNION* WINAPI D3DXQuaternionInverse(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
1350 {
1351 D3DXQUATERNION out;
1352 FLOAT norm;
1353
1354 TRACE("(%p, %p)\n", pout, pq);
1355
1356 norm = D3DXQuaternionLengthSq(pq);
1357
1358 out.x = -pq->x / norm;
1359 out.y = -pq->y / norm;
1360 out.z = -pq->z / norm;
1361 out.w = pq->w / norm;
1362
1363 *pout =out;
1364 return pout;
1365 }
1366
1367 D3DXQUATERNION * WINAPI D3DXQuaternionLn(D3DXQUATERNION *out, const D3DXQUATERNION *q)
1368 {
1369 FLOAT t;
1370
1371 TRACE("out %p, q %p\n", out, q);
1372
1373 if ((q->w >= 1.0f) || (q->w == -1.0f))
1374 t = 1.0f;
1375 else
1376 t = acosf(q->w) / sqrtf(1.0f - q->w * q->w);
1377
1378 out->x = t * q->x;
1379 out->y = t * q->y;
1380 out->z = t * q->z;
1381 out->w = 0.0f;
1382
1383 return out;
1384 }
1385
1386 D3DXQUATERNION* WINAPI D3DXQuaternionMultiply(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2)
1387 {
1388 D3DXQUATERNION out;
1389
1390 TRACE("(%p, %p, %p)\n", pout, pq1, pq2);
1391
1392 out.x = pq2->w * pq1->x + pq2->x * pq1->w + pq2->y * pq1->z - pq2->z * pq1->y;
1393 out.y = pq2->w * pq1->y - pq2->x * pq1->z + pq2->y * pq1->w + pq2->z * pq1->x;
1394 out.z = pq2->w * pq1->z + pq2->x * pq1->y - pq2->y * pq1->x + pq2->z * pq1->w;
1395 out.w = pq2->w * pq1->w - pq2->x * pq1->x - pq2->y * pq1->y - pq2->z * pq1->z;
1396 *pout = out;
1397 return pout;
1398 }
1399
1400 D3DXQUATERNION * WINAPI D3DXQuaternionNormalize(D3DXQUATERNION *out, const D3DXQUATERNION *q)
1401 {
1402 FLOAT norm;
1403
1404 TRACE("out %p, q %p\n", out, q);
1405
1406 norm = D3DXQuaternionLength(q);
1407
1408 out->x = q->x / norm;
1409 out->y = q->y / norm;
1410 out->z = q->z / norm;
1411 out->w = q->w / norm;
1412
1413 return out;
1414 }
1415
1416 D3DXQUATERNION * WINAPI D3DXQuaternionRotationAxis(D3DXQUATERNION *out, const D3DXVECTOR3 *v, FLOAT angle)
1417 {
1418 D3DXVECTOR3 temp;
1419
1420 TRACE("out %p, v %p, angle %f\n", out, v, angle);
1421
1422 D3DXVec3Normalize(&temp, v);
1423
1424 out->x = sinf(angle / 2.0f) * temp.x;
1425 out->y = sinf(angle / 2.0f) * temp.y;
1426 out->z = sinf(angle / 2.0f) * temp.z;
1427 out->w = cosf(angle / 2.0f);
1428
1429 return out;
1430 }
1431
1432 D3DXQUATERNION * WINAPI D3DXQuaternionRotationMatrix(D3DXQUATERNION *out, const D3DXMATRIX *m)
1433 {
1434 FLOAT s, trace;
1435
1436 TRACE("out %p, m %p\n", out, m);
1437
1438 trace = m->u.m[0][0] + m->u.m[1][1] + m->u.m[2][2] + 1.0f;
1439 if (trace > 1.0f)
1440 {
1441 s = 2.0f * sqrtf(trace);
1442 out->x = (m->u.m[1][2] - m->u.m[2][1]) / s;
1443 out->y = (m->u.m[2][0] - m->u.m[0][2]) / s;
1444 out->z = (m->u.m[0][1] - m->u.m[1][0]) / s;
1445 out->w = 0.25f * s;
1446 }
1447 else
1448 {
1449 int i, maxi = 0;
1450
1451 for (i = 1; i < 3; i++)
1452 {
1453 if (m->u.m[i][i] > m->u.m[maxi][maxi])
1454 maxi = i;
1455 }
1456
1457 switch (maxi)
1458 {
1459 case 0:
1460 s = 2.0f * sqrtf(1.0f + m->u.m[0][0] - m->u.m[1][1] - m->u.m[2][2]);
1461 out->x = 0.25f * s;
1462 out->y = (m->u.m[0][1] + m->u.m[1][0]) / s;
1463 out->z = (m->u.m[0][2] + m->u.m[2][0]) / s;
1464 out->w = (m->u.m[1][2] - m->u.m[2][1]) / s;
1465 break;
1466
1467 case 1:
1468 s = 2.0f * sqrtf(1.0f + m->u.m[1][1] - m->u.m[0][0] - m->u.m[2][2]);
1469 out->x = (m->u.m[0][1] + m->u.m[1][0]) / s;
1470 out->y = 0.25f * s;
1471 out->z = (m->u.m[1][2] + m->u.m[2][1]) / s;
1472 out->w = (m->u.m[2][0] - m->u.m[0][2]) / s;
1473 break;
1474
1475 case 2:
1476 s = 2.0f * sqrtf(1.0f + m->u.m[2][2] - m->u.m[0][0] - m->u.m[1][1]);
1477 out->x = (m->u.m[0][2] + m->u.m[2][0]) / s;
1478 out->y = (m->u.m[1][2] + m->u.m[2][1]) / s;
1479 out->z = 0.25f * s;
1480 out->w = (m->u.m[0][1] - m->u.m[1][0]) / s;
1481 break;
1482 }
1483 }
1484
1485 return out;
1486 }
1487
1488 D3DXQUATERNION * WINAPI D3DXQuaternionRotationYawPitchRoll(D3DXQUATERNION *out, FLOAT yaw, FLOAT pitch, FLOAT roll)
1489 {
1490 FLOAT syaw, cyaw, spitch, cpitch, sroll, croll;
1491
1492 TRACE("out %p, yaw %f, pitch %f, roll %f\n", out, yaw, pitch, roll);
1493
1494 syaw = sinf(yaw / 2.0f);
1495 cyaw = cosf(yaw / 2.0f);
1496 spitch = sinf(pitch / 2.0f);
1497 cpitch = cosf(pitch / 2.0f);
1498 sroll = sinf(roll / 2.0f);
1499 croll = cosf(roll / 2.0f);
1500
1501 out->x = syaw * cpitch * sroll + cyaw * spitch * croll;
1502 out->y = syaw * cpitch * croll - cyaw * spitch * sroll;
1503 out->z = cyaw * cpitch * sroll - syaw * spitch * croll;
1504 out->w = cyaw * cpitch * croll + syaw * spitch * sroll;
1505
1506 return out;
1507 }
1508
1509 D3DXQUATERNION * WINAPI D3DXQuaternionSlerp(D3DXQUATERNION *out, const D3DXQUATERNION *q1,
1510 const D3DXQUATERNION *q2, FLOAT t)
1511 {
1512 FLOAT dot, temp;
1513
1514 TRACE("out %p, q1 %p, q2 %p, t %f\n", out, q1, q2, t);
1515
1516 temp = 1.0f - t;
1517 dot = D3DXQuaternionDot(q1, q2);
1518 if (dot < 0.0f)
1519 {
1520 t = -t;
1521 dot = -dot;
1522 }
1523
1524 if (1.0f - dot > 0.001f)
1525 {
1526 FLOAT theta = acosf(dot);
1527
1528 temp = sinf(theta * temp) / sinf(theta);
1529 t = sinf(theta * t) / sinf(theta);
1530 }
1531
1532 out->x = temp * q1->x + t * q2->x;
1533 out->y = temp * q1->y + t * q2->y;
1534 out->z = temp * q1->z + t * q2->z;
1535 out->w = temp * q1->w + t * q2->w;
1536
1537 return out;
1538 }
1539
1540 D3DXQUATERNION* WINAPI D3DXQuaternionSquad(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, CONST D3DXQUATERNION *pq3, CONST D3DXQUATERNION *pq4, FLOAT t)
1541 {
1542 D3DXQUATERNION temp1, temp2;
1543
1544 TRACE("(%p, %p, %p, %p, %p, %f)\n", pout, pq1, pq2, pq3, pq4, t);
1545
1546 D3DXQuaternionSlerp(pout, D3DXQuaternionSlerp(&temp1, pq1, pq4, t), D3DXQuaternionSlerp(&temp2, pq2, pq3, t), 2.0f * t * (1.0f - t));
1547 return pout;
1548 }
1549
1550 static D3DXQUATERNION add_diff(CONST D3DXQUATERNION *q1, CONST D3DXQUATERNION *q2, CONST FLOAT add)
1551 {
1552 D3DXQUATERNION temp;
1553
1554 temp.x = q1->x + add * q2->x;
1555 temp.y = q1->y + add * q2->y;
1556 temp.z = q1->z + add * q2->z;
1557 temp.w = q1->w + add * q2->w;
1558
1559 return temp;
1560 }
1561
1562 void WINAPI D3DXQuaternionSquadSetup(D3DXQUATERNION *paout, D3DXQUATERNION *pbout, D3DXQUATERNION *pcout, CONST D3DXQUATERNION *pq0, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, CONST D3DXQUATERNION *pq3)
1563 {
1564 D3DXQUATERNION q, temp1, temp2, temp3, zero;
1565
1566 TRACE("(%p, %p, %p, %p, %p, %p, %p)\n", paout, pbout, pcout, pq0, pq1, pq2, pq3);
1567
1568 zero.x = 0.0f;
1569 zero.y = 0.0f;
1570 zero.z = 0.0f;
1571 zero.w = 0.0f;
1572
1573 if ( D3DXQuaternionDot(pq0, pq1) < 0.0f )
1574 temp2 = add_diff(&zero, pq0, -1.0f);
1575 else
1576 temp2 = *pq0;
1577
1578 if ( D3DXQuaternionDot(pq1, pq2) < 0.0f )
1579 *pcout = add_diff(&zero, pq2, -1.0f);
1580 else
1581 *pcout = *pq2;
1582
1583 if ( D3DXQuaternionDot(pcout, pq3) < 0.0f )
1584 temp3 = add_diff(&zero, pq3, -1.0f);
1585 else
1586 temp3 = *pq3;
1587
1588 D3DXQuaternionInverse(&temp1, pq1);
1589 D3DXQuaternionMultiply(&temp2, &temp1, &temp2);
1590 D3DXQuaternionLn(&temp2, &temp2);
1591 D3DXQuaternionMultiply(&q, &temp1, pcout);
1592 D3DXQuaternionLn(&q, &q);
1593 temp1 = add_diff(&temp2, &q, 1.0f);
1594 temp1.x *= -0.25f;
1595 temp1.y *= -0.25f;
1596 temp1.z *= -0.25f;
1597 temp1.w *= -0.25f;
1598 D3DXQuaternionExp(&temp1, &temp1);
1599 D3DXQuaternionMultiply(paout, pq1, &temp1);
1600
1601 D3DXQuaternionInverse(&temp1, pcout);
1602 D3DXQuaternionMultiply(&temp2, &temp1, pq1);
1603 D3DXQuaternionLn(&temp2, &temp2);
1604 D3DXQuaternionMultiply(&q, &temp1, &temp3);
1605 D3DXQuaternionLn(&q, &q);
1606 temp1 = add_diff(&temp2, &q, 1.0f);
1607 temp1.x *= -0.25f;
1608 temp1.y *= -0.25f;
1609 temp1.z *= -0.25f;
1610 temp1.w *= -0.25f;
1611 D3DXQuaternionExp(&temp1, &temp1);
1612 D3DXQuaternionMultiply(pbout, pcout, &temp1);
1613
1614 return;
1615 }
1616
1617 void WINAPI D3DXQuaternionToAxisAngle(CONST D3DXQUATERNION *pq, D3DXVECTOR3 *paxis, FLOAT *pangle)
1618 {
1619 TRACE("(%p, %p, %p)\n", pq, paxis, pangle);
1620
1621 paxis->x = pq->x;
1622 paxis->y = pq->y;
1623 paxis->z = pq->z;
1624 *pangle = 2.0f * acos(pq->w);
1625 }
1626
1627 /*_________________D3DXVec2_____________________*/
1628
1629 D3DXVECTOR2* WINAPI D3DXVec2BaryCentric(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pv3, FLOAT f, FLOAT g)
1630 {
1631 TRACE("(%p, %p, %p, %p, %f, %f)\n", pout, pv1, pv2, pv3, f, g);
1632
1633 pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
1634 pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
1635 return pout;
1636 }
1637
1638 D3DXVECTOR2* WINAPI D3DXVec2CatmullRom(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv0, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pv3, FLOAT s)
1639 {
1640 TRACE("(%p, %p, %p, %p, %p, %f)\n", pout, pv0, pv1, pv2, pv3, s);
1641
1642 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);
1643 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);
1644 return pout;
1645 }
1646
1647 D3DXVECTOR2* WINAPI D3DXVec2Hermite(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pt1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pt2, FLOAT s)
1648 {
1649 FLOAT h1, h2, h3, h4;
1650
1651 TRACE("(%p, %p, %p, %p, %p, %f)\n", pout, pv1, pt1, pv2, pt2, s);
1652
1653 h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
1654 h2 = s * s * s - 2.0f * s * s + s;
1655 h3 = -2.0f * s * s * s + 3.0f * s * s;
1656 h4 = s * s * s - s * s;
1657
1658 pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
1659 pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
1660 return pout;
1661 }
1662
1663 D3DXVECTOR2* WINAPI D3DXVec2Normalize(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv)
1664 {
1665 FLOAT norm;
1666
1667 TRACE("(%p, %p)\n", pout, pv);
1668
1669 norm = D3DXVec2Length(pv);
1670 if ( !norm )
1671 {
1672 pout->x = 0.0f;
1673 pout->y = 0.0f;
1674 }
1675 else
1676 {
1677 pout->x = pv->x / norm;
1678 pout->y = pv->y / norm;
1679 }
1680
1681 return pout;
1682 }
1683
1684 D3DXVECTOR4* WINAPI D3DXVec2Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
1685 {
1686 TRACE("(%p, %p, %p)\n", pout, pv, pm);
1687
1688 pout->x = pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y + pm->u.m[3][0];
1689 pout->y = pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y + pm->u.m[3][1];
1690 pout->z = pm->u.m[0][2] * pv->x + pm->u.m[1][2] * pv->y + pm->u.m[3][2];
1691 pout->w = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y + pm->u.m[3][3];
1692 return pout;
1693 }
1694
1695 D3DXVECTOR4* WINAPI D3DXVec2TransformArray(D3DXVECTOR4* out, UINT outstride, CONST D3DXVECTOR2* in, UINT instride, CONST D3DXMATRIX* matrix, UINT elements)
1696 {
1697 UINT i;
1698
1699 TRACE("(%p, %u, %p, %u, %p, %u)\n", out, outstride, in, instride, matrix, elements);
1700
1701 for (i = 0; i < elements; ++i) {
1702 D3DXVec2Transform(
1703 (D3DXVECTOR4*)((char*)out + outstride * i),
1704 (CONST D3DXVECTOR2*)((const char*)in + instride * i),
1705 matrix);
1706 }
1707 return out;
1708 }
1709
1710 D3DXVECTOR2* WINAPI D3DXVec2TransformCoord(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
1711 {
1712 D3DXVECTOR2 v;
1713 FLOAT norm;
1714
1715 TRACE("(%p, %p, %p)\n", pout, pv, pm);
1716
1717 v = *pv;
1718 norm = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y + pm->u.m[3][3];
1719
1720 pout->x = (pm->u.m[0][0] * v.x + pm->u.m[1][0] * v.y + pm->u.m[3][0]) / norm;
1721 pout->y = (pm->u.m[0][1] * v.x + pm->u.m[1][1] * v.y + pm->u.m[3][1]) / norm;
1722
1723 return pout;
1724 }
1725
1726 D3DXVECTOR2* WINAPI D3DXVec2TransformCoordArray(D3DXVECTOR2* out, UINT outstride, CONST D3DXVECTOR2* in, UINT instride, CONST D3DXMATRIX* matrix, UINT elements)
1727 {
1728 UINT i;
1729
1730 TRACE("(%p, %u, %p, %u, %p, %u)\n", out, outstride, in, instride, matrix, elements);
1731
1732 for (i = 0; i < elements; ++i) {
1733 D3DXVec2TransformCoord(
1734 (D3DXVECTOR2*)((char*)out + outstride * i),
1735 (CONST D3DXVECTOR2*)((const char*)in + instride * i),
1736 matrix);
1737 }
1738 return out;
1739 }
1740
1741 D3DXVECTOR2* WINAPI D3DXVec2TransformNormal(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
1742 {
1743 CONST D3DXVECTOR2 v = *pv;
1744 pout->x = pm->u.m[0][0] * v.x + pm->u.m[1][0] * v.y;
1745 pout->y = pm->u.m[0][1] * v.x + pm->u.m[1][1] * v.y;
1746 return pout;
1747 }
1748
1749 D3DXVECTOR2* WINAPI D3DXVec2TransformNormalArray(D3DXVECTOR2* out, UINT outstride, CONST D3DXVECTOR2 *in, UINT instride, CONST D3DXMATRIX *matrix, UINT elements)
1750 {
1751 UINT i;
1752
1753 TRACE("(%p, %u, %p, %u, %p, %u)\n", out, outstride, in, instride, matrix, elements);
1754
1755 for (i = 0; i < elements; ++i) {
1756 D3DXVec2TransformNormal(
1757 (D3DXVECTOR2*)((char*)out + outstride * i),
1758 (CONST D3DXVECTOR2*)((const char*)in + instride * i),
1759 matrix);
1760 }
1761 return out;
1762 }
1763
1764 /*_________________D3DXVec3_____________________*/
1765
1766 D3DXVECTOR3* WINAPI D3DXVec3BaryCentric(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3, FLOAT f, FLOAT g)
1767 {
1768 TRACE("(%p, %p, %p, %p, %f, %f)\n", pout, pv1, pv2, pv3, f, g);
1769
1770 pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
1771 pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
1772 pout->z = (1.0f-f-g) * (pv1->z) + f * (pv2->z) + g * (pv3->z);
1773 return pout;
1774 }
1775
1776 D3DXVECTOR3* WINAPI D3DXVec3CatmullRom( D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv0, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3, FLOAT s)
1777 {
1778 TRACE("(%p, %p, %p, %p, %p, %f)\n", pout, pv0, pv1, pv2, pv3, s);
1779
1780 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);
1781 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);
1782 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);
1783 return pout;
1784 }
1785
1786 D3DXVECTOR3* WINAPI D3DXVec3Hermite(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pt1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pt2, FLOAT s)
1787 {
1788 FLOAT h1, h2, h3, h4;
1789
1790 TRACE("(%p, %p, %p, %p, %p, %f)\n", pout, pv1, pt1, pv2, pt2, s);
1791
1792 h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
1793 h2 = s * s * s - 2.0f * s * s + s;
1794 h3 = -2.0f * s * s * s + 3.0f * s * s;
1795 h4 = s * s * s - s * s;
1796
1797 pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
1798 pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
1799 pout->z = h1 * (pv1->z) + h2 * (pt1->z) + h3 * (pv2->z) + h4 * (pt2->z);
1800 return pout;
1801 }
1802
1803 D3DXVECTOR3* WINAPI D3DXVec3Normalize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv)
1804 {
1805 FLOAT norm;
1806
1807 TRACE("(%p, %p)\n", pout, pv);
1808
1809 norm = D3DXVec3Length(pv);
1810 if ( !norm )
1811 {
1812 pout->x = 0.0f;
1813 pout->y = 0.0f;
1814 pout->z = 0.0f;
1815 }
1816 else
1817 {
1818 pout->x = pv->x / norm;
1819 pout->y = pv->y / norm;
1820 pout->z = pv->z / norm;
1821 }
1822
1823 return pout;
1824 }
1825
1826 D3DXVECTOR3* WINAPI D3DXVec3Project(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DVIEWPORT9 *pviewport, CONST D3DXMATRIX *pprojection, CONST D3DXMATRIX *pview, CONST D3DXMATRIX *pworld)
1827 {
1828 D3DXMATRIX m;
1829
1830 TRACE("(%p, %p, %p, %p, %p, %p)\n", pout, pv, pviewport, pprojection, pview, pworld);
1831
1832 D3DXMatrixIdentity(&m);
1833 if (pworld) D3DXMatrixMultiply(&m, &m, pworld);
1834 if (pview) D3DXMatrixMultiply(&m, &m, pview);
1835 if (pprojection) D3DXMatrixMultiply(&m, &m, pprojection);
1836
1837 D3DXVec3TransformCoord(pout, pv, &m);
1838
1839 if (pviewport)
1840 {
1841 pout->x = pviewport->X + ( 1.0f + pout->x ) * pviewport->Width / 2.0f;
1842 pout->y = pviewport->Y + ( 1.0f - pout->y ) * pviewport->Height / 2.0f;
1843 pout->z = pviewport->MinZ + pout->z * ( pviewport->MaxZ - pviewport->MinZ );
1844 }
1845 return pout;
1846 }
1847
1848 D3DXVECTOR3* WINAPI D3DXVec3ProjectArray(D3DXVECTOR3* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride, CONST D3DVIEWPORT9* viewport, CONST D3DXMATRIX* projection, CONST D3DXMATRIX* view, CONST D3DXMATRIX* world, UINT elements)
1849 {
1850 UINT i;
1851
1852 TRACE("(%p, %u, %p, %u, %p, %p, %p, %p, %u)\n", out, outstride, in, instride, viewport, projection, view, world, elements);
1853
1854 for (i = 0; i < elements; ++i) {
1855 D3DXVec3Project(
1856 (D3DXVECTOR3*)((char*)out + outstride * i),
1857 (CONST D3DXVECTOR3*)((const char*)in + instride * i),
1858 viewport, projection, view, world);
1859 }
1860 return out;
1861 }
1862
1863 D3DXVECTOR4* WINAPI D3DXVec3Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
1864 {
1865 TRACE("(%p, %p, %p)\n", pout, pv, pm);
1866
1867 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];
1868 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];
1869 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];
1870 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];
1871 return pout;
1872 }
1873
1874 D3DXVECTOR4* WINAPI D3DXVec3TransformArray(D3DXVECTOR4* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride, CONST D3DXMATRIX* matrix, UINT elements)
1875 {
1876 UINT i;
1877
1878 TRACE("(%p, %u, %p, %u, %p, %u)\n", out, outstride, in, instride, matrix, elements);
1879
1880 for (i = 0; i < elements; ++i) {
1881 D3DXVec3Transform(
1882 (D3DXVECTOR4*)((char*)out + outstride * i),
1883 (CONST D3DXVECTOR3*)((const char*)in + instride * i),
1884 matrix);
1885 }
1886 return out;
1887 }
1888
1889 D3DXVECTOR3* WINAPI D3DXVec3TransformCoord(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
1890 {
1891 D3DXVECTOR3 out;
1892 FLOAT norm;
1893
1894 TRACE("(%p, %p, %p)\n", pout, pv, pm);
1895
1896 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];
1897
1898 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]) / norm;
1899 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]) / norm;
1900 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]) / norm;
1901
1902 *pout = out;
1903
1904 return pout;
1905 }
1906
1907 D3DXVECTOR3* WINAPI D3DXVec3TransformCoordArray(D3DXVECTOR3* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride, CONST D3DXMATRIX* matrix, UINT elements)
1908 {
1909 UINT i;
1910
1911 TRACE("(%p, %u, %p, %u, %p, %u)\n", out, outstride, in, instride, matrix, elements);
1912
1913 for (i = 0; i < elements; ++i) {
1914 D3DXVec3TransformCoord(
1915 (D3DXVECTOR3*)((char*)out + outstride * i),
1916 (CONST D3DXVECTOR3*)((const char*)in + instride * i),
1917 matrix);
1918 }
1919 return out;
1920 }
1921
1922 D3DXVECTOR3* WINAPI D3DXVec3TransformNormal(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
1923 {
1924 CONST D3DXVECTOR3 v = *pv;
1925
1926 TRACE("(%p, %p, %p)\n", pout, pv, pm);
1927
1928 pout->x = pm->u.m[0][0] * v.x + pm->u.m[1][0] * v.y + pm->u.m[2][0] * v.z;
1929 pout->y = pm->u.m[0][1] * v.x + pm->u.m[1][1] * v.y + pm->u.m[2][1] * v.z;
1930 pout->z = pm->u.m[0][2] * v.x + pm->u.m[1][2] * v.y + pm->u.m[2][2] * v.z;
1931 return pout;
1932
1933 }
1934
1935 D3DXVECTOR3* WINAPI D3DXVec3TransformNormalArray(D3DXVECTOR3* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride, CONST D3DXMATRIX* matrix, UINT elements)
1936 {
1937 UINT i;
1938
1939 TRACE("(%p, %u, %p, %u, %p, %u)\n", out, outstride, in, instride, matrix, elements);
1940
1941 for (i = 0; i < elements; ++i) {
1942 D3DXVec3TransformNormal(
1943 (D3DXVECTOR3*)((char*)out + outstride * i),
1944 (CONST D3DXVECTOR3*)((const char*)in + instride * i),
1945 matrix);
1946 }
1947 return out;
1948 }
1949
1950 D3DXVECTOR3* WINAPI D3DXVec3Unproject(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DVIEWPORT9 *pviewport, CONST D3DXMATRIX *pprojection, CONST D3DXMATRIX *pview, CONST D3DXMATRIX *pworld)
1951 {
1952 D3DXMATRIX m;
1953
1954 TRACE("(%p, %p, %p, %p, %p, %p)\n", pout, pv, pviewport, pprojection, pview, pworld);
1955
1956 D3DXMatrixIdentity(&m);
1957 if (pworld) D3DXMatrixMultiply(&m, &m, pworld);
1958 if (pview) D3DXMatrixMultiply(&m, &m, pview);
1959 if (pprojection) D3DXMatrixMultiply(&m, &m, pprojection);
1960 D3DXMatrixInverse(&m, NULL, &m);
1961
1962 *pout = *pv;
1963 if (pviewport)
1964 {
1965 pout->x = 2.0f * ( pout->x - pviewport->X ) / pviewport->Width - 1.0f;
1966 pout->y = 1.0f - 2.0f * ( pout->y - pviewport->Y ) / pviewport->Height;
1967 pout->z = ( pout->z - pviewport->MinZ) / ( pviewport->MaxZ - pviewport->MinZ );
1968 }
1969 D3DXVec3TransformCoord(pout, pout, &m);
1970 return pout;
1971 }
1972
1973 D3DXVECTOR3* WINAPI D3DXVec3UnprojectArray(D3DXVECTOR3* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride, CONST D3DVIEWPORT9* viewport, CONST D3DXMATRIX* projection, CONST D3DXMATRIX* view, CONST D3DXMATRIX* world, UINT elements)
1974 {
1975 UINT i;
1976
1977 TRACE("(%p, %u, %p, %u, %p, %p, %p, %p, %u)\n", out, outstride, in, instride, viewport, projection, view, world, elements);
1978
1979 for (i = 0; i < elements; ++i) {
1980 D3DXVec3Unproject(
1981 (D3DXVECTOR3*)((char*)out + outstride * i),
1982 (CONST D3DXVECTOR3*)((const char*)in + instride * i),
1983 viewport, projection, view, world);
1984 }
1985 return out;
1986 }
1987
1988 /*_________________D3DXVec4_____________________*/
1989
1990 D3DXVECTOR4* WINAPI D3DXVec4BaryCentric(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3, FLOAT f, FLOAT g)
1991 {
1992 TRACE("(%p, %p, %p, %p, %f, %f)\n", pout, pv1, pv2, pv3, f, g);
1993
1994 pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
1995 pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
1996 pout->z = (1.0f-f-g) * (pv1->z) + f * (pv2->z) + g * (pv3->z);
1997 pout->w = (1.0f-f-g) * (pv1->w) + f * (pv2->w) + g * (pv3->w);
1998 return pout;
1999 }
2000
2001 D3DXVECTOR4* WINAPI D3DXVec4CatmullRom(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv0, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3, FLOAT s)
2002 {
2003 TRACE("(%p, %p, %p, %p, %p, %f)\n", pout, pv0, pv1, pv2, pv3, s);
2004
2005 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);
2006 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);
2007 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);
2008 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);
2009 return pout;
2010 }
2011
2012 D3DXVECTOR4* WINAPI D3DXVec4Cross(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3)
2013 {
2014 D3DXVECTOR4 out;
2015
2016 TRACE("(%p, %p, %p, %p)\n", pout, pv1, pv2, pv3);
2017
2018 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);
2019 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));
2020 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);
2021 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));
2022 *pout = out;
2023 return pout;
2024 }
2025
2026 D3DXVECTOR4* WINAPI D3DXVec4Hermite(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pt1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pt2, FLOAT s)
2027 {
2028 FLOAT h1, h2, h3, h4;
2029
2030 TRACE("(%p, %p, %p, %p, %p, %f)\n", pout, pv1, pt1, pv2, pt2, s);
2031
2032 h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
2033 h2 = s * s * s - 2.0f * s * s + s;
2034 h3 = -2.0f * s * s * s + 3.0f * s * s;
2035 h4 = s * s * s - s * s;
2036
2037 pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
2038 pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
2039 pout->z = h1 * (pv1->z) + h2 * (pt1->z) + h3 * (pv2->z) + h4 * (pt2->z);
2040 pout->w = h1 * (pv1->w) + h2 * (pt1->w) + h3 * (pv2->w) + h4 * (pt2->w);
2041 return pout;
2042 }
2043
2044 D3DXVECTOR4* WINAPI D3DXVec4Normalize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv)
2045 {
2046 FLOAT norm;
2047
2048 TRACE("(%p, %p)\n", pout, pv);
2049
2050 norm = D3DXVec4Length(pv);
2051
2052 pout->x = pv->x / norm;
2053 pout->y = pv->y / norm;
2054 pout->z = pv->z / norm;
2055 pout->w = pv->w / norm;
2056
2057 return pout;
2058 }
2059
2060 D3DXVECTOR4* WINAPI D3DXVec4Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv, CONST D3DXMATRIX *pm)
2061 {
2062 D3DXVECTOR4 out;
2063
2064 TRACE("(%p, %p, %p)\n", pout, pv, pm);
2065
2066 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;
2067 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;
2068 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;
2069 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;
2070 *pout = out;
2071 return pout;
2072 }
2073
2074 D3DXVECTOR4* WINAPI D3DXVec4TransformArray(D3DXVECTOR4* out, UINT outstride, CONST D3DXVECTOR4* in, UINT instride, CONST D3DXMATRIX* matrix, UINT elements)
2075 {
2076 UINT i;
2077
2078 TRACE("(%p, %u, %p, %u, %p, %u)\n", out, outstride, in, instride, matrix, elements);
2079
2080 for (i = 0; i < elements; ++i) {
2081 D3DXVec4Transform(
2082 (D3DXVECTOR4*)((char*)out + outstride * i),
2083 (CONST D3DXVECTOR4*)((const char*)in + instride * i),
2084 matrix);
2085 }
2086 return out;
2087 }
2088
2089 unsigned short float_32_to_16(const float in)
2090 {
2091 int exp = 0, origexp;
2092 float tmp = fabs(in);
2093 int sign = (copysignf(1, in) < 0);
2094 unsigned int mantissa;
2095 unsigned short ret;
2096
2097 /* Deal with special numbers */
2098 if (isinf(in)) return (sign ? 0xffff : 0x7fff);
2099 if (isnan(in)) return (sign ? 0xffff : 0x7fff);
2100 if (in == 0.0f) return (sign ? 0x8000 : 0x0000);
2101
2102 if (tmp < powf(2, 10))
2103 {
2104 do
2105 {
2106 tmp *= 2.0f;
2107 exp--;
2108 } while (tmp < powf(2, 10));
2109 }
2110 else if (tmp >= powf(2, 11))
2111 {
2112 do
2113 {
2114 tmp /= 2.0f;
2115 exp++;
2116 } while (tmp >= powf(2, 11));
2117 }
2118
2119 exp += 10; /* Normalize the mantissa */
2120 exp += 15; /* Exponent is encoded with excess 15 */
2121
2122 origexp = exp;
2123
2124 mantissa = (unsigned int) tmp;
2125 if ((tmp - mantissa == 0.5f && mantissa % 2 == 1) || /* round half to even */
2126 (tmp - mantissa > 0.5f))
2127 {
2128 mantissa++; /* round to nearest, away from zero */
2129 }
2130 if (mantissa == 2048)
2131 {
2132 mantissa = 1024;
2133 exp++;
2134 }
2135
2136 if (exp > 31)
2137 {
2138 /* too big */
2139 ret = 0x7fff; /* INF */
2140 }
2141 else if (exp <= 0)
2142 {
2143 unsigned int rounding = 0;
2144
2145 /* Denormalized half float */
2146
2147 /* return 0x0000 (=0.0) for numbers too small to represent in half floats */
2148 if (exp < -11)
2149 return (sign ? 0x8000 : 0x0000);
2150
2151 exp = origexp;
2152
2153 /* the 13 extra bits from single precision are used for rounding */
2154 mantissa = (unsigned int)(tmp * powf(2, 13));
2155 mantissa >>= 1 - exp; /* denormalize */
2156
2157 mantissa -= ~(mantissa >> 13) & 1; /* round half to even */
2158 /* remove 13 least significant bits to get half float precision */
2159 mantissa >>= 12;
2160 rounding = mantissa & 1;
2161 mantissa >>= 1;
2162
2163 ret = mantissa + rounding;
2164 }
2165 else
2166 {
2167 ret = (exp << 10) | (mantissa & 0x3ff);
2168 }
2169
2170 ret |= ((sign ? 1 : 0) << 15); /* Add the sign */
2171 return ret;
2172 }
2173
2174 D3DXFLOAT16 *WINAPI D3DXFloat32To16Array(D3DXFLOAT16 *pout, CONST FLOAT *pin, UINT n)
2175 {
2176 unsigned int i;
2177
2178 TRACE("(%p, %p, %u)\n", pout, pin, n);
2179
2180 for (i = 0; i < n; ++i)
2181 {
2182 pout[i].value = float_32_to_16(pin[i]);
2183 }
2184
2185 return pout;
2186 }
2187
2188 /* Native d3dx9's D3DXFloat16to32Array lacks support for NaN and Inf. Specifically, e = 16 is treated as a
2189 * regular number - e.g., 0x7fff is converted to 131008.0 and 0xffff to -131008.0. */
2190 static inline float float_16_to_32(const unsigned short in)
2191 {
2192 const unsigned short s = (in & 0x8000);
2193 const unsigned short e = (in & 0x7C00) >> 10;
2194 const unsigned short m = in & 0x3FF;
2195 const float sgn = (s ? -1.0f : 1.0f);
2196
2197 if (e == 0)
2198 {
2199 if (m == 0) return sgn * 0.0f; /* +0.0 or -0.0 */
2200 else return sgn * powf(2, -14.0f) * (m / 1024.0f);
2201 }
2202 else
2203 {
2204 return sgn * powf(2, e - 15.0f) * (1.0f + (m / 1024.0f));
2205 }
2206 }
2207
2208 FLOAT *WINAPI D3DXFloat16To32Array(FLOAT *pout, CONST D3DXFLOAT16 *pin, UINT n)
2209 {
2210 unsigned int i;
2211
2212 TRACE("(%p, %p, %u)\n", pout, pin, n);
2213
2214 for (i = 0; i < n; ++i)
2215 {
2216 pout[i] = float_16_to_32(pin[i].value);
2217 }
2218
2219 return pout;
2220 }
2221
2222 /*_________________D3DXSH________________*/
2223
2224 FLOAT* WINAPI D3DXSHAdd(FLOAT *out, UINT order, const FLOAT *a, const FLOAT *b)
2225 {
2226 UINT i;
2227
2228 TRACE("out %p, order %u, a %p, b %p\n", out, order, a, b);
2229
2230 for (i = 0; i < order * order; i++)
2231 out[i] = a[i] + b[i];
2232
2233 return out;
2234 }
2235
2236 FLOAT WINAPI D3DXSHDot(UINT order, CONST FLOAT *a, CONST FLOAT *b)
2237 {
2238 FLOAT s;
2239 UINT i;
2240
2241 TRACE("order %u, a %p, b %p\n", order, a, b);
2242
2243 s = a[0] * b[0];
2244 for (i = 1; i < order * order; i++)
2245 s += a[i] * b[i];
2246
2247 return s;
2248 }
2249
2250 FLOAT* WINAPI D3DXSHEvalDirection(FLOAT *out, UINT order, CONST D3DXVECTOR3 *dir)
2251 {
2252
2253 TRACE("(%p, %u, %p)\n", out, order, dir);
2254
2255 if ( (order < D3DXSH_MINORDER) || (order > D3DXSH_MAXORDER) )
2256 return out;
2257
2258 out[0] = 0.5f / sqrt(D3DX_PI);
2259 out[1] = -0.5f / sqrt(D3DX_PI / 3.0f) * dir->y;
2260 out[2] = 0.5f / sqrt(D3DX_PI / 3.0f) * dir->z;
2261 out[3] = -0.5f / sqrt(D3DX_PI / 3.0f) * dir->x;
2262 if ( order == 2 )
2263 return out;
2264
2265 out[4] = 0.5f / sqrt(D3DX_PI / 15.0f) * dir->x * dir->y;
2266 out[5] = -0.5f / sqrt(D3DX_PI / 15.0f) * dir->y * dir->z;
2267 out[6] = 0.25f / sqrt(D3DX_PI / 5.0f) * ( 3.0f * dir->z * dir->z - 1.0f );
2268 out[7] = -0.5f / sqrt(D3DX_PI / 15.0f) * dir->x * dir->z;
2269 out[8] = 0.25f / sqrt(D3DX_PI / 15.0f) * ( dir->x * dir->x - dir->y * dir->y );
2270 if ( order == 3 )
2271 return out;
2272
2273 out[9] = -sqrt(70.0f / D3DX_PI) / 8.0f * dir->y * (3.0f * dir->x * dir->x - dir->y * dir->y );
2274 out[10] = sqrt(105.0f / D3DX_PI) / 2.0f * dir->x * dir->y * dir->z;
2275 out[11] = -sqrt(42.0 / D3DX_PI) / 8.0f * dir->y * ( -1.0f + 5.0f * dir->z * dir->z );
2276 out[12] = sqrt(7.0f / D3DX_PI) / 4.0f * dir->z * ( 5.0f * dir->z * dir->z - 3.0f );
2277 out[13] = sqrt(42.0 / D3DX_PI) / 8.0f * dir->x * ( 1.0f - 5.0f * dir->z * dir->z );
2278 out[14] = sqrt(105.0f / D3DX_PI) / 4.0f * dir->z * ( dir->x * dir->x - dir->y * dir->y );
2279 out[15] = -sqrt(70.0f / D3DX_PI) / 8.0f * dir->x * ( dir->x * dir->x - 3.0f * dir->y * dir->y );
2280 if ( order == 4 )
2281 return out;
2282
2283 out[16] = 0.75f * sqrt(35.0f / D3DX_PI) * dir->x * dir->y * (dir->x * dir->x - dir->y * dir->y );
2284 out[17] = 3.0f * dir->z * out[9];
2285 out[18] = 0.75f * sqrt(5.0f / D3DX_PI) * dir->x * dir->y * ( 7.0f * dir->z * dir->z - 1.0f );
2286 out[19] = 0.375f * sqrt(10.0f / D3DX_PI) * dir->y * dir->z * ( 3.0f - 7.0f * dir->z * dir->z );
2287 out[20] = 3.0f / ( 16.0f * sqrt(D3DX_PI) ) * ( 35.0f * dir->z * dir->z * dir->z * dir->z - 30.f * dir->z * dir->z + 3.0f );
2288 out[21] = 0.375f * sqrt(10.0f / D3DX_PI) * dir->x * dir->z * ( 3.0f - 7.0f * dir->z * dir->z );
2289 out[22] = 0.375f * sqrt(5.0f / D3DX_PI) * ( dir->x * dir->x - dir->y * dir->y ) * ( 7.0f * dir->z * dir->z - 1.0f);
2290 out[23] = 3.0 * dir->z * out[15];
2291 out[24] = 3.0f / 16.0f * sqrt(35.0f / D3DX_PI) * ( dir->x * dir->x * dir->x * dir->x- 6.0f * dir->x * dir->x * dir->y * dir->y + dir->y * dir->y * dir->y * dir->y );
2292 if ( order == 5 )
2293 return out;
2294
2295 out[25] = -3.0f/ 32.0f * sqrt(154.0f / D3DX_PI) * dir->y * ( 5.0f * dir->x * dir->x * dir->x * dir->x - 10.0f * dir->x * dir->x * dir->y * dir->y + dir->y * dir->y * dir->y * dir->y );
2296 out[26] = 0.75f * sqrt(385.0f / D3DX_PI) * dir->x * dir->y * dir->z * ( dir->x * dir->x - dir->y * dir->y );
2297 out[27] = sqrt(770.0f / D3DX_PI) / 32.0f * dir->y * ( 3.0f * dir->x * dir->x - dir->y * dir->y ) * ( 1.0f - 9.0f * dir->z * dir->z );
2298 out[28] = sqrt(1155.0f / D3DX_PI) / 4.0f * dir->x * dir->y * dir->z * ( 3.0f * dir->z * dir->z - 1.0f);
2299 out[29] = sqrt(165.0f / D3DX_PI) / 16.0f * dir->y * ( 14.0f * dir->z * dir->z - 21.0f * dir->z * dir->z * dir->z * dir->z - 1.0f );
2300 out[30] = sqrt(11.0f / D3DX_PI) / 16.0f * dir->z * ( 63.0f * dir->z * dir->z * dir->z * dir->z - 70.0f * dir->z * dir->z + 15.0f );
2301 out[31] = sqrt(165.0f / D3DX_PI) / 16.0f * dir->x * ( 14.0f * dir->z * dir->z - 21.0f * dir->z * dir->z * dir->z * dir->z - 1.0f );
2302 out[32] = sqrt(1155.0f / D3DX_PI) / 8.0f * dir->z * ( dir->x * dir->x - dir->y * dir->y ) * ( 3.0f * dir->z * dir->z - 1.0f );
2303 out[33] = sqrt(770.0f / D3DX_PI) / 32.0f * dir->x * ( dir->x * dir->x - 3.0f * dir->y * dir->y ) * ( 1.0f - 9.0f * dir->z * dir->z );
2304 out[34] = 3.0f / 16.0f * sqrt(385.0f / D3DX_PI) * dir->z * ( dir->x * dir->x * dir->x * dir->x - 6.0 * dir->x * dir->x * dir->y * dir->y + dir->y * dir->y * dir->y * dir->y );
2305 out[35] = -3.0f/ 32.0f * sqrt(154.0f / D3DX_PI) * dir->x * ( dir->x * dir->x * dir->x * dir->x - 10.0f * dir->x * dir->x * dir->y * dir->y + 5.0f * dir->y * dir->y * dir->y * dir->y );
2306
2307 return out;
2308 }
2309
2310 HRESULT WINAPI D3DXSHEvalDirectionalLight(UINT order, CONST D3DXVECTOR3 *dir, FLOAT Rintensity, FLOAT Gintensity, FLOAT Bintensity, FLOAT *Rout, FLOAT *Gout, FLOAT *Bout)
2311 {
2312 FLOAT s, temp;
2313 UINT j;
2314
2315 TRACE("Order %u, Vector %p, Red %f, Green %f, Blue %f, Rout %p, Gout %p, Bout %p\n", order, dir, Rintensity, Gintensity, Bintensity, Rout, Gout, Bout);
2316
2317 s = 0.75f;
2318 if ( order > 2 )
2319 s += 5.0f / 16.0f;
2320 if ( order > 4 )
2321 s -= 3.0f / 32.0f;
2322 s /= D3DX_PI;
2323
2324 D3DXSHEvalDirection(Rout, order, dir);
2325 for (j = 0; j < order * order; j++)
2326 {
2327 temp = Rout[j] / s;
2328
2329 Rout[j] = Rintensity * temp;
2330 if ( Gout )
2331 Gout[j] = Gintensity * temp;
2332 if ( Bout )
2333 Bout[j] = Bintensity * temp;
2334 }
2335
2336 return D3D_OK;
2337 }
2338
2339 FLOAT * WINAPI D3DXSHMultiply2(FLOAT *out, const FLOAT *a, const FLOAT *b)
2340 {
2341 FLOAT ta, tb;
2342
2343 TRACE("out %p, a %p, b %p\n", out, a, b);
2344
2345 ta = 0.28209479f * a[0];
2346 tb = 0.28209479f * b[0];
2347
2348 out[0] = 0.28209479f * D3DXSHDot(2, a, b);
2349 out[1] = ta * b[1] + tb * a[1];
2350 out[2] = ta * b[2] + tb * a[2];
2351 out[3] = ta * b[3] + tb * a[3];
2352
2353 return out;
2354 }
2355
2356 FLOAT * WINAPI D3DXSHMultiply3(FLOAT *out, const FLOAT *a, const FLOAT *b)
2357 {
2358 FLOAT t, ta, tb;
2359
2360 TRACE("out %p, a %p, b %p\n", out, a, b);
2361
2362 out[0] = 0.28209479f * a[0] * b[0];
2363
2364 ta = 0.28209479f * a[0] - 0.12615662f * a[6] - 0.21850968f * a[8];
2365 tb = 0.28209479f * b[0] - 0.12615662f * b[6] - 0.21850968f * b[8];
2366 out[1] = ta * b[1] + tb * a[1];
2367 t = a[1] * b[1];
2368 out[0] += 0.28209479f * t;
2369 out[6] = -0.12615662f * t;
2370 out[8] = -0.21850968f * t;
2371
2372 ta = 0.21850968f * a[5];
2373 tb = 0.21850968f * b[5];
2374 out[1] += ta * b[2] + tb * a[2];
2375 out[2] = ta * b[1] + tb * a[1];
2376 t = a[1] * b[2] +a[2] * b[1];
2377 out[5] = 0.21850968f * t;
2378
2379 ta = 0.21850968f * a[4];
2380 tb = 0.21850968f * b[4];
2381 out[1] += ta * b[3] + tb * a[3];
2382 out[3] = ta * b[1] + tb * a[1];
2383 t = a[1] * b[3] + a[3] * b[1];
2384 out[4] = 0.21850968f * t;
2385
2386 ta = 0.28209480f * a[0] + 0.25231326f * a[6];
2387 tb = 0.28209480f * b[0] + 0.25231326f * b[6];
2388 out[2] += ta * b[2] + tb * a[2];
2389 t = a[2] * b[2];
2390 out[0] += 0.28209480f * t;
2391 out[6] += 0.25231326f * t;
2392
2393 ta = 0.21850969f * a[7];
2394 tb = 0.21850969f * b[7];
2395 out[2] += ta * b[3] + tb * a[3];
2396 out[3] += ta * b[2] + tb * a[2];
2397 t = a[2] * b[3] + a[3] * b[2];
2398 out[7] = 0.21850969f * t;
2399
2400 ta = 0.28209479f * a[0] - 0.12615663f * a[6] + 0.21850969f * a[8];
2401 tb = 0.28209479f * b[0] - 0.12615663f * b[6] + 0.21850969f * b[8];
2402 out[3] += ta * b[3] + tb * a[3];
2403 t = a[3] * b[3];
2404 out[0] += 0.28209479f * t;
2405 out[6] -= 0.12615663f * t;
2406 out[8] += 0.21850969f * t;
2407
2408 ta = 0.28209479f * a[0] - 0.18022375f * a[6];
2409 tb = 0.28209479f * b[0] - 0.18022375f * b[6];
2410 out[4] += ta * b[4] + tb * a[4];
2411 t = a[4] * b[4];
2412 out[0] += 0.28209479f * t;
2413 out[6] -= 0.18022375f * t;
2414
2415 ta = 0.15607835f * a[7];
2416 tb = 0.15607835f * b[7];
2417 out[4] += ta * b[5] + tb * a[5];
2418 out[5] += ta * b[4] + tb * a[4];
2419 t = a[4] * b[5] + a[5] * b[4];
2420 out[7] += 0.15607834f * t;
2421
2422 ta = 0.28209479f * a[0] + 0.09011186 * a[6] - 0.15607835f * a[8];
2423 tb = 0.28209479f * b[0] + 0.09011186 * b[6] - 0.15607835f * b[8];
2424 out[5] += ta * b[5] + tb * a[5];
2425 t = a[5] * b[5];
2426 out[0] += 0.28209479f * t;
2427 out[6] += 0.09011186f * t;
2428 out[8] -= 0.15607835f * t;
2429
2430 ta = 0.28209480f * a[0];
2431 tb = 0.28209480f * b[0];
2432 out[6] += ta * b[6] + tb * a[6];
2433 t = a[6] * b[6];
2434 out[0] += 0.28209480f * t;
2435 out[6] += 0.18022376f * t;
2436
2437 ta = 0.28209479f * a[0] + 0.09011186 * a[6] + 0.15607835f * a[8];
2438 tb = 0.28209479f * b[0] + 0.09011186 * b[6] + 0.15607835f * b[8];
2439 out[7] += ta * b[7] + tb * a[7];
2440 t = a[7] * b[7];
2441 out[0] += 0.28209479f * t;
2442 out[6] += 0.09011186f * t;
2443 out[8] += 0.15607835f * t;
2444
2445 ta = 0.28209479f * a[0] - 0.18022375f * a[6];
2446 tb = 0.28209479f * b[0] - 0.18022375f * b[6];
2447 out[8] += ta * b[8] + tb * a[8];
2448 t = a[8] * b[8];
2449 out[0] += 0.28209479f * t;
2450 out[6] -= 0.18022375f * t;
2451
2452 return out;
2453 }
2454
2455 FLOAT * WINAPI D3DXSHMultiply4(FLOAT *out, CONST FLOAT *a, CONST FLOAT *b)
2456 {
2457 FLOAT ta, tb, t;
2458
2459 TRACE("out %p, a %p, b %p\n", out, a, b);
2460
2461 out[0] = 0.28209479f * a[0] * b[0];
2462
2463 ta = 0.28209479f * a[0] - 0.12615663f * a[6] - 0.21850969f * a[8];
2464 tb = 0.28209479f * b[0] - 0.12615663f * b[6] - 0.21850969f * b[8];
2465 out[1] = ta * b[1] + tb * a[1];
2466 t = a[1] * b[1];
2467 out[0] += 0.28209479f * t;
2468 out[6] = -0.12615663f * t;
2469 out[8] = -0.21850969f * t;
2470
2471 ta = 0.21850969f * a[3] - 0.05839917f * a[13] - 0.22617901f * a[15];
2472 tb = 0.21850969f * b[3] - 0.05839917f * b[13] - 0.22617901f * b[15];
2473 out[1] += ta * b[4] + tb * a[4];
2474 out[4] = ta * b[1] + tb * a[1];
2475 t = a[1] * b[4] + a[4] * b[1];
2476 out[3] = 0.21850969f * t;
2477 out[13] = -0.05839917f * t;
2478 out[15] = -0.22617901f * t;
2479
2480 ta = 0.21850969f * a[2] - 0.14304817f * a[12] - 0.18467439f * a[14];
2481 tb = 0.21850969f * b[2] - 0.14304817f * b[12] - 0.18467439f * b[14];
2482 out[1] += ta * b[5] + tb * a[5];
2483 out[5] = ta * b[1] + tb * a[1];
2484 t = a[1] * b[5] + a[5] * b[1];
2485 out[2] = 0.21850969f * t;
2486 out[12] = -0.14304817f * t;
2487 out[14] = -0.18467439f * t;
2488
2489 ta = 0.20230066f * a[11];
2490 tb = 0.20230066f * b[11];
2491 out[1] += ta * b[6] + tb * a[6];
2492 out[6] += ta * b[1] + tb * a[1];
2493 t = a[1] * b[6] + a[6] * b[1];
2494 out[11] = 0.20230066f * t;
2495
2496 ta = 0.22617901f * a[9] + 0.05839917f * a[11];
2497 tb = 0.22617901f * b[9] + 0.05839917f * b[11];
2498 out[1] += ta * b[8] + tb * a[8];
2499 out[8] += ta * b[1] + tb * a[1];
2500 t = a[1] * b[8] + a[8] * b[1];
2501 out[9] = 0.22617901f * t;
2502 out[11] += 0.05839917f * t;
2503
2504 ta = 0.28209480f * a[0] + 0.25231326f * a[6];
2505 tb = 0.28209480f * b[0] + 0.25231326f * b[6];
2506 out[2] += ta * b[2] + tb * a[2];
2507 t = a[2] * b[2];
2508 out[0] += 0.28209480f * t;
2509 out[6] += 0.25231326f * t;
2510
2511 ta = 0.24776671f * a[12];
2512 tb = 0.24776671f * b[12];
2513 out[2] += ta * b[6] + tb * a[6];
2514 out[6] += ta * b[2] + tb * a[2];
2515 t = a[2] * b[6] + a[6] * b[2];
2516 out[12] += 0.24776671f * t;
2517
2518 ta = 0.28209480f * a[0] - 0.12615663f * a[6] + 0.21850969f * a[8];
2519 tb = 0.28209480f * b[0] - 0.12615663f * b[6] + 0.21850969f * b[8];
2520 out[3] += ta * b[3] + tb * a[3];
2521 t = a[3] * b[3];
2522 out[0] += 0.28209480f * t;
2523 out[6] -= 0.12615663f * t;
2524 out[8] += 0.21850969f * t;
2525
2526 ta = 0.20230066f * a[13];
2527 tb = 0.20230066f * b[13];
2528 out[3] += ta * b[6] + tb * a[6];
2529 out[6] += ta * b[3] + tb * a[3];
2530 t = a[3] * b[6] + a[6] * b[3];
2531 out[13] += 0.20230066f * t;
2532
2533 ta = 0.21850969f * a[2] - 0.14304817f * a[12] + 0.18467439f * a[14];
2534 tb = 0.21850969f * b[2] - 0.14304817f * b[12] + 0.18467439f * b[14];
2535 out[3] += ta * b[7] + tb * a[7];
2536 out[7] = ta * b[3] + tb * a[3];
2537 t = a[3] * b[7] + a[7] * b[3];
2538 out[2] += 0.21850969f * t;
2539 out[12] -= 0.14304817f * t;
2540 out[14] += 0.18467439f * t;
2541
2542 ta = -0.05839917f * a[13] + 0.22617901f * a[15];
2543 tb = -0.05839917f * b[13] + 0.22617901f * b[15];
2544 out[3] += ta * b[8] + tb * a[8];
2545 out[8] += ta * b[3] + tb * a[3];
2546 t = a[3] * b[8] + a[8] * b[3];
2547 out[13] -= 0.05839917f * t;
2548 out[15] += 0.22617901f * t;
2549
2550 ta = 0.28209479f * a[0] - 0.18022375f * a[6];
2551 tb = 0.28209479f * b[0] - 0.18022375f * b[6];
2552 out[4] += ta * b[4] + tb * a[4];
2553 t = a[4] * b[4];
2554 out[0] += 0.28209479f * t;
2555 out[6] -= 0.18022375f * t;
2556
2557 ta = 0.15607835f * a[7];
2558 tb = 0.15607835f * b[7];
2559 out[4] += ta * b[5] + tb * a[5];
2560 out[5] += ta * b[4] + tb * a[4];
2561 t = a[4] * b[5] + a[5] * b[4];
2562 out[7] += 0.15607835f * t;
2563
2564 ta = 0.22617901f * a[3] - 0.09403160f * a[13];
2565 tb = 0.22617901f * b[3] - 0.09403160f * b[13];
2566 out[4] += ta * b[9] + tb * a[9];
2567 out[9] += ta * b[4] + tb * a[4];
2568 t = a[4] * b[9] + a[9] * b[4];
2569 out[3] += 0.22617901f * t;
2570 out[13] -= 0.09403160f * t;
2571
2572 ta = 0.18467439f * a[2] - 0.18806319f * a[12];
2573 tb = 0.18467439f * b[2] - 0.18806319f * b[12];
2574 out[4] += ta * b[10] + tb * a [10];
2575 out[10] = ta * b[4] + tb * a[4];
2576 t = a[4] * b[10] + a[10] * b[4];
2577 out[2] += 0.18467439f * t;
2578 out[12] -= 0.18806319f * t;
2579
2580 ta = -0.05839917f * a[3] + 0.14567312f * a[13] + 0.09403160f * a[15];
2581 tb = -0.05839917f * b[3] + 0.14567312f * b[13] + 0.09403160f * b[15];
2582 out[4] += ta * b[11] + tb * a[11];
2583 out[11] += ta * b[4] + tb * a[4];
2584 t = a[4] * b[11] + a[11] * b[4];
2585 out[3] -= 0.05839917f * t;
2586 out[13] += 0.14567312f * t;
2587 out[15] += 0.09403160f * t;
2588
2589 ta = 0.28209479f * a[0] + 0.09011186f * a[6] - 0.15607835f * a[8];
2590 tb = 0.28209479f * b[0] + 0.09011186f * b[6] - 0.15607835f * b[8];
2591 out[5] += ta * b[5] + tb * a[5];
2592 t = a[5] * b[5];
2593 out[0] += 0.28209479f * t;
2594 out[6] += 0.09011186f * t;
2595 out[8] -= 0.15607835f * t;
2596
2597 ta = 0.14867701f * a[14];
2598 tb = 0.14867701f * b[14];
2599 out[5] += ta * b[9] + tb * a[9];
2600 out[9] += ta * b[5] + tb * a[5];
2601 t = a[5] * b[9] + a[9] * b[5];
2602 out[14] += 0.14867701f * t;
2603
2604 ta = 0.18467439f * a[3] + 0.11516472f * a[13] - 0.14867701f * a[15];
2605 tb = 0.18467439f * b[3] + 0.11516472f * b[13] - 0.14867701f * b[15];
2606 out[5] += ta * b[10] + tb * a[10];
2607 out[10] += ta * b[5] + tb * a[5];
2608 t = a[5] * b[10] + a[10] * b[5];
2609 out[3] += 0.18467439f * t;
2610 out[13] += 0.11516472f * t;
2611 out[15] -= 0.14867701f * t;
2612
2613 ta = 0.23359668f * a[2] + 0.05947080f * a[12] - 0.11516472f * a[14];
2614 tb = 0.23359668f * b[2] + 0.05947080f * b[12] - 0.11516472f * b[14];
2615 out[5] += ta * b[11] + tb * a[11];
2616 out[11] += ta * b[5] + tb * a[5];
2617 t = a[5] * b[11] + a[11] * b[5];
2618 out[2] += 0.23359668f * t;
2619 out[12] += 0.05947080f * t;
2620 out[14] -= 0.11516472f * t;
2621
2622 ta = 0.28209479f * a[0];
2623 tb = 0.28209479f * b[0];
2624 out[6] += ta * b[6] + tb * a[6];
2625 t = a[6] * b[6];
2626 out[0] += 0.28209479f * t;
2627 out[6] += 0.18022376f * t;
2628
2629 ta = 0.09011186f * a[6] + 0.28209479f * a[0] + 0.15607835f * a[8];
2630 tb = 0.09011186f * b[6] + 0.28209479f * b[0] + 0.15607835f * b[8];
2631 out[7] += ta * b[7] + tb * a[7];
2632 t = a[7] * b[7];
2633 out[6] += 0.09011186f * t;
2634 out[0] += 0.28209479f * t;
2635 out[8] += 0.15607835f * t;
2636
2637 ta = 0.14867701f * a[9] + 0.18467439f * a[1] + 0.11516472f * a[11];
2638 tb = 0.14867701f * b[9] + 0.18467439f * b[1] + 0.11516472f * b[11];
2639 out[7] += ta * b[10] + tb * a[10];
2640 out[10] += ta * b[7] + tb * a[7];
2641 t = a[7] * b[10] + a[10] * b[7];
2642 out[9] += 0.14867701f * t;
2643 out[1] += 0.18467439f * t;
2644 out[11] += 0.11516472f * t;
2645
2646 ta = 0.05947080f * a[12] + 0.23359668f * a[2] + 0.11516472f * a[14];
2647 tb = 0.05947080f * b[12] + 0.23359668f * b[2] + 0.11516472f * b[14];
2648 out[7] += ta * b[13] + tb * a[13];
2649 out[13] += ta * b[7]+ tb * a[7];
2650 t = a[7] * b[13] + a[13] * b[7];
2651 out[12] += 0.05947080f * t;
2652 out[2] += 0.23359668f * t;
2653 out[14] += 0.11516472f * t;
2654
2655 ta = 0.14867701f * a[15];
2656 tb = 0.14867701f * b[15];
2657 out[7] += ta * b[14] + tb * a[14];
2658 out[14] += ta * b[7] + tb * a[7];
2659 t = a[7] * b[14] + a[14] * b[7];
2660 out[15] += 0.14867701f * t;
2661
2662 ta = 0.28209479f * a[0] - 0.18022375f * a[6];
2663 tb = 0.28209479f * b[0] - 0.18022375f * b[6];
2664 out[8] += ta * b[8] + tb * a[8];
2665 t = a[8] * b[8];
2666 out[0] += 0.28209479f * t;
2667 out[6] -= 0.18022375f * t;
2668
2669 ta = -0.09403160f * a[11];
2670 tb = -0.09403160f * b[11];
2671 out[8] += ta * b[9] + tb * a[9];
2672 out[9] += ta * b[8] + tb * a[8];
2673 t = a[8] * b[9] + a[9] * b[8];
2674 out[11] -= 0.09403160f * t;
2675
2676 ta = -0.09403160f * a[15];
2677 tb = -0.09403160f * b[15];
2678 out[8] += ta * b[13] + tb * a[13];
2679 out[13] += ta * b[8] + tb * a[8];
2680 t = a[8] * b[13] + a[13] * b[8];
2681 out[15] -= 0.09403160f * t;
2682
2683 ta = 0.18467439f * a[2] - 0.18806319f * a[12];
2684 tb = 0.18467439f * b[2] - 0.18806319f * b[12];
2685 out[8] += ta * b[14] + tb * a[14];
2686 out[14] += ta * b[8] + tb * a[8];
2687 t = a[8] * b[14] + a[14] * b[8];
2688 out[2] += 0.18467439f * t;
2689 out[12] -= 0.18806319f * t;
2690
2691 ta = -0.21026104f * a[6] + 0.28209479f * a[0];
2692 tb = -0.21026104f * b[6] + 0.28209479f * b[0];
2693 out[9] += ta * b[9] + tb * a[9];
2694 t = a[9] * b[9];
2695 out[6] -= 0.21026104f * t;
2696 out[0] += 0.28209479f * t;
2697
2698 ta = 0.28209479f * a[0];
2699 tb = 0.28209479f * b[0];
2700 out[10] += ta * b[10] + tb * a[10];
2701 t = a[10] * b[10];
2702 out[0] += 0.28209479f * t;
2703
2704 ta = 0.28209479f * a[0] + 0.12615663f * a[6] - 0.14567312f * a[8];
2705 tb = 0.28209479f * b[0] + 0.12615663f * b[6] - 0.14567312f * b[8];
2706 out[11] += ta * b[11] + tb * a[11];
2707 t = a[11] * b[11];
2708 out[0] += 0.28209479f * t;
2709 out[6] += 0.12615663f * t;
2710 out[8] -= 0.14567312f * t;
2711
2712 ta = 0.28209479f * a[0] + 0.16820885f * a[6];
2713 tb = 0.28209479f * b[0] + 0.16820885f * b[6];
2714 out[12] += ta * b[12] + tb * a[12];
2715 t = a[12] * b[12];
2716 out[0] += 0.28209479f * t;
2717 out[6] += 0.16820885f * t;
2718
2719 ta =0.28209479f * a[0] + 0.14567312f * a[8] + 0.12615663f * a[6];
2720 tb =0.28209479f * b[0] + 0.14567312f * b[8] + 0.12615663f * b[6];
2721 out[13] += ta * b[13] + tb * a[13];
2722 t = a[13] * b[13];
2723 out[0] += 0.28209479f * t;
2724 out[8] += 0.14567312f * t;
2725 out[6] += 0.12615663f * t;
2726
2727 ta = 0.28209479f * a[0];
2728 tb = 0.28209479f * b[0];
2729 out[14] += ta * b[14] + tb * a[14];
2730 t = a[14] * b[14];
2731 out[0] += 0.28209479f * t;
2732
2733 ta = 0.28209479f * a[0] - 0.21026104f * a[6];
2734 tb = 0.28209479f * b[0] - 0.21026104f * b[6];
2735 out[15] += ta * b[15] + tb * a[15];
2736 t = a[15] * b[15];
2737 out[0] += 0.28209479f * t;
2738 out[6] -= 0.21026104f * t;
2739
2740 return out;
2741 }
2742
2743 static void rotate_X(FLOAT *out, UINT order, FLOAT a, FLOAT *in)
2744 {
2745 out[0] = in[0];
2746
2747 out[1] = a * in[2];
2748 out[2] = -a * in[1];
2749 out[3] = in[3];
2750
2751 out[4] = a * in[7];
2752 out[5] = -in[5];
2753 out[6] = -0.5f * in[6] - 0.8660253882f * in[8];
2754 out[7] = -a * in[4];
2755 out[8] = -0.8660253882f * in[6] + 0.5f * in[8];
2756 out[9] = -a * 0.7905694842f * in[12] + a * 0.6123724580f * in[14];
2757
2758 out[10] = -in[10];
2759 out[11] = -a * 0.6123724580f * in[12] - a * 0.7905694842f * in[14];
2760 out[12] = a * 0.7905694842f * in[9] + a * 0.6123724580f * in[11];
2761 out[13] = -0.25f * in[13] - 0.9682458639f * in[15];
2762 out[14] = -a * 0.6123724580f * in[9] + a * 0.7905694842f * in[11];
2763 out[15] = -0.9682458639f * in[13] + 0.25f * in[15];
2764 if (order == 4)
2765 return;
2766
2767 out[16] = -a * 0.9354143739f * in[21] + a * 0.3535533845f * in[23];
2768 out[17] = -0.75f * in[17] + 0.6614378095f * in[19];
2769 out[18] = -a * 0.3535533845f * in[21] - a * 0.9354143739f * in[23];
2770 out[19] = 0.6614378095f * in[17] + 0.75f * in[19];
2771 out[20] = 0.375f * in[20] + 0.5590170026f * in[22] + 0.7395099998f * in[24];
2772 out[21] = a * 0.9354143739f * in[16] + a * 0.3535533845f * in[18];
2773 out[22] = 0.5590170026f * in[20] + 0.5f * in[22] - 0.6614378691f * in[24];
2774 out[23] = -a * 0.3535533845f * in[16] + a * 0.9354143739f * in[18];
2775 out[24] = 0.7395099998f * in[20] - 0.6614378691f * in[22] + 0.125f * in[24];
2776 if (order == 5)
2777 return;
2778
2779 out[25] = a * 0.7015607357f * in[30] - a * 0.6846531630f * in[32] + a * 0.1976423711f * in[34];
2780 out[26] = -0.5f * in[26] + 0.8660253882f * in[28];
2781 out[27] = a * 0.5229125023f * in[30] + a * 0.3061861992f * in[32] - a * 0.7954951525 * in[34];
2782 out[28] = 0.8660253882f * in[26] + 0.5f * in[28];
2783 out[29] = a * 0.4841229022f * in[30] + a * 0.6614378691f * in[32] + a * 0.5728219748f * in[34];
2784 out[30] = -a * 0.7015607357f * in[25] - a * 0.5229125023f * in[27] - a * 0.4841229022f * in[29];
2785 out[31] = 0.125f * in[31] + 0.4050463140f * in[33] + 0.9057110548f * in[35];
2786 out[32] = a * 0.6846531630f * in[25] - a * 0.3061861992f * in[27] - a * 0.6614378691f * in[29];
2787 out[33] = 0.4050463140f * in[31] + 0.8125f * in[33] - 0.4192627370f * in[35];
2788 out[34] = -a * 0.1976423711f * in[25] + a * 0.7954951525f * in[27] - a * 0.5728219748f * in[29];
2789 out[35] = 0.9057110548f * in[31] - 0.4192627370f * in[33] + 0.0624999329f * in[35];
2790 }
2791
2792 FLOAT* WINAPI D3DXSHRotate(FLOAT *out, UINT order, CONST D3DXMATRIX *matrix, CONST FLOAT *in)
2793 {
2794 FLOAT alpha, beta, gamma, sinb, temp[36], temp1[36];
2795
2796 TRACE("out %p, order %u, matrix %p, in %p\n", out, order, matrix, in);
2797
2798 out[0] = in[0];
2799
2800 if ((order > D3DXSH_MAXORDER) || (order < D3DXSH_MINORDER))
2801 return out;
2802
2803 if (order <= 3)
2804 {
2805 out[1] = matrix->u.m[1][1] * in[1] - matrix->u.m[2][1] * in[2] + matrix->u.m[0][1] * in[3];
2806 out[2] = -matrix->u.m[1][2] * in[1] + matrix->u.m[2][2] * in[2] - matrix->u.m[0][2] * in[3];
2807 out[3] = matrix->u.m[1][0] * in[1] - matrix->u.m[2][0] * in[2] + matrix->u.m[0][0] * in[3];
2808
2809 if (order == 3)
2810 {
2811 FLOAT coeff[]={
2812 matrix->u.m[1][0] * matrix->u.m[0][0], matrix->u.m[1][1] * matrix->u.m[0][1],
2813 matrix->u.m[1][1] * matrix->u.m[2][1], matrix->u.m[1][0] * matrix->u.m[2][0],
2814 matrix->u.m[2][0] * matrix->u.m[2][0], matrix->u.m[2][1] * matrix->u.m[2][1],
2815 matrix->u.m[0][0] * matrix->u.m[2][0], matrix->u.m[0][1] * matrix->u.m[2][1],
2816 matrix->u.m[0][1] * matrix->u.m[0][1], matrix->u.m[1][0] * matrix->u.m[1][0],
2817 matrix->u.m[1][1] * matrix->u.m[1][1], matrix->u.m[0][0] * matrix->u.m[0][0], };
2818
2819 out[4] = (matrix->u.m[1][1] * matrix->u.m[0][0] + matrix->u.m[0][1] * matrix->u.m[1][0]) * in[4];
2820 out[4] -= (matrix->u.m[1][0] * matrix->u.m[2][1] + matrix->u.m[1][1] * matrix->u.m[2][0]) * in[5];
2821 out[4] += 1.7320508076f * matrix->u.m[2][0] * matrix->u.m[2][1] * in[6];
2822 out[4] -= (matrix->u.m[0][1] * matrix->u.m[2][0] + matrix->u.m[0][0] * matrix->u.m[2][1]) * in[7];
2823 out[4] += (matrix->u.m[0][0] * matrix->u.m[0][1] - matrix->u.m[1][0] * matrix->u.m[1][1]) * in[8];
2824
2825 out[5] = (matrix->u.m[1][1] * matrix->u.m[2][2] + matrix->u.m[1][2] * matrix->u.m[2][1]) * in[5];
2826 out[5] -= (matrix->u.m[1][1] * matrix->u.m[0][2] + matrix->u.m[1][2] * matrix->u.m[0][1]) * in[4];
2827 out[5] -= 1.7320508076f * matrix->u.m[2][2] * matrix->u.m[2][1] * in[6];
2828 out[5] += (matrix->u.m[0][2] * matrix->u.m[2][1] + matrix->u.m[0][1] * matrix->u.m[2][2]) * in[7];
2829 out[5] -= (matrix->u.m[0][1] * matrix->u.m[0][2] - matrix->u.m[1][1] * matrix->u.m[1][2]) * in[8];
2830
2831 out[6] = (matrix->u.m[2][2] * matrix->u.m[2][2] - 0.5f * (coeff[4] + coeff[5])) * in[6];
2832 out[6] -= (0.5773502692f * (coeff[0] + coeff[1]) - 1.1547005384f * matrix->u.m[1][2] * matrix->u.m[0][2]) * in[4];
2833 out[6] += (0.5773502692f * (coeff[2] + coeff[3]) - 1.1547005384f * matrix->u.m[1][2] * matrix->u.m[2][2]) * in[5];
2834 out[6] += (0.5773502692f * (coeff[6] + coeff[7]) - 1.1547005384f * matrix->u.m[0][2] * matrix->u.m[2][2]) * in[7];
2835 out[6] += (0.2886751347f * (coeff[9] - coeff[8] + coeff[10] - coeff[11]) - 0.5773502692f *
2836 (matrix->u.m[1][2] * matrix->u.m[1][2] - matrix->u.m[0][2] * matrix->u.m[0][2])) * in[8];
2837
2838 out[7] = (matrix->u.m[0][0] * matrix->u.m[2][2] + matrix->u.m[0][2] * matrix->u.m[2][0]) * in[7];
2839 out[7] -= (matrix->u.m[1][0] * matrix->u.m[0][2] + matrix->u.m[1][2] * matrix->u.m[0][0]) * in[4];
2840 out[7] += (matrix->u.m[1][0] * matrix->u.m[2][2] + matrix->u.m[1][2] * matrix->u.m[2][0]) * in[5];
2841 out[7] -= 1.7320508076f * matrix->u.m[2][2] * matrix->u.m[2][0] * in[6];
2842 out[7] -= (matrix->u.m[0][0] * matrix->u.m[0][2] - matrix->u.m[1][0] * matrix->u.m[1][2]) * in[8];
2843
2844 out[8] = 0.5f * (coeff[11] - coeff[8] - coeff[9] + coeff[10]) * in[8];
2845 out[8] += (coeff[0] - coeff[1]) * in[4];
2846 out[8] += (coeff[2] - coeff[3]) * in[5];
2847 out[8] += 0.86602540f * (coeff[4] - coeff[5]) * in[6];
2848 out[8] += (coeff[7] - coeff[6]) * in[7];
2849 }
2850
2851 return out;
2852 }
2853
2854 if (fabsf(matrix->u.m[2][2]) != 1.0f)
2855 {
2856 sinb = sqrtf(1.0f - matrix->u.m[2][2] * matrix->u.m[2][2]);
2857 alpha = atan2f(matrix->u.m[2][1] / sinb, matrix->u.m[2][0] / sinb);
2858 beta = atan2f(sinb, matrix->u.m[2][2]);
2859 gamma = atan2f(matrix->u.m[1][2] / sinb, -matrix->u.m[0][2] / sinb);
2860 }
2861 else
2862 {
2863 alpha = atan2f(matrix->u.m[0][1], matrix->u.m[0][0]);
2864 beta = 0.0f;
2865 gamma = 0.0f;
2866 }
2867
2868 D3DXSHRotateZ(temp, order, gamma, in);
2869 rotate_X(temp1, order, 1.0f, temp);
2870 D3DXSHRotateZ(temp, order, beta, temp1);
2871 rotate_X(temp1, order, -1.0f, temp);
2872 D3DXSHRotateZ(out, order, alpha, temp1);
2873
2874 return out;
2875 }
2876
2877 FLOAT * WINAPI D3DXSHRotateZ(FLOAT *out, UINT order, FLOAT angle, const FLOAT *in)
2878 {
2879 UINT i, sum = 0;
2880 FLOAT c[5], s[5];
2881
2882 TRACE("out %p, order %u, angle %f, in %p\n", out, order, angle, in);
2883
2884 order = min(max(order, D3DXSH_MINORDER), D3DXSH_MAXORDER);
2885
2886 out[0] = in[0];
2887
2888 for (i = 1; i < order; i++)
2889 {
2890 UINT j;
2891
2892 c[i - 1] = cosf(i * angle);
2893 s[i - 1] = sinf(i * angle);
2894 sum += i * 2;
2895
2896 out[sum - i] = c[i - 1] * in[sum - i];
2897 out[sum - i] += s[i - 1] * in[sum + i];
2898 for (j = i - 1; j > 0; j--)
2899 {
2900 out[sum - j] = 0.0f;
2901 out[sum - j] = c[j - 1] * in[sum - j];
2902 out[sum - j] += s[j - 1] * in[sum + j];
2903 }
2904
2905 if (in == out)
2906 out[sum] = 0.0f;
2907 else
2908 out[sum] = in[sum];
2909
2910 for (j = 1; j < i; j++)
2911 {
2912 out[sum + j] = 0.0f;
2913 out[sum + j] = -s[j - 1] * in[sum - j];
2914 out[sum + j] += c[j - 1] * in[sum + j];
2915 }
2916 out[sum + i] = -s[i - 1] * in[sum - i];
2917 out[sum + i] += c[i - 1] * in[sum + i];
2918 }
2919
2920 return out;
2921 }
2922
2923 FLOAT* WINAPI D3DXSHScale(FLOAT *out, UINT order, CONST FLOAT *a, CONST FLOAT scale)
2924 {
2925 UINT i;
2926
2927 TRACE("out %p, order %u, a %p, scale %f\n", out, order, a, scale);
2928
2929 for (i = 0; i < order * order; i++)
2930 out[i] = a[i] * scale;
2931
2932 return out;
2933 }
Windows API implementation