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