?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winex11: Maintain a separate copy of the surface image bits when we need byte swapping.
[wine.git] / dlls / d3dx9_36 / math.c
blob73bca458977fc9c7ea299b4b68b853ccdaa71f39
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 *pout, FLOAT yaw, FLOAT pitch, FLOAT roll)
635 {
636 D3DXMATRIX m;
637
638 TRACE("(%p, %f, %f, %f)\n", pout, yaw, pitch, roll);
639
640 D3DXMatrixIdentity(pout);
641 D3DXMatrixRotationZ(&m, roll);
642 D3DXMatrixMultiply(pout, pout, &m);
643 D3DXMatrixRotationX(&m, pitch);
644 D3DXMatrixMultiply(pout, pout, &m);
645 D3DXMatrixRotationY(&m, yaw);
646 D3DXMatrixMultiply(pout, pout, &m);
647 return pout;
648 }
649
650 D3DXMATRIX* WINAPI D3DXMatrixRotationZ(D3DXMATRIX *pout, FLOAT angle)
651 {
652 TRACE("(%p, %f)\n", pout, angle);
653
654 D3DXMatrixIdentity(pout);
655 pout->u.m[0][0] = cos(angle);
656 pout->u.m[1][1] = cos(angle);
657 pout->u.m[0][1] = sin(angle);
658 pout->u.m[1][0] = -sin(angle);
659 return pout;
660 }
661
662 D3DXMATRIX* WINAPI D3DXMatrixScaling(D3DXMATRIX *pout, FLOAT sx, FLOAT sy, FLOAT sz)
663 {
664 TRACE("(%p, %f, %f, %f)\n", pout, sx, sy, sz);
665
666 D3DXMatrixIdentity(pout);
667 pout->u.m[0][0] = sx;
668 pout->u.m[1][1] = sy;
669 pout->u.m[2][2] = sz;
670 return pout;
671 }
672
673 D3DXMATRIX* WINAPI D3DXMatrixShadow(D3DXMATRIX *pout, CONST D3DXVECTOR4 *plight, CONST D3DXPLANE *pplane)
674 {
675 D3DXPLANE Nplane;
676 FLOAT dot;
677
678 TRACE("(%p, %p, %p)\n", pout, plight, pplane);
679
680 D3DXPlaneNormalize(&Nplane, pplane);
681 dot = D3DXPlaneDot(&Nplane, plight);
682 pout->u.m[0][0] = dot - Nplane.a * plight->x;
683 pout->u.m[0][1] = -Nplane.a * plight->y;
684 pout->u.m[0][2] = -Nplane.a * plight->z;
685 pout->u.m[0][3] = -Nplane.a * plight->w;
686 pout->u.m[1][0] = -Nplane.b * plight->x;
687 pout->u.m[1][1] = dot - Nplane.b * plight->y;
688 pout->u.m[1][2] = -Nplane.b * plight->z;
689 pout->u.m[1][3] = -Nplane.b * plight->w;
690 pout->u.m[2][0] = -Nplane.c * plight->x;
691 pout->u.m[2][1] = -Nplane.c * plight->y;
692 pout->u.m[2][2] = dot - Nplane.c * plight->z;
693 pout->u.m[2][3] = -Nplane.c * plight->w;
694 pout->u.m[3][0] = -Nplane.d * plight->x;
695 pout->u.m[3][1] = -Nplane.d * plight->y;
696 pout->u.m[3][2] = -Nplane.d * plight->z;
697 pout->u.m[3][3] = dot - Nplane.d * plight->w;
698 return pout;
699 }
700
701 D3DXMATRIX* WINAPI D3DXMatrixTransformation(D3DXMATRIX *pout, CONST D3DXVECTOR3 *pscalingcenter, CONST D3DXQUATERNION *pscalingrotation, CONST D3DXVECTOR3 *pscaling, CONST D3DXVECTOR3 *protationcenter, CONST D3DXQUATERNION *protation, CONST D3DXVECTOR3 *ptranslation)
702 {
703 D3DXMATRIX m1, m2, m3, m4, m5, m6, m7;
704 D3DXQUATERNION prc;
705 D3DXVECTOR3 psc, pt;
706
707 TRACE("(%p, %p, %p, %p, %p, %p, %p)\n", pout, pscalingcenter, pscalingrotation, pscaling, protationcenter, protation, ptranslation);
708
709 if ( !pscalingcenter )
710 {
711 psc.x = 0.0f;
712 psc.y = 0.0f;
713 psc.z = 0.0f;
714 }
715 else
716 {
717 psc.x = pscalingcenter->x;
718 psc.y = pscalingcenter->y;
719 psc.z = pscalingcenter->z;
720 }
721
722 if ( !protationcenter )
723 {
724 prc.x = 0.0f;
725 prc.y = 0.0f;
726 prc.z = 0.0f;
727 }
728 else
729 {
730 prc.x = protationcenter->x;
731 prc.y = protationcenter->y;
732 prc.z = protationcenter->z;
733 }
734
735 if ( !ptranslation )
736 {
737 pt.x = 0.0f;
738 pt.y = 0.0f;
739 pt.z = 0.0f;
740 }
741 else
742 {
743 pt.x = ptranslation->x;
744 pt.y = ptranslation->y;
745 pt.z = ptranslation->z;
746 }
747
748 D3DXMatrixTranslation(&m1, -psc.x, -psc.y, -psc.z);
749
750 if ( !pscalingrotation )
751 {
752 D3DXMatrixIdentity(&m2);
753 D3DXMatrixIdentity(&m4);
754 }
755 else
756 {
757 D3DXMatrixRotationQuaternion(&m4, pscalingrotation);
758 D3DXMatrixInverse(&m2, NULL, &m4);
759 }
760
761 if ( !pscaling ) D3DXMatrixIdentity(&m3);
762 else D3DXMatrixScaling(&m3, pscaling->x, pscaling->y, pscaling->z);
763
764 if ( !protation ) D3DXMatrixIdentity(&m6);
765 else D3DXMatrixRotationQuaternion(&m6, protation);
766
767 D3DXMatrixTranslation(&m5, psc.x - prc.x, psc.y - prc.y, psc.z - prc.z);
768 D3DXMatrixTranslation(&m7, prc.x + pt.x, prc.y + pt.y, prc.z + pt.z);
769 D3DXMatrixMultiply(&m1, &m1, &m2);
770 D3DXMatrixMultiply(&m1, &m1, &m3);
771 D3DXMatrixMultiply(&m1, &m1, &m4);
772 D3DXMatrixMultiply(&m1, &m1, &m5);
773 D3DXMatrixMultiply(&m1, &m1, &m6);
774 D3DXMatrixMultiply(pout, &m1, &m7);
775 return pout;
776 }
777
778 D3DXMATRIX* WINAPI D3DXMatrixTransformation2D(D3DXMATRIX *pout, CONST D3DXVECTOR2 *pscalingcenter, FLOAT scalingrotation, CONST D3DXVECTOR2 *pscaling, CONST D3DXVECTOR2 *protationcenter, FLOAT rotation, CONST D3DXVECTOR2 *ptranslation)
779 {
780 D3DXQUATERNION rot, sca_rot;
781 D3DXVECTOR3 rot_center, sca, sca_center, trans;
782
783 TRACE("(%p, %p, %f, %p, %p, %f, %p)\n", pout, pscalingcenter, scalingrotation, pscaling, protationcenter, rotation, ptranslation);
784
785 if ( pscalingcenter )
786 {
787 sca_center.x=pscalingcenter->x;
788 sca_center.y=pscalingcenter->y;
789 sca_center.z=0.0f;
790 }
791 else
792 {
793 sca_center.x=0.0f;
794 sca_center.y=0.0f;
795 sca_center.z=0.0f;
796 }
797
798 if ( pscaling )
799 {
800 sca.x=pscaling->x;
801 sca.y=pscaling->y;
802 sca.z=1.0f;
803 }
804 else
805 {
806 sca.x=1.0f;
807 sca.y=1.0f;
808 sca.z=1.0f;
809 }
810
811 if ( protationcenter )
812 {
813 rot_center.x=protationcenter->x;
814 rot_center.y=protationcenter->y;
815 rot_center.z=0.0f;
816 }
817 else
818 {
819 rot_center.x=0.0f;
820 rot_center.y=0.0f;
821 rot_center.z=0.0f;
822 }
823
824 if ( ptranslation )
825 {
826 trans.x=ptranslation->x;
827 trans.y=ptranslation->y;
828 trans.z=0.0f;
829 }
830 else
831 {
832 trans.x=0.0f;
833 trans.y=0.0f;
834 trans.z=0.0f;
835 }
836
837 rot.w=cos(rotation/2.0f);
838 rot.x=0.0f;
839 rot.y=0.0f;
840 rot.z=sin(rotation/2.0f);
841
842 sca_rot.w=cos(scalingrotation/2.0f);
843 sca_rot.x=0.0f;
844 sca_rot.y=0.0f;
845 sca_rot.z=sin(scalingrotation/2.0f);
846
847 D3DXMatrixTransformation(pout, &sca_center, &sca_rot, &sca, &rot_center, &rot, &trans);
848
849 return pout;
850 }
851
852 D3DXMATRIX* WINAPI D3DXMatrixTranslation(D3DXMATRIX *pout, FLOAT x, FLOAT y, FLOAT z)
853 {
854 TRACE("(%p, %f, %f, %f)\n", pout, x, y, z);
855
856 D3DXMatrixIdentity(pout);
857 pout->u.m[3][0] = x;
858 pout->u.m[3][1] = y;
859 pout->u.m[3][2] = z;
860 return pout;
861 }
862
863 D3DXMATRIX* WINAPI D3DXMatrixTranspose(D3DXMATRIX *pout, CONST D3DXMATRIX *pm)
864 {
865 CONST D3DXMATRIX m = *pm;
866 int i,j;
867
868 TRACE("(%p, %p)\n", pout, pm);
869
870 for (i=0; i<4; i++)
871 for (j=0; j<4; j++) pout->u.m[i][j] = m.u.m[j][i];
872
873 return pout;
874 }
875
876 /*_________________D3DXMatrixStack____________________*/
877
878 static const unsigned int INITIAL_STACK_SIZE = 32;
879
880 HRESULT WINAPI D3DXCreateMatrixStack(DWORD flags, LPD3DXMATRIXSTACK *ppstack)
881 {
882 struct ID3DXMatrixStackImpl *object;
883
884 TRACE("flags %#x, ppstack %p\n", flags, ppstack);
885
886 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
887 if (object == NULL)
888 {
889 *ppstack = NULL;
890 return E_OUTOFMEMORY;
891 }
892 object->ID3DXMatrixStack_iface.lpVtbl = &ID3DXMatrixStack_Vtbl;
893 object->ref = 1;
894
895 object->stack = HeapAlloc(GetProcessHeap(), 0, INITIAL_STACK_SIZE * sizeof(*object->stack));
896 if (!object->stack)
897 {
898 HeapFree(GetProcessHeap(), 0, object);
899 *ppstack = NULL;
900 return E_OUTOFMEMORY;
901 }
902
903 object->current = 0;
904 object->stack_size = INITIAL_STACK_SIZE;
905 D3DXMatrixIdentity(&object->stack[0]);
906
907 TRACE("Created matrix stack %p\n", object);
908
909 *ppstack = &object->ID3DXMatrixStack_iface;
910 return D3D_OK;
911 }
912
913 static inline struct ID3DXMatrixStackImpl *impl_from_ID3DXMatrixStack(ID3DXMatrixStack *iface)
914 {
915 return CONTAINING_RECORD(iface, struct ID3DXMatrixStackImpl, ID3DXMatrixStack_iface);
916 }
917
918 static HRESULT WINAPI ID3DXMatrixStackImpl_QueryInterface(ID3DXMatrixStack *iface, REFIID riid, void **out)
919 {
920 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
921
922 if (IsEqualGUID(riid, &IID_ID3DXMatrixStack)
923 || IsEqualGUID(riid, &IID_IUnknown))
924 {
925 ID3DXMatrixStack_AddRef(iface);
926 *out = iface;
927 return S_OK;
928 }
929
930 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
931
932 *out = NULL;
933 return E_NOINTERFACE;
934 }
935
936 static ULONG WINAPI ID3DXMatrixStackImpl_AddRef(ID3DXMatrixStack *iface)
937 {
938 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
939 ULONG ref = InterlockedIncrement(&This->ref);
940 TRACE("(%p) : AddRef from %d\n", This, ref - 1);
941 return ref;
942 }
943
944 static ULONG WINAPI ID3DXMatrixStackImpl_Release(ID3DXMatrixStack *iface)
945 {
946 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
947 ULONG ref = InterlockedDecrement(&This->ref);
948 if (!ref)
949 {
950 HeapFree(GetProcessHeap(), 0, This->stack);
951 HeapFree(GetProcessHeap(), 0, This);
952 }
953 TRACE("(%p) : ReleaseRef to %d\n", This, ref);
954 return ref;
955 }
956
957 static D3DXMATRIX* WINAPI ID3DXMatrixStackImpl_GetTop(ID3DXMatrixStack *iface)
958 {
959 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
960
961 TRACE("iface %p\n", iface);
962
963 return &This->stack[This->current];
964 }
965
966 static HRESULT WINAPI ID3DXMatrixStackImpl_LoadIdentity(ID3DXMatrixStack *iface)
967 {
968 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
969
970 TRACE("iface %p\n", iface);
971
972 D3DXMatrixIdentity(&This->stack[This->current]);
973
974 return D3D_OK;
975 }
976
977 static HRESULT WINAPI ID3DXMatrixStackImpl_LoadMatrix(ID3DXMatrixStack *iface, CONST D3DXMATRIX *pm)
978 {
979 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
980
981 TRACE("iface %p\n", iface);
982
983 This->stack[This->current] = *pm;
984
985 return D3D_OK;
986 }
987
988 static HRESULT WINAPI ID3DXMatrixStackImpl_MultMatrix(ID3DXMatrixStack *iface, CONST D3DXMATRIX *pm)
989 {
990 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
991
992 TRACE("iface %p\n", iface);
993
994 D3DXMatrixMultiply(&This->stack[This->current], &This->stack[This->current], pm);
995
996 return D3D_OK;
997 }
998
999 static HRESULT WINAPI ID3DXMatrixStackImpl_MultMatrixLocal(ID3DXMatrixStack *iface, CONST D3DXMATRIX *pm)
1000 {
1001 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1002
1003 TRACE("iface %p\n", iface);
1004
1005 D3DXMatrixMultiply(&This->stack[This->current], pm, &This->stack[This->current]);
1006
1007 return D3D_OK;
1008 }
1009
1010 static HRESULT WINAPI ID3DXMatrixStackImpl_Pop(ID3DXMatrixStack *iface)
1011 {
1012 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1013
1014 TRACE("iface %p\n", iface);
1015
1016 /* Popping the last element on the stack returns D3D_OK, but does nothing. */
1017 if (!This->current) return D3D_OK;
1018
1019 if (This->current <= This->stack_size / 4 && This->stack_size >= INITIAL_STACK_SIZE * 2)
1020 {
1021 unsigned int new_size;
1022 D3DXMATRIX *new_stack;
1023
1024 new_size = This->stack_size / 2;
1025 new_stack = HeapReAlloc(GetProcessHeap(), 0, This->stack, new_size * sizeof(*new_stack));
1026 if (new_stack)
1027 {
1028 This->stack_size = new_size;
1029 This->stack = new_stack;
1030 }
1031 }
1032
1033 --This->current;
1034
1035 return D3D_OK;
1036 }
1037
1038 static HRESULT WINAPI ID3DXMatrixStackImpl_Push(ID3DXMatrixStack *iface)
1039 {
1040 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1041
1042 TRACE("iface %p\n", iface);
1043
1044 if (This->current == This->stack_size - 1)
1045 {
1046 unsigned int new_size;
1047 D3DXMATRIX *new_stack;
1048
1049 if (This->stack_size > UINT_MAX / 2) return E_OUTOFMEMORY;
1050
1051 new_size = This->stack_size * 2;
1052 new_stack = HeapReAlloc(GetProcessHeap(), 0, This->stack, new_size * sizeof(*new_stack));
1053 if (!new_stack) return E_OUTOFMEMORY;
1054
1055 This->stack_size = new_size;
1056 This->stack = new_stack;
1057 }
1058
1059 ++This->current;
1060 This->stack[This->current] = This->stack[This->current - 1];
1061
1062 return D3D_OK;
1063 }
1064
1065 static HRESULT WINAPI ID3DXMatrixStackImpl_RotateAxis(ID3DXMatrixStack *iface, CONST D3DXVECTOR3 *pv, FLOAT angle)
1066 {
1067 D3DXMATRIX temp;
1068 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1069
1070 TRACE("iface %p\n", iface);
1071
1072 D3DXMatrixRotationAxis(&temp, pv, angle);
1073 D3DXMatrixMultiply(&This->stack[This->current], &This->stack[This->current], &temp);
1074
1075 return D3D_OK;
1076 }
1077
1078 static HRESULT WINAPI ID3DXMatrixStackImpl_RotateAxisLocal(ID3DXMatrixStack *iface, CONST D3DXVECTOR3 *pv, FLOAT angle)
1079 {
1080 D3DXMATRIX temp;
1081 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1082
1083 TRACE("iface %p\n", iface);
1084
1085 D3DXMatrixRotationAxis(&temp, pv, angle);
1086 D3DXMatrixMultiply(&This->stack[This->current], &temp, &This->stack[This->current]);
1087
1088 return D3D_OK;
1089 }
1090
1091 static HRESULT WINAPI ID3DXMatrixStackImpl_RotateYawPitchRoll(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
1092 {
1093 D3DXMATRIX temp;
1094 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1095
1096 TRACE("iface %p\n", iface);
1097
1098 D3DXMatrixRotationYawPitchRoll(&temp, x, y, z);
1099 D3DXMatrixMultiply(&This->stack[This->current], &This->stack[This->current], &temp);
1100
1101 return D3D_OK;
1102 }
1103
1104 static HRESULT WINAPI ID3DXMatrixStackImpl_RotateYawPitchRollLocal(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
1105 {
1106 D3DXMATRIX temp;
1107 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1108
1109 TRACE("iface %p\n", iface);
1110
1111 D3DXMatrixRotationYawPitchRoll(&temp, x, y, z);
1112 D3DXMatrixMultiply(&This->stack[This->current], &temp, &This->stack[This->current]);
1113
1114 return D3D_OK;
1115 }
1116
1117 static HRESULT WINAPI ID3DXMatrixStackImpl_Scale(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
1118 {
1119 D3DXMATRIX temp;
1120 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1121
1122 TRACE("iface %p\n", iface);
1123
1124 D3DXMatrixScaling(&temp, x, y, z);
1125 D3DXMatrixMultiply(&This->stack[This->current], &This->stack[This->current], &temp);
1126
1127 return D3D_OK;
1128 }
1129
1130 static HRESULT WINAPI ID3DXMatrixStackImpl_ScaleLocal(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
1131 {
1132 D3DXMATRIX temp;
1133 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1134
1135 TRACE("iface %p\n", iface);
1136
1137 D3DXMatrixScaling(&temp, x, y, z);
1138 D3DXMatrixMultiply(&This->stack[This->current], &temp, &This->stack[This->current]);
1139
1140 return D3D_OK;
1141 }
1142
1143 static HRESULT WINAPI ID3DXMatrixStackImpl_Translate(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
1144 {
1145 D3DXMATRIX temp;
1146 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1147
1148 TRACE("iface %p\n", iface);
1149
1150 D3DXMatrixTranslation(&temp, x, y, z);
1151 D3DXMatrixMultiply(&This->stack[This->current], &This->stack[This->current], &temp);
1152
1153 return D3D_OK;
1154 }
1155
1156 static HRESULT WINAPI ID3DXMatrixStackImpl_TranslateLocal(ID3DXMatrixStack *iface, FLOAT x, FLOAT y, FLOAT z)
1157 {
1158 D3DXMATRIX temp;
1159 struct ID3DXMatrixStackImpl *This = impl_from_ID3DXMatrixStack(iface);
1160
1161 TRACE("iface %p\n", iface);
1162
1163 D3DXMatrixTranslation(&temp, x, y, z);
1164 D3DXMatrixMultiply(&This->stack[This->current], &temp,&This->stack[This->current]);
1165
1166 return D3D_OK;
1167 }
1168
1169 static const ID3DXMatrixStackVtbl ID3DXMatrixStack_Vtbl =
1170 {
1171 ID3DXMatrixStackImpl_QueryInterface,
1172 ID3DXMatrixStackImpl_AddRef,
1173 ID3DXMatrixStackImpl_Release,
1174 ID3DXMatrixStackImpl_Pop,
1175 ID3DXMatrixStackImpl_Push,
1176 ID3DXMatrixStackImpl_LoadIdentity,
1177 ID3DXMatrixStackImpl_LoadMatrix,
1178 ID3DXMatrixStackImpl_MultMatrix,
1179 ID3DXMatrixStackImpl_MultMatrixLocal,
1180 ID3DXMatrixStackImpl_RotateAxis,
1181 ID3DXMatrixStackImpl_RotateAxisLocal,
1182 ID3DXMatrixStackImpl_RotateYawPitchRoll,
1183 ID3DXMatrixStackImpl_RotateYawPitchRollLocal,
1184 ID3DXMatrixStackImpl_Scale,
1185 ID3DXMatrixStackImpl_ScaleLocal,
1186 ID3DXMatrixStackImpl_Translate,
1187 ID3DXMatrixStackImpl_TranslateLocal,
1188 ID3DXMatrixStackImpl_GetTop
1189 };
1190
1191 /*_________________D3DXPLANE________________*/
1192
1193 D3DXPLANE* WINAPI D3DXPlaneFromPointNormal(D3DXPLANE *pout, CONST D3DXVECTOR3 *pvpoint, CONST D3DXVECTOR3 *pvnormal)
1194 {
1195 TRACE("(%p, %p, %p)\n", pout, pvpoint, pvnormal);
1196
1197 pout->a = pvnormal->x;
1198 pout->b = pvnormal->y;
1199 pout->c = pvnormal->z;
1200 pout->d = -D3DXVec3Dot(pvpoint, pvnormal);
1201 return pout;
1202 }
1203
1204 D3DXPLANE* WINAPI D3DXPlaneFromPoints(D3DXPLANE *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3)
1205 {
1206 D3DXVECTOR3 edge1, edge2, normal, Nnormal;
1207
1208 TRACE("(%p, %p, %p, %p)\n", pout, pv1, pv2, pv3);
1209
1210 edge1.x = 0.0f; edge1.y = 0.0f; edge1.z = 0.0f;
1211 edge2.x = 0.0f; edge2.y = 0.0f; edge2.z = 0.0f;
1212 D3DXVec3Subtract(&edge1, pv2, pv1);
1213 D3DXVec3Subtract(&edge2, pv3, pv1);
1214 D3DXVec3Cross(&normal, &edge1, &edge2);
1215 D3DXVec3Normalize(&Nnormal, &normal);
1216 D3DXPlaneFromPointNormal(pout, pv1, &Nnormal);
1217 return pout;
1218 }
1219
1220 D3DXVECTOR3* WINAPI D3DXPlaneIntersectLine(D3DXVECTOR3 *pout, CONST D3DXPLANE *pp, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
1221 {
1222 D3DXVECTOR3 direction, normal;
1223 FLOAT dot, temp;
1224
1225 TRACE("(%p, %p, %p, %p)\n", pout, pp, pv1, pv2);
1226
1227 normal.x = pp->a;
1228 normal.y = pp->b;
1229 normal.z = pp->c;
1230 direction.x = pv2->x - pv1->x;
1231 direction.y = pv2->y - pv1->y;
1232 direction.z = pv2->z - pv1->z;
1233 dot = D3DXVec3Dot(&normal, &direction);
1234 if ( !dot ) return NULL;
1235 temp = ( pp->d + D3DXVec3Dot(&normal, pv1) ) / dot;
1236 pout->x = pv1->x - temp * direction.x;
1237 pout->y = pv1->y - temp * direction.y;
1238 pout->z = pv1->z - temp * direction.z;
1239 return pout;
1240 }
1241
1242 D3DXPLANE * WINAPI D3DXPlaneNormalize(D3DXPLANE *out, const D3DXPLANE *p)
1243 {
1244 FLOAT norm;
1245
1246 TRACE("out %p, p %p\n", out, p);
1247
1248 norm = sqrtf(p->a * p->a + p->b * p->b + p->c * p->c);
1249 if (norm)
1250 {
1251 out->a = p->a / norm;
1252 out->b = p->b / norm;
1253 out->c = p->c / norm;
1254 out->d = p->d / norm;
1255 }
1256 else
1257 {
1258 out->a = 0.0f;
1259 out->b = 0.0f;
1260 out->c = 0.0f;
1261 out->d = 0.0f;
1262 }
1263
1264 return out;
1265 }
1266
1267 D3DXPLANE* WINAPI D3DXPlaneTransform(D3DXPLANE *pout, CONST D3DXPLANE *pplane, CONST D3DXMATRIX *pm)
1268 {
1269 CONST D3DXPLANE plane = *pplane;
1270
1271 TRACE("(%p, %p, %p)\n", pout, pplane, pm);
1272
1273 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;
1274 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;
1275 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;
1276 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;
1277 return pout;
1278 }
1279
1280 D3DXPLANE* WINAPI D3DXPlaneTransformArray(D3DXPLANE* out, UINT outstride, CONST D3DXPLANE* in, UINT instride, CONST D3DXMATRIX* matrix, UINT elements)
1281 {
1282 UINT i;
1283
1284 TRACE("(%p, %u, %p, %u, %p, %u)\n", out, outstride, in, instride, matrix, elements);
1285
1286 for (i = 0; i < elements; ++i) {
1287 D3DXPlaneTransform(
1288 (D3DXPLANE*)((char*)out + outstride * i),
1289 (CONST D3DXPLANE*)((const char*)in + instride * i),
1290 matrix);
1291 }
1292 return out;
1293 }
1294
1295 /*_________________D3DXQUATERNION________________*/
1296
1297 D3DXQUATERNION* WINAPI D3DXQuaternionBaryCentric(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, CONST D3DXQUATERNION *pq3, FLOAT f, FLOAT g)
1298 {
1299 D3DXQUATERNION temp1, temp2;
1300
1301 TRACE("(%p, %p, %p, %p, %f, %f)\n", pout, pq1, pq2, pq3, f, g);
1302
1303 D3DXQuaternionSlerp(pout, D3DXQuaternionSlerp(&temp1, pq1, pq2, f + g), D3DXQuaternionSlerp(&temp2, pq1, pq3, f+g), g / (f + g));
1304 return pout;
1305 }
1306
1307 D3DXQUATERNION * WINAPI D3DXQuaternionExp(D3DXQUATERNION *out, const D3DXQUATERNION *q)
1308 {
1309 FLOAT norm;
1310
1311 TRACE("out %p, q %p\n", out, q);
1312
1313 norm = sqrtf(q->x * q->x + q->y * q->y + q->z * q->z);
1314 if (norm)
1315 {
1316 out->x = sinf(norm) * q->x / norm;
1317 out->y = sinf(norm) * q->y / norm;
1318 out->z = sinf(norm) * q->z / norm;
1319 out->w = cosf(norm);
1320 }
1321 else
1322 {
1323 out->x = 0.0f;
1324 out->y = 0.0f;
1325 out->z = 0.0f;
1326 out->w = 1.0f;
1327 }
1328
1329 return out;
1330 }
1331
1332 D3DXQUATERNION* WINAPI D3DXQuaternionInverse(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
1333 {
1334 D3DXQUATERNION out;
1335 FLOAT norm;
1336
1337 TRACE("(%p, %p)\n", pout, pq);
1338
1339 norm = D3DXQuaternionLengthSq(pq);
1340
1341 out.x = -pq->x / norm;
1342 out.y = -pq->y / norm;
1343 out.z = -pq->z / norm;
1344 out.w = pq->w / norm;
1345
1346 *pout =out;
1347 return pout;
1348 }
1349
1350 D3DXQUATERNION * WINAPI D3DXQuaternionLn(D3DXQUATERNION *out, const D3DXQUATERNION *q)
1351 {
1352 FLOAT t;
1353
1354 TRACE("out %p, q %p\n", out, q);
1355
1356 if ((q->w >= 1.0f) || (q->w == -1.0f))
1357 t = 1.0f;
1358 else
1359 t = acosf(q->w) / sqrtf(1.0f - q->w * q->w);
1360
1361 out->x = t * q->x;
1362 out->y = t * q->y;
1363 out->z = t * q->z;
1364 out->w = 0.0f;
1365
1366 return out;
1367 }
1368
1369 D3DXQUATERNION* WINAPI D3DXQuaternionMultiply(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2)
1370 {
1371 D3DXQUATERNION out;
1372
1373 TRACE("(%p, %p, %p)\n", pout, pq1, pq2);
1374
1375 out.x = pq2->w * pq1->x + pq2->x * pq1->w + pq2->y * pq1->z - pq2->z * pq1->y;
1376 out.y = pq2->w * pq1->y - pq2->x * pq1->z + pq2->y * pq1->w + pq2->z * pq1->x;
1377 out.z = pq2->w * pq1->z + pq2->x * pq1->y - pq2->y * pq1->x + pq2->z * pq1->w;
1378 out.w = pq2->w * pq1->w - pq2->x * pq1->x - pq2->y * pq1->y - pq2->z * pq1->z;
1379 *pout = out;
1380 return pout;
1381 }
1382
1383 D3DXQUATERNION * WINAPI D3DXQuaternionNormalize(D3DXQUATERNION *out, const D3DXQUATERNION *q)
1384 {
1385 FLOAT norm;
1386
1387 TRACE("out %p, q %p\n", out, q);
1388
1389 norm = D3DXQuaternionLength(q);
1390
1391 out->x = q->x / norm;
1392 out->y = q->y / norm;
1393 out->z = q->z / norm;
1394 out->w = q->w / norm;
1395
1396 return out;
1397 }
1398
1399 D3DXQUATERNION * WINAPI D3DXQuaternionRotationAxis(D3DXQUATERNION *out, const D3DXVECTOR3 *v, FLOAT angle)
1400 {
1401 D3DXVECTOR3 temp;
1402
1403 TRACE("out %p, v %p, angle %f\n", out, v, angle);
1404
1405 D3DXVec3Normalize(&temp, v);
1406
1407 out->x = sinf(angle / 2.0f) * temp.x;
1408 out->y = sinf(angle / 2.0f) * temp.y;
1409 out->z = sinf(angle / 2.0f) * temp.z;
1410 out->w = cosf(angle / 2.0f);
1411
1412 return out;
1413 }
1414
1415 D3DXQUATERNION * WINAPI D3DXQuaternionRotationMatrix(D3DXQUATERNION *out, const D3DXMATRIX *m)
1416 {
1417 FLOAT s, trace;
1418
1419 TRACE("out %p, m %p\n", out, m);
1420
1421 trace = m->u.m[0][0] + m->u.m[1][1] + m->u.m[2][2] + 1.0f;
1422 if (trace > 1.0f)
1423 {
1424 s = 2.0f * sqrtf(trace);
1425 out->x = (m->u.m[1][2] - m->u.m[2][1]) / s;
1426 out->y = (m->u.m[2][0] - m->u.m[0][2]) / s;
1427 out->z = (m->u.m[0][1] - m->u.m[1][0]) / s;
1428 out->w = 0.25f * s;
1429 }
1430 else
1431 {
1432 int i, maxi = 0;
1433
1434 for (i = 1; i < 3; i++)
1435 {
1436 if (m->u.m[i][i] > m->u.m[maxi][maxi])
1437 maxi = i;
1438 }
1439
1440 switch (maxi)
1441 {
1442 case 0:
1443 s = 2.0f * sqrtf(1.0f + m->u.m[0][0] - m->u.m[1][1] - m->u.m[2][2]);
1444 out->x = 0.25f * s;
1445 out->y = (m->u.m[0][1] + m->u.m[1][0]) / s;
1446 out->z = (m->u.m[0][2] + m->u.m[2][0]) / s;
1447 out->w = (m->u.m[1][2] - m->u.m[2][1]) / s;
1448 break;
1449
1450 case 1:
1451 s = 2.0f * sqrtf(1.0f + m->u.m[1][1] - m->u.m[0][0] - m->u.m[2][2]);
1452 out->x = (m->u.m[0][1] + m->u.m[1][0]) / s;
1453 out->y = 0.25f * s;
1454 out->z = (m->u.m[1][2] + m->u.m[2][1]) / s;
1455 out->w = (m->u.m[2][0] - m->u.m[0][2]) / s;
1456 break;
1457
1458 case 2:
1459 s = 2.0f * sqrtf(1.0f + m->u.m[2][2] - m->u.m[0][0] - m->u.m[1][1]);
1460 out->x = (m->u.m[0][2] + m->u.m[2][0]) / s;
1461 out->y = (m->u.m[1][2] + m->u.m[2][1]) / s;
1462 out->z = 0.25f * s;
1463 out->w = (m->u.m[0][1] - m->u.m[1][0]) / s;
1464 break;
1465 }
1466 }
1467
1468 return out;
1469 }
1470
1471 D3DXQUATERNION * WINAPI D3DXQuaternionRotationYawPitchRoll(D3DXQUATERNION *out, FLOAT yaw, FLOAT pitch, FLOAT roll)
1472 {
1473 FLOAT syaw, cyaw, spitch, cpitch, sroll, croll;
1474
1475 TRACE("out %p, yaw %f, pitch %f, roll %f\n", out, yaw, pitch, roll);
1476
1477 syaw = sinf(yaw / 2.0f);
1478 cyaw = cosf(yaw / 2.0f);
1479 spitch = sinf(pitch / 2.0f);
1480 cpitch = cosf(pitch / 2.0f);
1481 sroll = sinf(roll / 2.0f);
1482 croll = cosf(roll / 2.0f);
1483
1484 out->x = syaw * cpitch * sroll + cyaw * spitch * croll;
1485 out->y = syaw * cpitch * croll - cyaw * spitch * sroll;
1486 out->z = cyaw * cpitch * sroll - syaw * spitch * croll;
1487 out->w = cyaw * cpitch * croll + syaw * spitch * sroll;
1488
1489 return out;
1490 }
1491
1492 D3DXQUATERNION * WINAPI D3DXQuaternionSlerp(D3DXQUATERNION *out, const D3DXQUATERNION *q1,
1493 const D3DXQUATERNION *q2, FLOAT t)
1494 {
1495 FLOAT dot, temp;
1496
1497 TRACE("out %p, q1 %p, q2 %p, t %f\n", out, q1, q2, t);
1498
1499 temp = 1.0f - t;
1500 dot = D3DXQuaternionDot(q1, q2);
1501 if (dot < 0.0f)
1502 {
1503 t = -t;
1504 dot = -dot;
1505 }
1506
1507 if (1.0f - dot > 0.001f)
1508 {
1509 FLOAT theta = acosf(dot);
1510
1511 temp = sinf(theta * temp) / sinf(theta);
1512 t = sinf(theta * t) / sinf(theta);
1513 }
1514
1515 out->x = temp * q1->x + t * q2->x;
1516 out->y = temp * q1->y + t * q2->y;
1517 out->z = temp * q1->z + t * q2->z;
1518 out->w = temp * q1->w + t * q2->w;
1519
1520 return out;
1521 }
1522
1523 D3DXQUATERNION* WINAPI D3DXQuaternionSquad(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, CONST D3DXQUATERNION *pq3, CONST D3DXQUATERNION *pq4, FLOAT t)
1524 {
1525 D3DXQUATERNION temp1, temp2;
1526
1527 TRACE("(%p, %p, %p, %p, %p, %f)\n", pout, pq1, pq2, pq3, pq4, t);
1528
1529 D3DXQuaternionSlerp(pout, D3DXQuaternionSlerp(&temp1, pq1, pq4, t), D3DXQuaternionSlerp(&temp2, pq2, pq3, t), 2.0f * t * (1.0f - t));
1530 return pout;
1531 }
1532
1533 static D3DXQUATERNION add_diff(CONST D3DXQUATERNION *q1, CONST D3DXQUATERNION *q2, CONST FLOAT add)
1534 {
1535 D3DXQUATERNION temp;
1536
1537 temp.x = q1->x + add * q2->x;
1538 temp.y = q1->y + add * q2->y;
1539 temp.z = q1->z + add * q2->z;
1540 temp.w = q1->w + add * q2->w;
1541
1542 return temp;
1543 }
1544
1545 void WINAPI D3DXQuaternionSquadSetup(D3DXQUATERNION *paout, D3DXQUATERNION *pbout, D3DXQUATERNION *pcout, CONST D3DXQUATERNION *pq0, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, CONST D3DXQUATERNION *pq3)
1546 {
1547 D3DXQUATERNION q, temp1, temp2, temp3, zero;
1548
1549 TRACE("(%p, %p, %p, %p, %p, %p, %p)\n", paout, pbout, pcout, pq0, pq1, pq2, pq3);
1550
1551 zero.x = 0.0f;
1552 zero.y = 0.0f;
1553 zero.z = 0.0f;
1554 zero.w = 0.0f;
1555
1556 if ( D3DXQuaternionDot(pq0, pq1) < 0.0f )
1557 temp2 = add_diff(&zero, pq0, -1.0f);
1558 else
1559 temp2 = *pq0;
1560
1561 if ( D3DXQuaternionDot(pq1, pq2) < 0.0f )
1562 *pcout = add_diff(&zero, pq2, -1.0f);
1563 else
1564 *pcout = *pq2;
1565
1566 if ( D3DXQuaternionDot(pcout, pq3) < 0.0f )
1567 temp3 = add_diff(&zero, pq3, -1.0f);
1568 else
1569 temp3 = *pq3;
1570
1571 D3DXQuaternionInverse(&temp1, pq1);
1572 D3DXQuaternionMultiply(&temp2, &temp1, &temp2);
1573 D3DXQuaternionLn(&temp2, &temp2);
1574 D3DXQuaternionMultiply(&q, &temp1, pcout);
1575 D3DXQuaternionLn(&q, &q);
1576 temp1 = add_diff(&temp2, &q, 1.0f);
1577 temp1.x *= -0.25f;
1578 temp1.y *= -0.25f;
1579 temp1.z *= -0.25f;
1580 temp1.w *= -0.25f;
1581 D3DXQuaternionExp(&temp1, &temp1);
1582 D3DXQuaternionMultiply(paout, pq1, &temp1);
1583
1584 D3DXQuaternionInverse(&temp1, pcout);
1585 D3DXQuaternionMultiply(&temp2, &temp1, pq1);
1586 D3DXQuaternionLn(&temp2, &temp2);
1587 D3DXQuaternionMultiply(&q, &temp1, &temp3);
1588 D3DXQuaternionLn(&q, &q);
1589 temp1 = add_diff(&temp2, &q, 1.0f);
1590 temp1.x *= -0.25f;
1591 temp1.y *= -0.25f;
1592 temp1.z *= -0.25f;
1593 temp1.w *= -0.25f;
1594 D3DXQuaternionExp(&temp1, &temp1);
1595 D3DXQuaternionMultiply(pbout, pcout, &temp1);
1596
1597 return;
1598 }
1599
1600 void WINAPI D3DXQuaternionToAxisAngle(CONST D3DXQUATERNION *pq, D3DXVECTOR3 *paxis, FLOAT *pangle)
1601 {
1602 TRACE("(%p, %p, %p)\n", pq, paxis, pangle);
1603
1604 paxis->x = pq->x;
1605 paxis->y = pq->y;
1606 paxis->z = pq->z;
1607 *pangle = 2.0f * acos(pq->w);
1608 }
1609
1610 /*_________________D3DXVec2_____________________*/
1611
1612 D3DXVECTOR2* WINAPI D3DXVec2BaryCentric(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pv3, FLOAT f, FLOAT g)
1613 {
1614 TRACE("(%p, %p, %p, %p, %f, %f)\n", pout, pv1, pv2, pv3, f, g);
1615
1616 pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
1617 pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
1618 return pout;
1619 }
1620
1621 D3DXVECTOR2* WINAPI D3DXVec2CatmullRom(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv0, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pv3, FLOAT s)
1622 {
1623 TRACE("(%p, %p, %p, %p, %p, %f)\n", pout, pv0, pv1, pv2, pv3, s);
1624
1625 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);
1626 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);
1627 return pout;
1628 }
1629
1630 D3DXVECTOR2* WINAPI D3DXVec2Hermite(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pt1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pt2, FLOAT s)
1631 {
1632 FLOAT h1, h2, h3, h4;
1633
1634 TRACE("(%p, %p, %p, %p, %p, %f)\n", pout, pv1, pt1, pv2, pt2, s);
1635
1636 h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
1637 h2 = s * s * s - 2.0f * s * s + s;
1638 h3 = -2.0f * s * s * s + 3.0f * s * s;
1639 h4 = s * s * s - s * s;
1640
1641 pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
1642 pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
1643 return pout;
1644 }
1645
1646 D3DXVECTOR2* WINAPI D3DXVec2Normalize(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv)
1647 {
1648 FLOAT norm;
1649
1650 TRACE("(%p, %p)\n", pout, pv);
1651
1652 norm = D3DXVec2Length(pv);
1653 if ( !norm )
1654 {
1655 pout->x = 0.0f;
1656 pout->y = 0.0f;
1657 }
1658 else
1659 {
1660 pout->x = pv->x / norm;
1661 pout->y = pv->y / norm;
1662 }
1663
1664 return pout;
1665 }
1666
1667 D3DXVECTOR4* WINAPI D3DXVec2Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
1668 {
1669 TRACE("(%p, %p, %p)\n", pout, pv, pm);
1670
1671 pout->x = pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y + pm->u.m[3][0];
1672 pout->y = pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y + pm->u.m[3][1];
1673 pout->z = pm->u.m[0][2] * pv->x + pm->u.m[1][2] * pv->y + pm->u.m[3][2];
1674 pout->w = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y + pm->u.m[3][3];
1675 return pout;
1676 }
1677
1678 D3DXVECTOR4* WINAPI D3DXVec2TransformArray(D3DXVECTOR4* out, UINT outstride, CONST D3DXVECTOR2* in, UINT instride, CONST D3DXMATRIX* matrix, UINT elements)
1679 {
1680 UINT i;
1681
1682 TRACE("(%p, %u, %p, %u, %p, %u)\n", out, outstride, in, instride, matrix, elements);
1683
1684 for (i = 0; i < elements; ++i) {
1685 D3DXVec2Transform(
1686 (D3DXVECTOR4*)((char*)out + outstride * i),
1687 (CONST D3DXVECTOR2*)((const char*)in + instride * i),
1688 matrix);
1689 }
1690 return out;
1691 }
1692
1693 D3DXVECTOR2* WINAPI D3DXVec2TransformCoord(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
1694 {
1695 D3DXVECTOR2 v;
1696 FLOAT norm;
1697
1698 TRACE("(%p, %p, %p)\n", pout, pv, pm);
1699
1700 v = *pv;
1701 norm = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y + pm->u.m[3][3];
1702
1703 pout->x = (pm->u.m[0][0] * v.x + pm->u.m[1][0] * v.y + pm->u.m[3][0]) / norm;
1704 pout->y = (pm->u.m[0][1] * v.x + pm->u.m[1][1] * v.y + pm->u.m[3][1]) / norm;
1705
1706 return pout;
1707 }
1708
1709 D3DXVECTOR2* WINAPI D3DXVec2TransformCoordArray(D3DXVECTOR2* out, UINT outstride, CONST D3DXVECTOR2* in, UINT instride, CONST D3DXMATRIX* matrix, UINT elements)
1710 {
1711 UINT i;
1712
1713 TRACE("(%p, %u, %p, %u, %p, %u)\n", out, outstride, in, instride, matrix, elements);
1714
1715 for (i = 0; i < elements; ++i) {
1716 D3DXVec2TransformCoord(
1717 (D3DXVECTOR2*)((char*)out + outstride * i),
1718 (CONST D3DXVECTOR2*)((const char*)in + instride * i),
1719 matrix);
1720 }
1721 return out;
1722 }
1723
1724 D3DXVECTOR2* WINAPI D3DXVec2TransformNormal(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
1725 {
1726 CONST D3DXVECTOR2 v = *pv;
1727 pout->x = pm->u.m[0][0] * v.x + pm->u.m[1][0] * v.y;
1728 pout->y = pm->u.m[0][1] * v.x + pm->u.m[1][1] * v.y;
1729 return pout;
1730 }
1731
1732 D3DXVECTOR2* WINAPI D3DXVec2TransformNormalArray(D3DXVECTOR2* out, UINT outstride, CONST D3DXVECTOR2 *in, UINT instride, CONST D3DXMATRIX *matrix, UINT elements)
1733 {
1734 UINT i;
1735
1736 TRACE("(%p, %u, %p, %u, %p, %u)\n", out, outstride, in, instride, matrix, elements);
1737
1738 for (i = 0; i < elements; ++i) {
1739 D3DXVec2TransformNormal(
1740 (D3DXVECTOR2*)((char*)out + outstride * i),
1741 (CONST D3DXVECTOR2*)((const char*)in + instride * i),
1742 matrix);
1743 }
1744 return out;
1745 }
1746
1747 /*_________________D3DXVec3_____________________*/
1748
1749 D3DXVECTOR3* WINAPI D3DXVec3BaryCentric(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3, FLOAT f, FLOAT g)
1750 {
1751 TRACE("(%p, %p, %p, %p, %f, %f)\n", pout, pv1, pv2, pv3, f, g);
1752
1753 pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
1754 pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
1755 pout->z = (1.0f-f-g) * (pv1->z) + f * (pv2->z) + g * (pv3->z);
1756 return pout;
1757 }
1758
1759 D3DXVECTOR3* WINAPI D3DXVec3CatmullRom( D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv0, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3, FLOAT s)
1760 {
1761 TRACE("(%p, %p, %p, %p, %p, %f)\n", pout, pv0, pv1, pv2, pv3, s);
1762
1763 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);
1764 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);
1765 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);
1766 return pout;
1767 }
1768
1769 D3DXVECTOR3* WINAPI D3DXVec3Hermite(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pt1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pt2, FLOAT s)
1770 {
1771 FLOAT h1, h2, h3, h4;
1772
1773 TRACE("(%p, %p, %p, %p, %p, %f)\n", pout, pv1, pt1, pv2, pt2, s);
1774
1775 h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
1776 h2 = s * s * s - 2.0f * s * s + s;
1777 h3 = -2.0f * s * s * s + 3.0f * s * s;
1778 h4 = s * s * s - s * s;
1779
1780 pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
1781 pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
1782 pout->z = h1 * (pv1->z) + h2 * (pt1->z) + h3 * (pv2->z) + h4 * (pt2->z);
1783 return pout;
1784 }
1785
1786 D3DXVECTOR3* WINAPI D3DXVec3Normalize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv)
1787 {
1788 FLOAT norm;
1789
1790 TRACE("(%p, %p)\n", pout, pv);
1791
1792 norm = D3DXVec3Length(pv);
1793 if ( !norm )
1794 {
1795 pout->x = 0.0f;
1796 pout->y = 0.0f;
1797 pout->z = 0.0f;
1798 }
1799 else
1800 {
1801 pout->x = pv->x / norm;
1802 pout->y = pv->y / norm;
1803 pout->z = pv->z / norm;
1804 }
1805
1806 return pout;
1807 }
1808
1809 D3DXVECTOR3* WINAPI D3DXVec3Project(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DVIEWPORT9 *pviewport, CONST D3DXMATRIX *pprojection, CONST D3DXMATRIX *pview, CONST D3DXMATRIX *pworld)
1810 {
1811 D3DXMATRIX m;
1812 D3DXVECTOR3 out;
1813
1814 TRACE("(%p, %p, %p, %p, %p, %p)\n", pout, pv, pviewport, pprojection, pview, pworld);
1815
1816 D3DXMatrixMultiply(&m, pworld, pview);
1817 D3DXMatrixMultiply(&m, &m, pprojection);
1818 D3DXVec3TransformCoord(&out, pv, &m);
1819 out.x = pviewport->X + ( 1.0f + out.x ) * pviewport->Width / 2.0f;
1820 out.y = pviewport->Y + ( 1.0f - out.y ) * pviewport->Height / 2.0f;
1821 out.z = pviewport->MinZ + out.z * ( pviewport->MaxZ - pviewport->MinZ );
1822 *pout = out;
1823 return pout;
1824 }
1825
1826 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)
1827 {
1828 UINT i;
1829
1830 TRACE("(%p, %u, %p, %u, %p, %p, %p, %p, %u)\n", out, outstride, in, instride, viewport, projection, view, world, elements);
1831
1832 for (i = 0; i < elements; ++i) {
1833 D3DXVec3Project(
1834 (D3DXVECTOR3*)((char*)out + outstride * i),
1835 (CONST D3DXVECTOR3*)((const char*)in + instride * i),
1836 viewport, projection, view, world);
1837 }
1838 return out;
1839 }
1840
1841 D3DXVECTOR4* WINAPI D3DXVec3Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
1842 {
1843 TRACE("(%p, %p, %p)\n", pout, pv, pm);
1844
1845 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];
1846 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];
1847 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];
1848 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];
1849 return pout;
1850 }
1851
1852 D3DXVECTOR4* WINAPI D3DXVec3TransformArray(D3DXVECTOR4* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride, CONST D3DXMATRIX* matrix, UINT elements)
1853 {
1854 UINT i;
1855
1856 TRACE("(%p, %u, %p, %u, %p, %u)\n", out, outstride, in, instride, matrix, elements);
1857
1858 for (i = 0; i < elements; ++i) {
1859 D3DXVec3Transform(
1860 (D3DXVECTOR4*)((char*)out + outstride * i),
1861 (CONST D3DXVECTOR3*)((const char*)in + instride * i),
1862 matrix);
1863 }
1864 return out;
1865 }
1866
1867 D3DXVECTOR3* WINAPI D3DXVec3TransformCoord(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
1868 {
1869 D3DXVECTOR3 out;
1870 FLOAT norm;
1871
1872 TRACE("(%p, %p, %p)\n", pout, pv, pm);
1873
1874 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];
1875
1876 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;
1877 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;
1878 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;
1879
1880 *pout = out;
1881
1882 return pout;
1883 }
1884
1885 D3DXVECTOR3* WINAPI D3DXVec3TransformCoordArray(D3DXVECTOR3* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride, CONST D3DXMATRIX* matrix, UINT elements)
1886 {
1887 UINT i;
1888
1889 TRACE("(%p, %u, %p, %u, %p, %u)\n", out, outstride, in, instride, matrix, elements);
1890
1891 for (i = 0; i < elements; ++i) {
1892 D3DXVec3TransformCoord(
1893 (D3DXVECTOR3*)((char*)out + outstride * i),
1894 (CONST D3DXVECTOR3*)((const char*)in + instride * i),
1895 matrix);
1896 }
1897 return out;
1898 }
1899
1900 D3DXVECTOR3* WINAPI D3DXVec3TransformNormal(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
1901 {
1902 CONST D3DXVECTOR3 v = *pv;
1903
1904 TRACE("(%p, %p, %p)\n", pout, pv, pm);
1905
1906 pout->x = pm->u.m[0][0] * v.x + pm->u.m[1][0] * v.y + pm->u.m[2][0] * v.z;
1907 pout->y = pm->u.m[0][1] * v.x + pm->u.m[1][1] * v.y + pm->u.m[2][1] * v.z;
1908 pout->z = pm->u.m[0][2] * v.x + pm->u.m[1][2] * v.y + pm->u.m[2][2] * v.z;
1909 return pout;
1910
1911 }
1912
1913 D3DXVECTOR3* WINAPI D3DXVec3TransformNormalArray(D3DXVECTOR3* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride, CONST D3DXMATRIX* matrix, UINT elements)
1914 {
1915 UINT i;
1916
1917 TRACE("(%p, %u, %p, %u, %p, %u)\n", out, outstride, in, instride, matrix, elements);
1918
1919 for (i = 0; i < elements; ++i) {
1920 D3DXVec3TransformNormal(
1921 (D3DXVECTOR3*)((char*)out + outstride * i),
1922 (CONST D3DXVECTOR3*)((const char*)in + instride * i),
1923 matrix);
1924 }
1925 return out;
1926 }
1927
1928 D3DXVECTOR3* WINAPI D3DXVec3Unproject(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DVIEWPORT9 *pviewport, CONST D3DXMATRIX *pprojection, CONST D3DXMATRIX *pview, CONST D3DXMATRIX *pworld)
1929 {
1930 D3DXMATRIX m;
1931 D3DXVECTOR3 out;
1932
1933 TRACE("(%p, %p, %p, %p, %p, %p)\n", pout, pv, pviewport, pprojection, pview, pworld);
1934
1935 if (pworld) {
1936 D3DXMatrixMultiply(&m, pworld, pview);
1937 D3DXMatrixMultiply(&m, &m, pprojection);
1938 } else {
1939 D3DXMatrixMultiply(&m, pview, pprojection);
1940 }
1941 D3DXMatrixInverse(&m, NULL, &m);
1942 out.x = 2.0f * ( pv->x - pviewport->X ) / pviewport->Width - 1.0f;
1943 out.y = 1.0f - 2.0f * ( pv->y - pviewport->Y ) / pviewport->Height;
1944 out.z = ( pv->z - pviewport->MinZ) / ( pviewport->MaxZ - pviewport->MinZ );
1945 D3DXVec3TransformCoord(&out, &out, &m);
1946 *pout = out;
1947 return pout;
1948 }
1949
1950 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)
1951 {
1952 UINT i;
1953
1954 TRACE("(%p, %u, %p, %u, %p, %p, %p, %p, %u)\n", out, outstride, in, instride, viewport, projection, view, world, elements);
1955
1956 for (i = 0; i < elements; ++i) {
1957 D3DXVec3Unproject(
1958 (D3DXVECTOR3*)((char*)out + outstride * i),
1959 (CONST D3DXVECTOR3*)((const char*)in + instride * i),
1960 viewport, projection, view, world);
1961 }
1962 return out;
1963 }
1964
1965 /*_________________D3DXVec4_____________________*/
1966
1967 D3DXVECTOR4* WINAPI D3DXVec4BaryCentric(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3, FLOAT f, FLOAT g)
1968 {
1969 TRACE("(%p, %p, %p, %p, %f, %f)\n", pout, pv1, pv2, pv3, f, g);
1970
1971 pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
1972 pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
1973 pout->z = (1.0f-f-g) * (pv1->z) + f * (pv2->z) + g * (pv3->z);
1974 pout->w = (1.0f-f-g) * (pv1->w) + f * (pv2->w) + g * (pv3->w);
1975 return pout;
1976 }
1977
1978 D3DXVECTOR4* WINAPI D3DXVec4CatmullRom(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv0, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3, FLOAT s)
1979 {
1980 TRACE("(%p, %p, %p, %p, %p, %f)\n", pout, pv0, pv1, pv2, pv3, s);
1981
1982 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);
1983 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);
1984 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);
1985 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);
1986 return pout;
1987 }
1988
1989 D3DXVECTOR4* WINAPI D3DXVec4Cross(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3)
1990 {
1991 D3DXVECTOR4 out;
1992
1993 TRACE("(%p, %p, %p, %p)\n", pout, pv1, pv2, pv3);
1994
1995 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);
1996 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));
1997 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);
1998 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));
1999 *pout = out;
2000 return pout;
2001 }
2002
2003 D3DXVECTOR4* WINAPI D3DXVec4Hermite(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pt1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pt2, FLOAT s)
2004 {
2005 FLOAT h1, h2, h3, h4;
2006
2007 TRACE("(%p, %p, %p, %p, %p, %f)\n", pout, pv1, pt1, pv2, pt2, s);
2008
2009 h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
2010 h2 = s * s * s - 2.0f * s * s + s;
2011 h3 = -2.0f * s * s * s + 3.0f * s * s;
2012 h4 = s * s * s - s * s;
2013
2014 pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
2015 pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
2016 pout->z = h1 * (pv1->z) + h2 * (pt1->z) + h3 * (pv2->z) + h4 * (pt2->z);
2017 pout->w = h1 * (pv1->w) + h2 * (pt1->w) + h3 * (pv2->w) + h4 * (pt2->w);
2018 return pout;
2019 }
2020
2021 D3DXVECTOR4* WINAPI D3DXVec4Normalize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv)
2022 {
2023 FLOAT norm;
2024
2025 TRACE("(%p, %p)\n", pout, pv);
2026
2027 norm = D3DXVec4Length(pv);
2028
2029 pout->x = pv->x / norm;
2030 pout->y = pv->y / norm;
2031 pout->z = pv->z / norm;
2032 pout->w = pv->w / norm;
2033
2034 return pout;
2035 }
2036
2037 D3DXVECTOR4* WINAPI D3DXVec4Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv, CONST D3DXMATRIX *pm)
2038 {
2039 D3DXVECTOR4 out;
2040
2041 TRACE("(%p, %p, %p)\n", pout, pv, pm);
2042
2043 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;
2044 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;
2045 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;
2046 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;
2047 *pout = out;
2048 return pout;
2049 }
2050
2051 D3DXVECTOR4* WINAPI D3DXVec4TransformArray(D3DXVECTOR4* out, UINT outstride, CONST D3DXVECTOR4* in, UINT instride, CONST D3DXMATRIX* matrix, UINT elements)
2052 {
2053 UINT i;
2054
2055 TRACE("(%p, %u, %p, %u, %p, %u)\n", out, outstride, in, instride, matrix, elements);
2056
2057 for (i = 0; i < elements; ++i) {
2058 D3DXVec4Transform(
2059 (D3DXVECTOR4*)((char*)out + outstride * i),
2060 (CONST D3DXVECTOR4*)((const char*)in + instride * i),
2061 matrix);
2062 }
2063 return out;
2064 }
2065
2066 static inline unsigned short float_32_to_16(const float in)
2067 {
2068 int exp = 0, origexp;
2069 float tmp = fabs(in);
2070 int sign = (copysignf(1, in) < 0);
2071 unsigned int mantissa;
2072 unsigned short ret;
2073
2074 /* Deal with special numbers */
2075 if (isinf(in)) return (sign ? 0xffff : 0x7fff);
2076 if (isnan(in)) return (sign ? 0xffff : 0x7fff);
2077 if (in == 0.0f) return (sign ? 0x8000 : 0x0000);
2078
2079 if (tmp < powf(2, 10))
2080 {
2081 do
2082 {
2083 tmp *= 2.0f;
2084 exp--;
2085 } while (tmp < powf(2, 10));
2086 }
2087 else if (tmp >= powf(2, 11))
2088 {
2089 do
2090 {
2091 tmp /= 2.0f;
2092 exp++;
2093 } while (tmp >= powf(2, 11));
2094 }
2095
2096 exp += 10; /* Normalize the mantissa */
2097 exp += 15; /* Exponent is encoded with excess 15 */
2098
2099 origexp = exp;
2100
2101 mantissa = (unsigned int) tmp;
2102 if ((tmp - mantissa == 0.5f && mantissa % 2 == 1) || /* round half to even */
2103 (tmp - mantissa > 0.5f))
2104 {
2105 mantissa++; /* round to nearest, away from zero */
2106 }
2107 if (mantissa == 2048)
2108 {
2109 mantissa = 1024;
2110 exp++;
2111 }
2112
2113 if (exp > 31)
2114 {
2115 /* too big */
2116 ret = 0x7fff; /* INF */
2117 }
2118 else if (exp <= 0)
2119 {
2120 unsigned int rounding = 0;
2121
2122 /* Denormalized half float */
2123
2124 /* return 0x0000 (=0.0) for numbers too small to represent in half floats */
2125 if (exp < -11)
2126 return (sign ? 0x8000 : 0x0000);
2127
2128 exp = origexp;
2129
2130 /* the 13 extra bits from single precision are used for rounding */
2131 mantissa = (unsigned int)(tmp * powf(2, 13));
2132 mantissa >>= 1 - exp; /* denormalize */
2133
2134 mantissa -= ~(mantissa >> 13) & 1; /* round half to even */
2135 /* remove 13 least significant bits to get half float precision */
2136 mantissa >>= 12;
2137 rounding = mantissa & 1;
2138 mantissa >>= 1;
2139
2140 ret = mantissa + rounding;
2141 }
2142 else
2143 {
2144 ret = (exp << 10) | (mantissa & 0x3ff);
2145 }
2146
2147 ret |= ((sign ? 1 : 0) << 15); /* Add the sign */
2148 return ret;
2149 }
2150
2151 D3DXFLOAT16 *WINAPI D3DXFloat32To16Array(D3DXFLOAT16 *pout, CONST FLOAT *pin, UINT n)
2152 {
2153 unsigned int i;
2154
2155 TRACE("(%p, %p, %u)\n", pout, pin, n);
2156
2157 for (i = 0; i < n; ++i)
2158 {
2159 pout[i].value = float_32_to_16(pin[i]);
2160 }
2161
2162 return pout;
2163 }
2164
2165 /* Native d3dx9's D3DXFloat16to32Array lacks support for NaN and Inf. Specifically, e = 16 is treated as a
2166 * regular number - e.g., 0x7fff is converted to 131008.0 and 0xffff to -131008.0. */
2167 static inline float float_16_to_32(const unsigned short in)
2168 {
2169 const unsigned short s = (in & 0x8000);
2170 const unsigned short e = (in & 0x7C00) >> 10;
2171 const unsigned short m = in & 0x3FF;
2172 const float sgn = (s ? -1.0f : 1.0f);
2173
2174 if (e == 0)
2175 {
2176 if (m == 0) return sgn * 0.0f; /* +0.0 or -0.0 */
2177 else return sgn * powf(2, -14.0f) * (m / 1024.0f);
2178 }
2179 else
2180 {
2181 return sgn * powf(2, e - 15.0f) * (1.0f + (m / 1024.0f));
2182 }
2183 }
2184
2185 FLOAT *WINAPI D3DXFloat16To32Array(FLOAT *pout, CONST D3DXFLOAT16 *pin, UINT n)
2186 {
2187 unsigned int i;
2188
2189 TRACE("(%p, %p, %u)\n", pout, pin, n);
2190
2191 for (i = 0; i < n; ++i)
2192 {
2193 pout[i] = float_16_to_32(pin[i].value);
2194 }
2195
2196 return pout;
2197 }
2198
2199 /*_________________D3DXSH________________*/
2200
2201 FLOAT* WINAPI D3DXSHAdd(FLOAT *out, UINT order, const FLOAT *a, const FLOAT *b)
2202 {
2203 UINT i;
2204
2205 TRACE("out %p, order %u, a %p, b %p\n", out, order, a, b);
2206
2207 for (i = 0; i < order * order; i++)
2208 out[i] = a[i] + b[i];
2209
2210 return out;
2211 }
2212
2213 FLOAT WINAPI D3DXSHDot(UINT order, CONST FLOAT *a, CONST FLOAT *b)
2214 {
2215 FLOAT s;
2216 UINT i;
2217
2218 TRACE("order %u, a %p, b %p\n", order, a, b);
2219
2220 s = a[0] * b[0];
2221 for (i = 1; i < order * order; i++)
2222 s += a[i] * b[i];
2223
2224 return s;
2225 }
2226
2227 FLOAT* WINAPI D3DXSHEvalDirection(FLOAT *out, UINT order, CONST D3DXVECTOR3 *dir)
2228 {
2229
2230 TRACE("(%p, %u, %p)\n", out, order, dir);
2231
2232 if ( (order < D3DXSH_MINORDER) || (order > D3DXSH_MAXORDER) )
2233 return out;
2234
2235 out[0] = 0.5f / sqrt(D3DX_PI);
2236 out[1] = -0.5f / sqrt(D3DX_PI / 3.0f) * dir->y;
2237 out[2] = 0.5f / sqrt(D3DX_PI / 3.0f) * dir->z;
2238 out[3] = -0.5f / sqrt(D3DX_PI / 3.0f) * dir->x;
2239 if ( order == 2 )
2240 return out;
2241
2242 out[4] = 0.5f / sqrt(D3DX_PI / 15.0f) * dir->x * dir->y;
2243 out[5] = -0.5f / sqrt(D3DX_PI / 15.0f) * dir->y * dir->z;
2244 out[6] = 0.25f / sqrt(D3DX_PI / 5.0f) * ( 3.0f * dir->z * dir->z - 1.0f );
2245 out[7] = -0.5f / sqrt(D3DX_PI / 15.0f) * dir->x * dir->z;
2246 out[8] = 0.25f / sqrt(D3DX_PI / 15.0f) * ( dir->x * dir->x - dir->y * dir->y );
2247 if ( order == 3 )
2248 return out;
2249
2250 out[9] = -sqrt(70.0f / D3DX_PI) / 8.0f * dir->y * (3.0f * dir->x * dir->x - dir->y * dir->y );
2251 out[10] = sqrt(105.0f / D3DX_PI) / 2.0f * dir->x * dir->y * dir->z;
2252 out[11] = -sqrt(42.0 / D3DX_PI) / 8.0f * dir->y * ( -1.0f + 5.0f * dir->z * dir->z );
2253 out[12] = sqrt(7.0f / D3DX_PI) / 4.0f * dir->z * ( 5.0f * dir->z * dir->z - 3.0f );
2254 out[13] = sqrt(42.0 / D3DX_PI) / 8.0f * dir->x * ( 1.0f - 5.0f * dir->z * dir->z );
2255 out[14] = sqrt(105.0f / D3DX_PI) / 4.0f * dir->z * ( dir->x * dir->x - dir->y * dir->y );
2256 out[15] = -sqrt(70.0f / D3DX_PI) / 8.0f * dir->x * ( dir->x * dir->x - 3.0f * dir->y * dir->y );
2257 if ( order == 4 )
2258 return out;
2259
2260 out[16] = 0.75f * sqrt(35.0f / D3DX_PI) * dir->x * dir->y * (dir->x * dir->x - dir->y * dir->y );
2261 out[17] = 3.0f * dir->z * out[9];
2262 out[18] = 0.75f * sqrt(5.0f / D3DX_PI) * dir->x * dir->y * ( 7.0f * dir->z * dir->z - 1.0f );
2263 out[19] = 0.375f * sqrt(10.0f / D3DX_PI) * dir->y * dir->z * ( 3.0f - 7.0f * dir->z * dir->z );
2264 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 );
2265 out[21] = 0.375f * sqrt(10.0f / D3DX_PI) * dir->x * dir->z * ( 3.0f - 7.0f * dir->z * dir->z );
2266 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);
2267 out[23] = 3.0 * dir->z * out[15];
2268 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 );
2269 if ( order == 5 )
2270 return out;
2271
2272 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 );
2273 out[26] = 0.75f * sqrt(385.0f / D3DX_PI) * dir->x * dir->y * dir->z * ( dir->x * dir->x - dir->y * dir->y );
2274 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 );
2275 out[28] = sqrt(1155.0f / D3DX_PI) / 4.0f * dir->x * dir->y * dir->z * ( 3.0f * dir->z * dir->z - 1.0f);
2276 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 );
2277 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 );
2278 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 );
2279 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 );
2280 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 );
2281 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 );
2282 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 );
2283
2284 return out;
2285 }
2286
2287 HRESULT WINAPI D3DXSHEvalDirectionalLight(UINT order, CONST D3DXVECTOR3 *dir, FLOAT Rintensity, FLOAT Gintensity, FLOAT Bintensity, FLOAT *Rout, FLOAT *Gout, FLOAT *Bout)
2288 {
2289 FLOAT s, temp;
2290 UINT j;
2291
2292 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);
2293
2294 s = 0.75f;
2295 if ( order > 2 )
2296 s += 5.0f / 16.0f;
2297 if ( order > 4 )
2298 s -= 3.0f / 32.0f;
2299 s /= D3DX_PI;
2300
2301 D3DXSHEvalDirection(Rout, order, dir);
2302 for (j = 0; j < order * order; j++)
2303 {
2304 temp = Rout[j] / s;
2305
2306 Rout[j] = Rintensity * temp;
2307 if ( Gout )
2308 Gout[j] = Gintensity * temp;
2309 if ( Bout )
2310 Bout[j] = Bintensity * temp;
2311 }
2312
2313 return D3D_OK;
2314 }
2315
2316 FLOAT * WINAPI D3DXSHMultiply2(FLOAT *out, const FLOAT *a, const FLOAT *b)
2317 {
2318 FLOAT ta, tb;
2319
2320 TRACE("out %p, a %p, b %p\n", out, a, b);
2321
2322 ta = 0.28209479f * a[0];
2323 tb = 0.28209479f * b[0];
2324
2325 out[0] = 0.28209479f * D3DXSHDot(2, a, b);
2326 out[1] = ta * b[1] + tb * a[1];
2327 out[2] = ta * b[2] + tb * a[2];
2328 out[3] = ta * b[3] + tb * a[3];
2329
2330 return out;
2331 }
2332
2333 FLOAT * WINAPI D3DXSHMultiply3(FLOAT *out, const FLOAT *a, const FLOAT *b)
2334 {
2335 FLOAT t, ta, tb;
2336
2337 TRACE("out %p, a %p, b %p\n", out, a, b);
2338
2339 out[0] = 0.28209479f * a[0] * b[0];
2340
2341 ta = 0.28209479f * a[0] - 0.12615662f * a[6] - 0.21850968f * a[8];
2342 tb = 0.28209479f * b[0] - 0.12615662f * b[6] - 0.21850968f * b[8];
2343 out[1] = ta * b[1] + tb * a[1];
2344 t = a[1] * b[1];
2345 out[0] += 0.28209479f * t;
2346 out[6] = -0.12615662f * t;
2347 out[8] = -0.21850968f * t;
2348
2349 ta = 0.21850968f * a[5];
2350 tb = 0.21850968f * b[5];
2351 out[1] += ta * b[2] + tb * a[2];
2352 out[2] = ta * b[1] + tb * a[1];
2353 t = a[1] * b[2] +a[2] * b[1];
2354 out[5] = 0.21850968f * t;
2355
2356 ta = 0.21850968f * a[4];
2357 tb = 0.21850968f * b[4];
2358 out[1] += ta * b[3] + tb * a[3];
2359 out[3] = ta * b[1] + tb * a[1];
2360 t = a[1] * b[3] + a[3] * b[1];
2361 out[4] = 0.21850968f * t;
2362
2363 ta = 0.28209480f * a[0] + 0.25231326f * a[6];
2364 tb = 0.28209480f * b[0] + 0.25231326f * b[6];
2365 out[2] += ta * b[2] + tb * a[2];
2366 t = a[2] * b[2];
2367 out[0] += 0.28209480f * t;
2368 out[6] += 0.25231326f * t;
2369
2370 ta = 0.21850969f * a[7];
2371 tb = 0.21850969f * b[7];
2372 out[2] += ta * b[3] + tb * a[3];
2373 out[3] += ta * b[2] + tb * a[2];
2374 t = a[2] * b[3] + a[3] * b[2];
2375 out[7] = 0.21850969f * t;
2376
2377 ta = 0.28209479f * a[0] - 0.12615663f * a[6] + 0.21850969f * a[8];
2378 tb = 0.28209479f * b[0] - 0.12615663f * b[6] + 0.21850969f * b[8];
2379 out[3] += ta * b[3] + tb * a[3];
2380 t = a[3] * b[3];
2381 out[0] += 0.28209479f * t;
2382 out[6] -= 0.12615663f * t;
2383 out[8] += 0.21850969f * t;
2384
2385 ta = 0.28209479f * a[0] - 0.18022375f * a[6];
2386 tb = 0.28209479f * b[0] - 0.18022375f * b[6];
2387 out[4] += ta * b[4] + tb * a[4];
2388 t = a[4] * b[4];
2389 out[0] += 0.28209479f * t;
2390 out[6] -= 0.18022375f * t;
2391
2392 ta = 0.15607835f * a[7];
2393 tb = 0.15607835f * b[7];
2394 out[4] += ta * b[5] + tb * a[5];
2395 out[5] += ta * b[4] + tb * a[4];
2396 t = a[4] * b[5] + a[5] * b[4];
2397 out[7] += 0.15607834f * t;
2398
2399 ta = 0.28209479f * a[0] + 0.09011186 * a[6] - 0.15607835f * a[8];
2400 tb = 0.28209479f * b[0] + 0.09011186 * b[6] - 0.15607835f * b[8];
2401 out[5] += ta * b[5] + tb * a[5];
2402 t = a[5] * b[5];
2403 out[0] += 0.28209479f * t;
2404 out[6] += 0.09011186f * t;
2405 out[8] -= 0.15607835f * t;
2406
2407 ta = 0.28209480f * a[0];
2408 tb = 0.28209480f * b[0];
2409 out[6] += ta * b[6] + tb * a[6];
2410 t = a[6] * b[6];
2411 out[0] += 0.28209480f * t;
2412 out[6] += 0.18022376f * t;
2413
2414 ta = 0.28209479f * a[0] + 0.09011186 * a[6] + 0.15607835f * a[8];
2415 tb = 0.28209479f * b[0] + 0.09011186 * b[6] + 0.15607835f * b[8];
2416 out[7] += ta * b[7] + tb * a[7];
2417 t = a[7] * b[7];
2418 out[0] += 0.28209479f * t;
2419 out[6] += 0.09011186f * t;
2420 out[8] += 0.15607835f * t;
2421
2422 ta = 0.28209479f * a[0] - 0.18022375f * a[6];
2423 tb = 0.28209479f * b[0] - 0.18022375f * b[6];
2424 out[8] += ta * b[8] + tb * a[8];
2425 t = a[8] * b[8];
2426 out[0] += 0.28209479f * t;
2427 out[6] -= 0.18022375f * t;
2428
2429 return out;
2430 }
2431
2432 FLOAT * WINAPI D3DXSHMultiply4(FLOAT *out, CONST FLOAT *a, CONST FLOAT *b)
2433 {
2434 FLOAT ta, tb, t;
2435
2436 TRACE("out %p, a %p, b %p\n", out, a, b);
2437
2438 out[0] = 0.28209479f * a[0] * b[0];
2439
2440 ta = 0.28209479f * a[0] - 0.12615663f * a[6] - 0.21850969f * a[8];
2441 tb = 0.28209479f * b[0] - 0.12615663f * b[6] - 0.21850969f * b[8];
2442 out[1] = ta * b[1] + tb * a[1];
2443 t = a[1] * b[1];
2444 out[0] += 0.28209479f * t;
2445 out[6] = -0.12615663f * t;
2446 out[8] = -0.21850969f * t;
2447
2448 ta = 0.21850969f * a[3] - 0.05839917f * a[13] - 0.22617901f * a[15];
2449 tb = 0.21850969f * b[3] - 0.05839917f * b[13] - 0.22617901f * b[15];
2450 out[1] += ta * b[4] + tb * a[4];
2451 out[4] = ta * b[1] + tb * a[1];
2452 t = a[1] * b[4] + a[4] * b[1];
2453 out[3] = 0.21850969f * t;
2454 out[13] = -0.05839917f * t;
2455 out[15] = -0.22617901f * t;
2456
2457 ta = 0.21850969f * a[2] - 0.14304817f * a[12] - 0.18467439f * a[14];
2458 tb = 0.21850969f * b[2] - 0.14304817f * b[12] - 0.18467439f * b[14];
2459 out[1] += ta * b[5] + tb * a[5];
2460 out[5] = ta * b[1] + tb * a[1];
2461 t = a[1] * b[5] + a[5] * b[1];
2462 out[2] = 0.21850969f * t;
2463 out[12] = -0.14304817f * t;
2464 out[14] = -0.18467439f * t;
2465
2466 ta = 0.20230066f * a[11];
2467 tb = 0.20230066f * b[11];
2468 out[1] += ta * b[6] + tb * a[6];
2469 out[6] += ta * b[1] + tb * a[1];
2470 t = a[1] * b[6] + a[6] * b[1];
2471 out[11] = 0.20230066f * t;
2472
2473 ta = 0.22617901f * a[9] + 0.05839917f * a[11];
2474 tb = 0.22617901f * b[9] + 0.05839917f * b[11];
2475 out[1] += ta * b[8] + tb * a[8];
2476 out[8] += ta * b[1] + tb * a[1];
2477 t = a[1] * b[8] + a[8] * b[1];
2478 out[9] = 0.22617901f * t;
2479 out[11] += 0.05839917f * t;
2480
2481 ta = 0.28209480f * a[0] + 0.25231326f * a[6];
2482 tb = 0.28209480f * b[0] + 0.25231326f * b[6];
2483 out[2] += ta * b[2] + tb * a[2];
2484 t = a[2] * b[2];
2485 out[0] += 0.28209480f * t;
2486 out[6] += 0.25231326f * t;
2487
2488 ta = 0.24776671f * a[12];
2489 tb = 0.24776671f * b[12];
2490 out[2] += ta * b[6] + tb * a[6];
2491 out[6] += ta * b[2] + tb * a[2];
2492 t = a[2] * b[6] + a[6] * b[2];
2493 out[12] += 0.24776671f * t;
2494
2495 ta = 0.28209480f * a[0] - 0.12615663f * a[6] + 0.21850969f * a[8];
2496 tb = 0.28209480f * b[0] - 0.12615663f * b[6] + 0.21850969f * b[8];
2497 out[3] += ta * b[3] + tb * a[3];
2498 t = a[3] * b[3];
2499 out[0] += 0.28209480f * t;
2500 out[6] -= 0.12615663f * t;
2501 out[8] += 0.21850969f * t;
2502
2503 ta = 0.20230066f * a[13];
2504 tb = 0.20230066f * b[13];
2505 out[3] += ta * b[6] + tb * a[6];
2506 out[6] += ta * b[3] + tb * a[3];
2507 t = a[3] * b[6] + a[6] * b[3];
2508 out[13] += 0.20230066f * t;
2509
2510 ta = 0.21850969f * a[2] - 0.14304817f * a[12] + 0.18467439f * a[14];
2511 tb = 0.21850969f * b[2] - 0.14304817f * b[12] + 0.18467439f * b[14];
2512 out[3] += ta * b[7] + tb * a[7];
2513 out[7] = ta * b[3] + tb * a[3];
2514 t = a[3] * b[7] + a[7] * b[3];
2515 out[2] += 0.21850969f * t;
2516 out[12] -= 0.14304817f * t;
2517 out[14] += 0.18467439f * t;
2518
2519 ta = -0.05839917f * a[13] + 0.22617901f * a[15];
2520 tb = -0.05839917f * b[13] + 0.22617901f * b[15];
2521 out[3] += ta * b[8] + tb * a[8];
2522 out[8] += ta * b[3] + tb * a[3];
2523 t = a[3] * b[8] + a[8] * b[3];
2524 out[13] -= 0.05839917f * t;
2525 out[15] += 0.22617901f * t;
2526
2527 ta = 0.28209479f * a[0] - 0.18022375f * a[6];
2528 tb = 0.28209479f * b[0] - 0.18022375f * b[6];
2529 out[4] += ta * b[4] + tb * a[4];
2530 t = a[4] * b[4];
2531 out[0] += 0.28209479f * t;
2532 out[6] -= 0.18022375f * t;
2533
2534 ta = 0.15607835f * a[7];
2535 tb = 0.15607835f * b[7];
2536 out[4] += ta * b[5] + tb * a[5];
2537 out[5] += ta * b[4] + tb * a[4];
2538 t = a[4] * b[5] + a[5] * b[4];
2539 out[7] += 0.15607835f * t;
2540
2541 ta = 0.22617901f * a[3] - 0.09403160f * a[13];
2542 tb = 0.22617901f * b[3] - 0.09403160f * b[13];
2543 out[4] += ta * b[9] + tb * a[9];
2544 out[9] += ta * b[4] + tb * a[4];
2545 t = a[4] * b[9] + a[9] * b[4];
2546 out[3] += 0.22617901f * t;
2547 out[13] -= 0.09403160f * t;
2548
2549 ta = 0.18467439f * a[2] - 0.18806319f * a[12];
2550 tb = 0.18467439f * b[2] - 0.18806319f * b[12];
2551 out[4] += ta * b[10] + tb * a [10];
2552 out[10] = ta * b[4] + tb * a[4];
2553 t = a[4] * b[10] + a[10] * b[4];
2554 out[2] += 0.18467439f * t;
2555 out[12] -= 0.18806319f * t;
2556
2557 ta = -0.05839917f * a[3] + 0.14567312f * a[13] + 0.09403160f * a[15];
2558 tb = -0.05839917f * b[3] + 0.14567312f * b[13] + 0.09403160f * b[15];
2559 out[4] += ta * b[11] + tb * a[11];
2560 out[11] += ta * b[4] + tb * a[4];
2561 t = a[4] * b[11] + a[11] * b[4];
2562 out[3] -= 0.05839917f * t;
2563 out[13] += 0.14567312f * t;
2564 out[15] += 0.09403160f * t;
2565
2566 ta = 0.28209479f * a[0] + 0.09011186f * a[6] - 0.15607835f * a[8];
2567 tb = 0.28209479f * b[0] + 0.09011186f * b[6] - 0.15607835f * b[8];
2568 out[5] += ta * b[5] + tb * a[5];
2569 t = a[5] * b[5];
2570 out[0] += 0.28209479f * t;
2571 out[6] += 0.09011186f * t;
2572 out[8] -= 0.15607835f * t;
2573
2574 ta = 0.14867701f * a[14];
2575 tb = 0.14867701f * b[14];
2576 out[5] += ta * b[9] + tb * a[9];
2577 out[9] += ta * b[5] + tb * a[5];
2578 t = a[5] * b[9] + a[9] * b[5];
2579 out[14] += 0.14867701f * t;
2580
2581 ta = 0.18467439f * a[3] + 0.11516472f * a[13] - 0.14867701f * a[15];
2582 tb = 0.18467439f * b[3] + 0.11516472f * b[13] - 0.14867701f * b[15];
2583 out[5] += ta * b[10] + tb * a[10];
2584 out[10] += ta * b[5] + tb * a[5];
2585 t = a[5] * b[10] + a[10] * b[5];
2586 out[3] += 0.18467439f * t;
2587 out[13] += 0.11516472f * t;
2588 out[15] -= 0.14867701f * t;
2589
2590 ta = 0.23359668f * a[2] + 0.05947080f * a[12] - 0.11516472f * a[14];
2591 tb = 0.23359668f * b[2] + 0.05947080f * b[12] - 0.11516472f * b[14];
2592 out[5] += ta * b[11] + tb * a[11];
2593 out[11] += ta * b[5] + tb * a[5];
2594 t = a[5] * b[11] + a[11] * b[5];
2595 out[2] += 0.23359668f * t;
2596 out[12] += 0.05947080f * t;
2597 out[14] -= 0.11516472f * t;
2598
2599 ta = 0.28209479f * a[0];
2600 tb = 0.28209479f * b[0];
2601 out[6] += ta * b[6] + tb * a[6];
2602 t = a[6] * b[6];
2603 out[0] += 0.28209479f * t;
2604 out[6] += 0.18022376f * t;
2605
2606 ta = 0.09011186f * a[6] + 0.28209479f * a[0] + 0.15607835f * a[8];
2607 tb = 0.09011186f * b[6] + 0.28209479f * b[0] + 0.15607835f * b[8];
2608 out[7] += ta * b[7] + tb * a[7];
2609 t = a[7] * b[7];
2610 out[6] += 0.09011186f * t;
2611 out[0] += 0.28209479f * t;
2612 out[8] += 0.15607835f * t;
2613
2614 ta = 0.14867701f * a[9] + 0.18467439f * a[1] + 0.11516472f * a[11];
2615 tb = 0.14867701f * b[9] + 0.18467439f * b[1] + 0.11516472f * b[11];
2616 out[7] += ta * b[10] + tb * a[10];
2617 out[10] += ta * b[7] + tb * a[7];
2618 t = a[7] * b[10] + a[10] * b[7];
2619 out[9] += 0.14867701f * t;
2620 out[1] += 0.18467439f * t;
2621 out[11] += 0.11516472f * t;
2622
2623 ta = 0.05947080f * a[12] + 0.23359668f * a[2] + 0.11516472f * a[14];
2624 tb = 0.05947080f * b[12] + 0.23359668f * b[2] + 0.11516472f * b[14];
2625 out[7] += ta * b[13] + tb * a[13];
2626 out[13] += ta * b[7]+ tb * a[7];
2627 t = a[7] * b[13] + a[13] * b[7];
2628 out[12] += 0.05947080f * t;
2629 out[2] += 0.23359668f * t;
2630 out[14] += 0.11516472f * t;
2631
2632 ta = 0.14867701f * a[15];
2633 tb = 0.14867701f * b[15];
2634 out[7] += ta * b[14] + tb * a[14];
2635 out[14] += ta * b[7] + tb * a[7];
2636 t = a[7] * b[14] + a[14] * b[7];
2637 out[15] += 0.14867701f * t;
2638
2639 ta = 0.28209479f * a[0] - 0.18022375f * a[6];
2640 tb = 0.28209479f * b[0] - 0.18022375f * b[6];
2641 out[8] += ta * b[8] + tb * a[8];
2642 t = a[8] * b[8];
2643 out[0] += 0.28209479f * t;
2644 out[6] -= 0.18022375f * t;
2645
2646 ta = -0.09403160f * a[11];
2647 tb = -0.09403160f * b[11];
2648 out[8] += ta * b[9] + tb * a[9];
2649 out[9] += ta * b[8] + tb * a[8];
2650 t = a[8] * b[9] + a[9] * b[8];
2651 out[11] -= 0.09403160f * t;
2652
2653 ta = -0.09403160f * a[15];
2654 tb = -0.09403160f * b[15];
2655 out[8] += ta * b[13] + tb * a[13];
2656 out[13] += ta * b[8] + tb * a[8];
2657 t = a[8] * b[13] + a[13] * b[8];
2658 out[15] -= 0.09403160f * t;
2659
2660 ta = 0.18467439f * a[2] - 0.18806319f * a[12];
2661 tb = 0.18467439f * b[2] - 0.18806319f * b[12];
2662 out[8] += ta * b[14] + tb * a[14];
2663 out[14] += ta * b[8] + tb * a[8];
2664 t = a[8] * b[14] + a[14] * b[8];
2665 out[2] += 0.18467439f * t;
2666 out[12] -= 0.18806319f * t;
2667
2668 ta = -0.21026104f * a[6] + 0.28209479f * a[0];
2669 tb = -0.21026104f * b[6] + 0.28209479f * b[0];
2670 out[9] += ta * b[9] + tb * a[9];
2671 t = a[9] * b[9];
2672 out[6] -= 0.21026104f * t;
2673 out[0] += 0.28209479f * t;
2674
2675 ta = 0.28209479f * a[0];
2676 tb = 0.28209479f * b[0];
2677 out[10] += ta * b[10] + tb * a[10];
2678 t = a[10] * b[10];
2679 out[0] += 0.28209479f * t;
2680
2681 ta = 0.28209479f * a[0] + 0.12615663f * a[6] - 0.14567312f * a[8];
2682 tb = 0.28209479f * b[0] + 0.12615663f * b[6] - 0.14567312f * b[8];
2683 out[11] += ta * b[11] + tb * a[11];
2684 t = a[11] * b[11];
2685 out[0] += 0.28209479f * t;
2686 out[6] += 0.12615663f * t;
2687 out[8] -= 0.14567312f * t;
2688
2689 ta = 0.28209479f * a[0] + 0.16820885f * a[6];
2690 tb = 0.28209479f * b[0] + 0.16820885f * b[6];
2691 out[12] += ta * b[12] + tb * a[12];
2692 t = a[12] * b[12];
2693 out[0] += 0.28209479f * t;
2694 out[6] += 0.16820885f * t;
2695
2696 ta =0.28209479f * a[0] + 0.14567312f * a[8] + 0.12615663f * a[6];
2697 tb =0.28209479f * b[0] + 0.14567312f * b[8] + 0.12615663f * b[6];
2698 out[13] += ta * b[13] + tb * a[13];
2699 t = a[13] * b[13];
2700 out[0] += 0.28209479f * t;
2701 out[8] += 0.14567312f * t;
2702 out[6] += 0.12615663f * t;
2703
2704 ta = 0.28209479f * a[0];
2705 tb = 0.28209479f * b[0];
2706 out[14] += ta * b[14] + tb * a[14];
2707 t = a[14] * b[14];
2708 out[0] += 0.28209479f * t;
2709
2710 ta = 0.28209479f * a[0] - 0.21026104f * a[6];
2711 tb = 0.28209479f * b[0] - 0.21026104f * b[6];
2712 out[15] += ta * b[15] + tb * a[15];
2713 t = a[15] * b[15];
2714 out[0] += 0.28209479f * t;
2715 out[6] -= 0.21026104f * t;
2716
2717 return out;
2718 }
2719
2720 static void rotate_X(FLOAT *out, UINT order, FLOAT a, FLOAT *in)
2721 {
2722 out[0] = in[0];
2723 if ( order < 2 )
2724 return;
2725
2726 out[1] = a * in[2];
2727 out[2] = -a * in[1];
2728 out[3] = in[3];
2729 if ( order == 2 )
2730 return;
2731
2732 out[4] = a * in[7];
2733 out[5] = -in[5];
2734 out[6] = -0.5f * in[6] - 0.8660253882f * in[8];
2735 out[7] = -a * in[4];
2736 out[8] = -0.8660253882f * in[6] + 0.5f * in[8];
2737 out[9] = -a * 0.7905694842f * in[12] + a * 0.6123724580f * in[14];
2738 if ( order == 3 )
2739 return;
2740
2741 out[10] = -in[10];
2742 out[11] = -a * 0.6123724580f * in[12] - a * 0.7905694842f * in[14];
2743 out[12] = a * 0.7905694842f * in[9] + a * 0.6123724580f * in[11];
2744 out[13] = -0.25f * in[13] - 0.9682458639f * in[15];
2745 out[14] = -a * 0.6123724580f * in[9] + a * 0.7905694842f * in[11];
2746 out[15] = -0.9682458639f * in[13] + 0.25f * in[15];
2747 if ( order == 4 )
2748 return;
2749
2750 out[16] = -a * 0.9354143739f * in[21] + a * 0.3535533845f * in[23];
2751 out[17] = -0.75f * in[17] + 0.6614378095f * in[19];
2752 out[18] = -a * 0.3535533845f * in[21] - a * 0.9354143739f * in[23];
2753 out[19] = 0.6614378095f * in[17] + 0.75f * in[19];
2754 out[20] = 0.375f * in[20] + 0.5590170026f * in[22] + 0.7395099998f * in[24];
2755 out[21] = a * 0.9354143739f * in[16] + a * 0.3535533845f * in[18];
2756 out[22] = 0.5590170026f * in[20] + 0.5f * in[22] - 0.6614378691f * in[24];
2757 out[23] = -a * 0.3535533845f * in[16] + a * 0.9354143739f * in[18];
2758 out[24] = 0.7395099998f * in[20] - 0.6614378691f * in[22] + 0.125f * in[24];
2759 if ( order == 5 )
2760 return;
2761
2762 out[25] = a * 0.7015607357f * in[30] - a * 0.6846531630f * in[32] + a * 0.1976423711f * in[34];
2763 out[26] = -0.5f * in[26] + 0.8660253882f * in[28];
2764 out[27] = a * 0.5229125023f * in[30] + a * 0.3061861992f * in[32] - a * 0.7954951525 * in[34];
2765 out[28] = 0.8660253882f * in[26] + 0.5f * in[28];
2766 out[29] = a * 0.4841229022f * in[30] + a * 0.6614378691f * in[32] + a * 0.5728219748f * in[34];
2767 out[30] = -a * 0.7015607357f * in[25] - a * 0.5229125023f * in[27] - a * 0.4841229022f * in[29];
2768 out[31] = 0.125f * in[31] + 0.4050463140f * in[33] + 0.9057110548f * in[35];
2769 out[32] = a * 0.6846531630f * in[25] - a * 0.3061861992f * in[27] - a * 0.6614378691f * in[29];
2770 out[33] = 0.4050463140f * in[31] + 0.8125f * in[33] - 0.4192627370f * in[35];
2771 out[34] = -a * 0.1976423711f * in[25] + a * 0.7954951525f * in[27] - a * 0.5728219748f * in[29];
2772 out[35] = 0.9057110548f * in[31] - 0.4192627370f * in[33] + 0.0624999329f * in[35];
2773
2774 }
2775
2776 FLOAT* WINAPI D3DXSHRotate(FLOAT *out, UINT order, CONST D3DXMATRIX *matrix, CONST FLOAT *in)
2777 {
2778 FLOAT alpha, beta, gamma, sinb, temp[36];
2779
2780 TRACE("out %p, order %u, matrix %p, in %p\n", out, order, matrix, in);
2781
2782 out[0] = in[0];
2783
2784 if ( ( order > D3DXSH_MAXORDER ) || ( order < D3DXSH_MINORDER ) )
2785 return out;
2786
2787 /* TODO: Implement handy computations for order <= 3. They are faster than the general algorithm. */
2788 if ( order < 4 )
2789 WARN("Using general algorithm for order = %u\n", order);
2790
2791 if ( fabsf( matrix->u.m[2][2] ) != 1.0f )
2792 {
2793 sinb = sqrtf( 1.0f - matrix->u.m[2][2] * matrix->u.m[2][2] );
2794 alpha = atan2f(matrix->u.m[2][1] / sinb, matrix->u.m[2][0] / sinb );
2795 beta = atan2f( sinb, matrix->u.m[2][2] );
2796 gamma = atan2f( matrix->u.m[1][2] / sinb, -matrix->u.m[0][2] / sinb );
2797 }
2798 else
2799 {
2800 alpha = atan2f( matrix->u.m[0][1], matrix->u.m[0][0] );
2801 beta = 0.0f;
2802 gamma = 0.0f;
2803 }
2804
2805 D3DXSHRotateZ(out, order, gamma, in);
2806 rotate_X(temp, order, 1.0f, out);
2807 D3DXSHRotateZ(out, order, beta, temp);
2808 rotate_X(temp, order, -1.0f, out);
2809 D3DXSHRotateZ(out, order, alpha, temp);
2810
2811 return out;
2812 }
2813
2814 FLOAT * WINAPI D3DXSHRotateZ(FLOAT *out, UINT order, FLOAT angle, CONST FLOAT *in)
2815 {
2816 FLOAT c1a, c2a, c3a, c4a, c5a, s1a, s2a, s3a, s4a, s5a;
2817
2818 TRACE("out %p, order %u, angle %f, in %p\n", out, order, angle, in);
2819
2820 c1a = cosf(angle);
2821 s1a = sinf(angle);
2822 out[0] = in[0];
2823 out[1] = c1a * in[1] + s1a * in[3];
2824 out[2] = in[2];
2825 out[3] = c1a * in[3] - s1a * in[1];
2826 if (order <= D3DXSH_MINORDER)
2827 return out;
2828
2829 c2a = cosf(2.0f * angle);
2830 s2a = sinf(2.0f * angle);
2831 out[4] = c2a * in[4] + s2a * in[8];
2832 out[5] = c1a * in[5] + s1a * in[7];
2833 out[6] = in[6];
2834 out[7] = c1a * in[7] - s1a * in[5];
2835 out[8] = c2a * in[8] - s2a * in[4];
2836 if (order == 3)
2837 return out;
2838
2839 c3a = cosf(3.0f * angle);
2840 s3a = sinf(3.0f * angle);
2841 out[9] = c3a * in[9] + s3a * in[15];
2842 out[10] = c2a * in[10] + s2a * in[14];
2843 out[11] = c1a * in[11] + s1a * in[13];
2844 out[12] = in[12];
2845 out[13] = c1a * in[13] - s1a * in[11];
2846 out[14] = c2a * in[14] - s2a * in[10];
2847 out[15] = c3a * in[15] - s3a * in[9];
2848 if (order == 4)
2849 return out;
2850
2851 c4a = cosf(4.0f * angle);
2852 s4a = sinf(4.0f * angle);
2853 out[16] = c4a * in[16] + s4a * in[24];
2854 out[17] = c3a * in[17] + s3a * in[23];
2855 out[18] = c2a * in[18] + s2a * in[22];
2856 out[19] = c1a * in[19] + s1a * in[21];
2857 out[20] = in[20];
2858 out[21] = c1a * in[21] - s1a * in[19];
2859 out[22] = c2a * in[22] - s2a * in[18];
2860 out[23] = c3a * in[23] - s3a * in[17];
2861 out[24] = c4a * in[24] - s4a * in[16];
2862 if (order == 5)
2863 return out;
2864
2865 c5a = cosf(5.0f * angle);
2866 s5a = sinf(5.0f * angle);
2867 out[25] = c5a * in[25] + s5a * in[35];
2868 out[26] = c4a * in[26] + s4a * in[34];
2869 out[27] = c3a * in[27] + s3a * in[33];
2870 out[28] = c2a * in[28] + s2a * in[32];
2871 out[29] = c1a * in[29] + s1a * in[31];
2872 out[30] = in[30];
2873 out[31] = c1a * in[31] - s1a * in[29];
2874 out[32] = c2a * in[32] - s2a * in[28];
2875 out[33] = c3a * in[33] - s3a * in[27];
2876 out[34] = c4a * in[34] - s4a * in[26];
2877 out[35] = c5a * in[35] - s5a * in[25];
2878
2879 return out;
2880 }
2881
2882 FLOAT* WINAPI D3DXSHScale(FLOAT *out, UINT order, CONST FLOAT *a, CONST FLOAT scale)
2883 {
2884 UINT i;
2885
2886 TRACE("out %p, order %u, a %p, scale %f\n", out, order, a, scale);
2887
2888 for (i = 0; i < order * order; i++)
2889 out[i] = a[i] * scale;
2890
2891 return out;
2892 }
Windows API implementation