ole32: Implement OleCreateEmbeddingHelper.
[wine] / dlls / d3dx9_36 / math.c
1 /*
2  * Mathematical operations specific to D3DX9.
3  *
4  * Copyright (C) 2008 David Adam
5  * Copyright (C) 2008 Philip Nilsson
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #define NONAMELESSUNION
23
24 #include "config.h"
25 #include "windef.h"
26 #include "wingdi.h"
27 #include "d3dx9.h"
28
29
30 /*************************************************************************
31  * D3DXMatrixAffineTransformation2D
32  */
33 D3DXMATRIX* WINAPI D3DXMatrixAffineTransformation2D(
34     D3DXMATRIX *pout, FLOAT scaling,
35     CONST D3DXVECTOR2 *protationcenter, FLOAT rotation,
36     CONST D3DXVECTOR2 *ptranslation)
37 {
38     D3DXMATRIX m1, m2, m3, m4, m5;
39     D3DXQUATERNION rot;
40     D3DXVECTOR3 rot_center, trans;
41
42     rot.w=cos(rotation/2.0f);
43     rot.x=0.0f;
44     rot.y=0.0f;
45     rot.z=sin(rotation/2.0f);
46
47     if ( protationcenter )
48     {
49         rot_center.x=protationcenter->x;
50         rot_center.y=protationcenter->y;
51         rot_center.z=0.0f;
52     }
53     else
54     {
55         rot_center.x=0.0f;
56         rot_center.y=0.0f;
57         rot_center.z=0.0f;
58     }
59
60     if ( ptranslation )
61     {
62         trans.x=ptranslation->x;
63         trans.y=ptranslation->y;
64         trans.z=0.0f;
65     }
66     else
67     {
68         trans.x=0.0f;
69         trans.y=0.0f;
70         trans.z=0.0f;
71     }
72
73     D3DXMatrixScaling(&m1, scaling, scaling, 1.0f);
74     D3DXMatrixTranslation(&m2, -rot_center.x, -rot_center.y, -rot_center.z);
75     D3DXMatrixTranslation(&m4, rot_center.x, rot_center.y, rot_center.z);
76     D3DXMatrixRotationQuaternion(&m3, &rot);
77     D3DXMatrixTranslation(&m5, trans.x, trans.y, trans.z);
78
79     D3DXMatrixMultiply(&m1, &m1, &m2);
80     D3DXMatrixMultiply(&m1, &m1, &m3);
81     D3DXMatrixMultiply(&m1, &m1, &m4);
82     D3DXMatrixMultiply(pout, &m1, &m5);
83
84     return pout;
85 }
86
87 /*************************************************************************
88  * D3DXMatrixDecompose
89  */
90 HRESULT WINAPI D3DXMatrixDecompose(D3DXVECTOR3 *poutscale, D3DXQUATERNION *poutrotation, D3DXVECTOR3 *pouttranslation, D3DXMATRIX *pm)
91 {
92     D3DXMATRIX normalized;
93     D3DXVECTOR3 vec;
94
95     /*Compute the scaling part.*/
96     vec.x=pm->u.m[0][0];
97     vec.y=pm->u.m[0][1];
98     vec.z=pm->u.m[0][2];
99     poutscale->x=D3DXVec3Length(&vec);
100
101     vec.x=pm->u.m[1][0];
102     vec.y=pm->u.m[1][1];
103     vec.z=pm->u.m[1][2];
104     poutscale->y=D3DXVec3Length(&vec);
105
106     vec.x=pm->u.m[2][0];
107     vec.y=pm->u.m[2][1];
108     vec.z=pm->u.m[2][2];
109     poutscale->z=D3DXVec3Length(&vec);
110
111     /*Compute the translation part.*/
112     pouttranslation->x=pm->u.m[3][0];
113     pouttranslation->y=pm->u.m[3][1];
114     pouttranslation->z=pm->u.m[3][2];
115
116     /*Let's calculate the rotation now*/
117     if ( (poutscale->x == 0.0f) || (poutscale->y == 0.0f) || (poutscale->z == 0.0f) )
118     {
119      return D3DERR_INVALIDCALL;
120     }
121
122     normalized.u.m[0][0]=pm->u.m[0][0]/poutscale->x;
123     normalized.u.m[0][1]=pm->u.m[0][1]/poutscale->x;
124     normalized.u.m[0][2]=pm->u.m[0][2]/poutscale->x;
125     normalized.u.m[1][0]=pm->u.m[1][0]/poutscale->y;
126     normalized.u.m[1][1]=pm->u.m[1][1]/poutscale->y;
127     normalized.u.m[1][2]=pm->u.m[1][2]/poutscale->y;
128     normalized.u.m[2][0]=pm->u.m[2][0]/poutscale->z;
129     normalized.u.m[2][1]=pm->u.m[2][1]/poutscale->z;
130     normalized.u.m[2][2]=pm->u.m[2][2]/poutscale->z;
131
132     D3DXQuaternionRotationMatrix(poutrotation,&normalized);
133     return S_OK;
134 }
135
136 /*************************************************************************
137  * D3DXMatrixTransformation2D
138  */
139 D3DXMATRIX* WINAPI D3DXMatrixTransformation2D(
140     D3DXMATRIX *pout, CONST D3DXVECTOR2 *pscalingcenter,
141     FLOAT scalingrotation, CONST D3DXVECTOR2 *pscaling,
142     CONST D3DXVECTOR2 *protationcenter, FLOAT rotation,
143     CONST D3DXVECTOR2 *ptranslation)
144 {
145     D3DXQUATERNION rot, sca_rot;
146     D3DXVECTOR3 rot_center, sca, sca_center, trans;
147
148     if ( pscalingcenter )
149     {
150         sca_center.x=pscalingcenter->x;
151         sca_center.y=pscalingcenter->y;
152         sca_center.z=0.0f;
153     }
154     else
155     {
156         sca_center.x=0.0f;
157         sca_center.y=0.0f;
158         sca_center.z=0.0f;
159     }
160
161     if ( pscaling )
162     {
163         sca.x=pscaling->x;
164         sca.y=pscaling->y;
165         sca.z=1.0f;
166     }
167     else
168     {
169         sca.x=1.0f;
170         sca.y=1.0f;
171         sca.z=1.0f;
172     }
173
174     if ( protationcenter )
175     {
176         rot_center.x=protationcenter->x;
177         rot_center.y=protationcenter->y;
178         rot_center.z=0.0f;
179     }
180     else
181     {
182         rot_center.x=0.0f;
183         rot_center.y=0.0f;
184         rot_center.z=0.0f;
185     }
186
187     if ( ptranslation )
188     {
189         trans.x=ptranslation->x;
190         trans.y=ptranslation->y;
191         trans.z=0.0f;
192     }
193     else
194     {
195         trans.x=0.0f;
196         trans.y=0.0f;
197         trans.z=0.0f;
198     }
199
200     rot.w=cos(rotation/2.0f);
201     rot.x=0.0f;
202     rot.y=0.0f;
203     rot.z=sin(rotation/2.0f);
204
205     sca_rot.w=cos(scalingrotation/2.0f);
206     sca_rot.x=0.0f;
207     sca_rot.y=0.0f;
208     sca_rot.z=sin(scalingrotation/2.0f);
209
210     D3DXMatrixTransformation(pout, &sca_center, &sca_rot, &sca, &rot_center, &rot, &trans);
211
212     return pout;
213 }
214
215 /*************************************************************************
216  * D3DXPlaneTransformArray
217  */
218 D3DXPLANE* WINAPI D3DXPlaneTransformArray(
219     D3DXPLANE* out, UINT outstride, CONST D3DXPLANE* in, UINT instride,
220     CONST D3DXMATRIX* matrix, UINT elements)
221 {
222     UINT i;
223
224     for (i = 0; i < elements; ++i) {
225         D3DXPlaneTransform(
226             (D3DXPLANE*)((char*)out + outstride * i),
227             (CONST D3DXPLANE*)((const char*)in + instride * i),
228             matrix);
229     }
230     return out;
231 }
232
233 /*************************************************************************
234  * D3DXVec2TransformArray
235  *
236  * Transform an array of vectors by a matrix.
237  */
238 D3DXVECTOR4* WINAPI D3DXVec2TransformArray(
239     D3DXVECTOR4* out, UINT outstride, CONST D3DXVECTOR2* in, UINT instride,
240     CONST D3DXMATRIX* matrix, UINT elements)
241 {
242     UINT i;
243
244     for (i = 0; i < elements; ++i) {
245         D3DXVec2Transform(
246             (D3DXVECTOR4*)((char*)out + outstride * i),
247             (CONST D3DXVECTOR2*)((const char*)in + instride * i),
248             matrix);
249     }
250     return out;
251 }
252
253 /*************************************************************************
254  * D3DXVec2TransformCoordArray
255  */
256 D3DXVECTOR2* WINAPI D3DXVec2TransformCoordArray(
257     D3DXVECTOR2* out, UINT outstride, CONST D3DXVECTOR2* in, UINT instride,
258     CONST D3DXMATRIX* matrix, UINT elements)
259 {
260     UINT i;
261
262     for (i = 0; i < elements; ++i) {
263         D3DXVec2TransformCoord(
264             (D3DXVECTOR2*)((char*)out + outstride * i),
265             (CONST D3DXVECTOR2*)((const char*)in + instride * i),
266             matrix);
267     }
268     return out;
269 }
270
271 /*************************************************************************
272  * D3DXVec2TransformNormalArray
273  */
274 D3DXVECTOR2* WINAPI D3DXVec2TransformNormalArray(
275     D3DXVECTOR2* out, UINT outstride, CONST D3DXVECTOR2 *in, UINT instride,
276     CONST D3DXMATRIX *matrix, UINT elements)
277 {
278     UINT i;
279
280     for (i = 0; i < elements; ++i) {
281         D3DXVec2TransformNormal(
282             (D3DXVECTOR2*)((char*)out + outstride * i),
283             (CONST D3DXVECTOR2*)((const char*)in + instride * i),
284             matrix);
285     }
286     return out;
287 }
288
289 /*************************************************************************
290  * D3DXVec3ProjectArray
291  *
292  * Projects an array of vectors to the screen.
293  */
294 D3DXVECTOR3* WINAPI D3DXVec3ProjectArray(
295     D3DXVECTOR3* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride,
296     CONST D3DVIEWPORT9* viewport, CONST D3DXMATRIX* projection,
297     CONST D3DXMATRIX* view, CONST D3DXMATRIX* world, UINT elements)
298 {
299     UINT i;
300
301     for (i = 0; i < elements; ++i) {
302         D3DXVec3Project(
303             (D3DXVECTOR3*)((char*)out + outstride * i),
304             (CONST D3DXVECTOR3*)((const char*)in + instride * i),
305             viewport, projection, view, world);
306     }
307     return out;
308 }
309
310 /*************************************************************************
311  * D3DXVec3TransformArray
312  */
313 D3DXVECTOR4* WINAPI D3DXVec3TransformArray(
314     D3DXVECTOR4* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride,
315     CONST D3DXMATRIX* matrix, UINT elements)
316 {
317     UINT i;
318
319     for (i = 0; i < elements; ++i) {
320         D3DXVec3Transform(
321             (D3DXVECTOR4*)((char*)out + outstride * i),
322             (CONST D3DXVECTOR3*)((const char*)in + instride * i),
323             matrix);
324     }
325     return out;
326 }
327
328 /*************************************************************************
329  * D3DXVec3TransformCoordArray
330  */
331 D3DXVECTOR3* WINAPI D3DXVec3TransformCoordArray(
332     D3DXVECTOR3* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride,
333     CONST D3DXMATRIX* matrix, UINT elements)
334 {
335     UINT i;
336
337     for (i = 0; i < elements; ++i) {
338         D3DXVec3TransformCoord(
339             (D3DXVECTOR3*)((char*)out + outstride * i),
340             (CONST D3DXVECTOR3*)((const char*)in + instride * i),
341             matrix);
342     }
343     return out;
344 }
345
346 /*************************************************************************
347  * D3DXVec3TransformNormalArray
348  */
349 D3DXVECTOR3* WINAPI D3DXVec3TransformNormalArray(
350     D3DXVECTOR3* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride,
351     CONST D3DXMATRIX* matrix, UINT elements)
352 {
353     UINT i;
354
355     for (i = 0; i < elements; ++i) {
356         D3DXVec3TransformNormal(
357             (D3DXVECTOR3*)((char*)out + outstride * i),
358             (CONST D3DXVECTOR3*)((const char*)in + instride * i),
359             matrix);
360     }
361     return out;
362 }
363
364 /*************************************************************************
365  * D3DXVec3UnprojectArray
366  */
367 D3DXVECTOR3* WINAPI D3DXVec3UnprojectArray(
368     D3DXVECTOR3* out, UINT outstride, CONST D3DXVECTOR3* in, UINT instride,
369     CONST D3DVIEWPORT9* viewport, CONST D3DXMATRIX* projection,
370     CONST D3DXMATRIX* view, CONST D3DXMATRIX* world, UINT elements)
371 {
372     UINT i;
373
374     for (i = 0; i < elements; ++i) {
375         D3DXVec3Unproject(
376             (D3DXVECTOR3*)((char*)out + outstride * i),
377             (CONST D3DXVECTOR3*)((const char*)in + instride * i),
378             viewport, projection, view, world);
379     }
380     return out;
381 }
382
383 /*************************************************************************
384  * D3DXVec4TransformArray
385  */
386 D3DXVECTOR4* WINAPI D3DXVec4TransformArray(
387     D3DXVECTOR4* out, UINT outstride, CONST D3DXVECTOR4* in, UINT instride,
388     CONST D3DXMATRIX* matrix, UINT elements)
389 {
390     UINT i;
391
392     for (i = 0; i < elements; ++i) {
393         D3DXVec4Transform(
394             (D3DXVECTOR4*)((char*)out + outstride * i),
395             (CONST D3DXVECTOR4*)((const char*)in + instride * i),
396             matrix);
397     }
398     return out;
399 }