2 * Copyright 2007 David Adam
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #define NONAMELESSUNION
29 #include "d3dx8_private.h"
31 #include "wine/debug.h"
33 WINE_DEFAULT_DEBUG_CHANNEL(d3dx8
);
35 static const ID3DXMatrixStackVtbl ID3DXMatrixStack_Vtbl
;
37 /*_________________D3DXColor____________________*/
39 D3DXCOLOR
* WINAPI
D3DXColorAdjustContrast(D3DXCOLOR
*pout
, CONST D3DXCOLOR
*pc
, FLOAT s
)
41 pout
->r
= 0.5f
+ s
* (pc
->r
- 0.5f
);
42 pout
->g
= 0.5f
+ s
* (pc
->g
- 0.5f
);
43 pout
->b
= 0.5f
+ s
* (pc
->b
- 0.5f
);
48 D3DXCOLOR
* WINAPI
D3DXColorAdjustSaturation(D3DXCOLOR
*pout
, CONST D3DXCOLOR
*pc
, FLOAT s
)
52 grey
= pc
->r
* 0.2125f
+ pc
->g
* 0.7154f
+ pc
->b
* 0.0721f
;
53 pout
->r
= grey
+ s
* (pc
->r
- grey
);
54 pout
->g
= grey
+ s
* (pc
->g
- grey
);
55 pout
->b
= grey
+ s
* (pc
->b
- grey
);
60 /*_________________D3DXMatrix____________________*/
62 D3DXMATRIX
* WINAPI
D3DXMatrixAffineTransformation(D3DXMATRIX
*pout
, FLOAT scaling
, CONST D3DXVECTOR3
*rotationcenter
, CONST D3DXQUATERNION
*rotation
, CONST D3DXVECTOR3
*translation
)
64 D3DXMATRIX m1
, m2
, m3
, m4
, m5
;
66 D3DXMatrixScaling(&m1
, scaling
, scaling
, scaling
);
67 if ( !rotationcenter
)
69 D3DXMatrixIdentity(&m2
);
70 D3DXMatrixIdentity(&m4
);
74 D3DXMatrixTranslation(&m2
, -rotationcenter
->x
, -rotationcenter
->y
, -rotationcenter
->z
);
75 D3DXMatrixTranslation(&m4
, rotationcenter
->x
, rotationcenter
->y
, rotationcenter
->z
);
79 D3DXMatrixIdentity(&m3
);
83 D3DXMatrixRotationQuaternion(&m3
, rotation
);
87 D3DXMatrixIdentity(&m5
);
91 D3DXMatrixTranslation(&m5
, translation
->x
, translation
->y
, translation
->z
);
93 D3DXMatrixMultiply(&m1
, &m1
, &m2
);
94 D3DXMatrixMultiply(&m1
, &m1
, &m3
);
95 D3DXMatrixMultiply(&m1
, &m1
, &m4
);
96 D3DXMatrixMultiply(pout
, &m1
, &m5
);
100 FLOAT WINAPI
D3DXMatrixfDeterminant(CONST D3DXMATRIX
*pm
)
102 D3DXVECTOR4 minor
, v1
, v2
, v3
;
105 v1
.x
= pm
->u
.m
[0][0]; v1
.y
= pm
->u
.m
[1][0]; v1
.z
= pm
->u
.m
[2][0]; v1
.w
= pm
->u
.m
[3][0];
106 v2
.x
= pm
->u
.m
[0][1]; v2
.y
= pm
->u
.m
[1][1]; v2
.z
= pm
->u
.m
[2][1]; v2
.w
= pm
->u
.m
[3][1];
107 v3
.x
= pm
->u
.m
[0][2]; v3
.y
= pm
->u
.m
[1][2]; v3
.z
= pm
->u
.m
[2][2]; v3
.w
= pm
->u
.m
[3][2];
108 D3DXVec4Cross(&minor
, &v1
, &v2
, &v3
);
109 det
= - (pm
->u
.m
[0][3] * minor
.x
+ pm
->u
.m
[1][3] * minor
.y
+ pm
->u
.m
[2][3] * minor
.z
+ pm
->u
.m
[3][3] * minor
.w
);
113 D3DXMATRIX
* WINAPI
D3DXMatrixInverse(D3DXMATRIX
*pout
, FLOAT
*pdeterminant
, CONST D3DXMATRIX
*pm
)
116 D3DXVECTOR4 v
, vec
[3];
119 det
= D3DXMatrixfDeterminant(pm
);
120 if ( !det
) return NULL
;
121 if ( pdeterminant
) *pdeterminant
= det
;
129 if ( j
> i
) a
= a
-1;
130 vec
[a
].x
= pm
->u
.m
[j
][0];
131 vec
[a
].y
= pm
->u
.m
[j
][1];
132 vec
[a
].z
= pm
->u
.m
[j
][2];
133 vec
[a
].w
= pm
->u
.m
[j
][3];
136 D3DXVec4Cross(&v
, &vec
[0], &vec
[1], &vec
[2]);
137 pout
->u
.m
[0][i
] = pow(-1.0f
, i
) * v
.x
/ det
;
138 pout
->u
.m
[1][i
] = pow(-1.0f
, i
) * v
.y
/ det
;
139 pout
->u
.m
[2][i
] = pow(-1.0f
, i
) * v
.z
/ det
;
140 pout
->u
.m
[3][i
] = pow(-1.0f
, i
) * v
.w
/ det
;
145 D3DXMATRIX
* WINAPI
D3DXMatrixLookAtLH(D3DXMATRIX
*pout
, CONST D3DXVECTOR3
*peye
, CONST D3DXVECTOR3
*pat
, CONST D3DXVECTOR3
*pup
)
147 D3DXVECTOR3 right
, rightn
, up
, upn
, vec
, vec2
;
149 D3DXVec3Subtract(&vec2
, pat
, peye
);
150 D3DXVec3Normalize(&vec
, &vec2
);
151 D3DXVec3Cross(&right
, pup
, &vec
);
152 D3DXVec3Cross(&up
, &vec
, &right
);
153 D3DXVec3Normalize(&rightn
, &right
);
154 D3DXVec3Normalize(&upn
, &up
);
155 pout
->u
.m
[0][0] = rightn
.x
;
156 pout
->u
.m
[1][0] = rightn
.y
;
157 pout
->u
.m
[2][0] = rightn
.z
;
158 pout
->u
.m
[3][0] = -D3DXVec3Dot(&rightn
,peye
);
159 pout
->u
.m
[0][1] = upn
.x
;
160 pout
->u
.m
[1][1] = upn
.y
;
161 pout
->u
.m
[2][1] = upn
.z
;
162 pout
->u
.m
[3][1] = -D3DXVec3Dot(&upn
, peye
);
163 pout
->u
.m
[0][2] = vec
.x
;
164 pout
->u
.m
[1][2] = vec
.y
;
165 pout
->u
.m
[2][2] = vec
.z
;
166 pout
->u
.m
[3][2] = -D3DXVec3Dot(&vec
, peye
);
167 pout
->u
.m
[0][3] = 0.0f
;
168 pout
->u
.m
[1][3] = 0.0f
;
169 pout
->u
.m
[2][3] = 0.0f
;
170 pout
->u
.m
[3][3] = 1.0f
;
174 D3DXMATRIX
* WINAPI
D3DXMatrixLookAtRH(D3DXMATRIX
*pout
, CONST D3DXVECTOR3
*peye
, CONST D3DXVECTOR3
*pat
, CONST D3DXVECTOR3
*pup
)
176 D3DXVECTOR3 right
, rightn
, up
, upn
, vec
, vec2
;
178 D3DXVec3Subtract(&vec2
, pat
, peye
);
179 D3DXVec3Normalize(&vec
, &vec2
);
180 D3DXVec3Cross(&right
, pup
, &vec
);
181 D3DXVec3Cross(&up
, &vec
, &right
);
182 D3DXVec3Normalize(&rightn
, &right
);
183 D3DXVec3Normalize(&upn
, &up
);
184 pout
->u
.m
[0][0] = -rightn
.x
;
185 pout
->u
.m
[1][0] = -rightn
.y
;
186 pout
->u
.m
[2][0] = -rightn
.z
;
187 pout
->u
.m
[3][0] = D3DXVec3Dot(&rightn
,peye
);
188 pout
->u
.m
[0][1] = upn
.x
;
189 pout
->u
.m
[1][1] = upn
.y
;
190 pout
->u
.m
[2][1] = upn
.z
;
191 pout
->u
.m
[3][1] = -D3DXVec3Dot(&upn
, peye
);
192 pout
->u
.m
[0][2] = -vec
.x
;
193 pout
->u
.m
[1][2] = -vec
.y
;
194 pout
->u
.m
[2][2] = -vec
.z
;
195 pout
->u
.m
[3][2] = D3DXVec3Dot(&vec
, peye
);
196 pout
->u
.m
[0][3] = 0.0f
;
197 pout
->u
.m
[1][3] = 0.0f
;
198 pout
->u
.m
[2][3] = 0.0f
;
199 pout
->u
.m
[3][3] = 1.0f
;
203 D3DXMATRIX
* WINAPI
D3DXMatrixMultiply(D3DXMATRIX
*pout
, CONST D3DXMATRIX
*pm1
, CONST D3DXMATRIX
*pm2
)
212 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
];
219 D3DXMATRIX
* WINAPI
D3DXMatrixMultiplyTranspose(D3DXMATRIX
*pout
, CONST D3DXMATRIX
*pm1
, CONST D3DXMATRIX
*pm2
)
221 D3DXMatrixMultiply(pout
, pm1
, pm2
);
222 D3DXMatrixTranspose(pout
, pout
);
226 D3DXMATRIX
* WINAPI
D3DXMatrixOrthoLH(D3DXMATRIX
*pout
, FLOAT w
, FLOAT h
, FLOAT zn
, FLOAT zf
)
228 D3DXMatrixIdentity(pout
);
229 pout
->u
.m
[0][0] = 2.0f
/ w
;
230 pout
->u
.m
[1][1] = 2.0f
/ h
;
231 pout
->u
.m
[2][2] = 1.0f
/ (zf
- zn
);
232 pout
->u
.m
[3][2] = zn
/ (zn
- zf
);
236 D3DXMATRIX
* WINAPI
D3DXMatrixOrthoOffCenterLH(D3DXMATRIX
*pout
, FLOAT l
, FLOAT r
, FLOAT b
, FLOAT t
, FLOAT zn
, FLOAT zf
)
238 D3DXMatrixIdentity(pout
);
239 pout
->u
.m
[0][0] = 2.0f
/ (r
- l
);
240 pout
->u
.m
[1][1] = 2.0f
/ (t
- b
);
241 pout
->u
.m
[2][2] = 1.0f
/ (zf
-zn
);
242 pout
->u
.m
[3][0] = -1.0f
-2.0f
*l
/ (r
- l
);
243 pout
->u
.m
[3][1] = 1.0f
+ 2.0f
* t
/ (b
- t
);
244 pout
->u
.m
[3][2] = zn
/ (zn
-zf
);
248 D3DXMATRIX
* WINAPI
D3DXMatrixOrthoOffCenterRH(D3DXMATRIX
*pout
, FLOAT l
, FLOAT r
, FLOAT b
, FLOAT t
, FLOAT zn
, FLOAT zf
)
250 D3DXMatrixIdentity(pout
);
251 pout
->u
.m
[0][0] = 2.0f
/ (r
- l
);
252 pout
->u
.m
[1][1] = 2.0f
/ (t
- b
);
253 pout
->u
.m
[2][2] = 1.0f
/ (zn
-zf
);
254 pout
->u
.m
[3][0] = -1.0f
-2.0f
*l
/ (r
- l
);
255 pout
->u
.m
[3][1] = 1.0f
+ 2.0f
* t
/ (b
- t
);
256 pout
->u
.m
[3][2] = zn
/ (zn
-zf
);
260 D3DXMATRIX
* WINAPI
D3DXMatrixOrthoRH(D3DXMATRIX
*pout
, FLOAT w
, FLOAT h
, FLOAT zn
, FLOAT zf
)
262 D3DXMatrixIdentity(pout
);
263 pout
->u
.m
[0][0] = 2.0f
/ w
;
264 pout
->u
.m
[1][1] = 2.0f
/ h
;
265 pout
->u
.m
[2][2] = 1.0f
/ (zn
- zf
);
266 pout
->u
.m
[3][2] = zn
/ (zn
- zf
);
270 D3DXMATRIX
* WINAPI
D3DXMatrixPerspectiveFovLH(D3DXMATRIX
*pout
, FLOAT fovy
, FLOAT aspect
, FLOAT zn
, FLOAT zf
)
272 D3DXMatrixIdentity(pout
);
273 pout
->u
.m
[0][0] = 1.0f
/ (aspect
* tan(fovy
/2.0f
));
274 pout
->u
.m
[1][1] = 1.0f
/ tan(fovy
/2.0f
);
275 pout
->u
.m
[2][2] = zf
/ (zf
- zn
);
276 pout
->u
.m
[2][3] = 1.0f
;
277 pout
->u
.m
[3][2] = (zf
* zn
) / (zn
- zf
);
278 pout
->u
.m
[3][3] = 0.0f
;
282 D3DXMATRIX
* WINAPI
D3DXMatrixPerspectiveFovRH(D3DXMATRIX
*pout
, FLOAT fovy
, FLOAT aspect
, FLOAT zn
, FLOAT zf
)
284 D3DXMatrixIdentity(pout
);
285 pout
->u
.m
[0][0] = 1.0f
/ (aspect
* tan(fovy
/2.0f
));
286 pout
->u
.m
[1][1] = 1.0f
/ tan(fovy
/2.0f
);
287 pout
->u
.m
[2][2] = zf
/ (zn
- zf
);
288 pout
->u
.m
[2][3] = -1.0f
;
289 pout
->u
.m
[3][2] = (zf
* zn
) / (zn
- zf
);
290 pout
->u
.m
[3][3] = 0.0f
;
294 D3DXMATRIX
* WINAPI
D3DXMatrixPerspectiveLH(D3DXMATRIX
*pout
, FLOAT w
, FLOAT h
, FLOAT zn
, FLOAT zf
)
296 D3DXMatrixIdentity(pout
);
297 pout
->u
.m
[0][0] = 2.0f
* zn
/ w
;
298 pout
->u
.m
[1][1] = 2.0f
* zn
/ h
;
299 pout
->u
.m
[2][2] = zf
/ (zf
- zn
);
300 pout
->u
.m
[3][2] = (zn
* zf
) / (zn
- zf
);
301 pout
->u
.m
[2][3] = 1.0f
;
302 pout
->u
.m
[3][3] = 0.0f
;
306 D3DXMATRIX
* WINAPI
D3DXMatrixPerspectiveOffCenterLH(D3DXMATRIX
*pout
, FLOAT l
, FLOAT r
, FLOAT b
, FLOAT t
, FLOAT zn
, FLOAT zf
)
308 D3DXMatrixIdentity(pout
);
309 pout
->u
.m
[0][0] = 2.0f
* zn
/ (r
- l
);
310 pout
->u
.m
[1][1] = -2.0f
* zn
/ (b
- t
);
311 pout
->u
.m
[2][0] = -1.0f
- 2.0f
* l
/ (r
- l
);
312 pout
->u
.m
[2][1] = 1.0f
+ 2.0f
* t
/ (b
- t
);
313 pout
->u
.m
[2][2] = - zf
/ (zn
- zf
);
314 pout
->u
.m
[3][2] = (zn
* zf
) / (zn
-zf
);
315 pout
->u
.m
[2][3] = 1.0f
;
316 pout
->u
.m
[3][3] = 0.0f
;
320 D3DXMATRIX
* WINAPI
D3DXMatrixPerspectiveOffCenterRH(D3DXMATRIX
*pout
, FLOAT l
, FLOAT r
, FLOAT b
, FLOAT t
, FLOAT zn
, FLOAT zf
)
322 D3DXMatrixIdentity(pout
);
323 pout
->u
.m
[0][0] = 2.0f
* zn
/ (r
- l
);
324 pout
->u
.m
[1][1] = -2.0f
* zn
/ (b
- t
);
325 pout
->u
.m
[2][0] = 1.0f
+ 2.0f
* l
/ (r
- l
);
326 pout
->u
.m
[2][1] = -1.0f
-2.0f
* t
/ (b
- t
);
327 pout
->u
.m
[2][2] = zf
/ (zn
- zf
);
328 pout
->u
.m
[3][2] = (zn
* zf
) / (zn
-zf
);
329 pout
->u
.m
[2][3] = -1.0f
;
330 pout
->u
.m
[3][3] = 0.0f
;
334 D3DXMATRIX
* WINAPI
D3DXMatrixPerspectiveRH(D3DXMATRIX
*pout
, FLOAT w
, FLOAT h
, FLOAT zn
, FLOAT zf
)
336 D3DXMatrixIdentity(pout
);
337 pout
->u
.m
[0][0] = 2.0f
* zn
/ w
;
338 pout
->u
.m
[1][1] = 2.0f
* zn
/ h
;
339 pout
->u
.m
[2][2] = zf
/ (zn
- zf
);
340 pout
->u
.m
[3][2] = (zn
* zf
) / (zn
- zf
);
341 pout
->u
.m
[2][3] = -1.0f
;
342 pout
->u
.m
[3][3] = 0.0f
;
346 D3DXMATRIX
* WINAPI
D3DXMatrixReflect(D3DXMATRIX
*pout
, CONST D3DXPLANE
*pplane
)
350 D3DXPlaneNormalize(&Nplane
, pplane
);
351 D3DXMatrixIdentity(pout
);
352 pout
->u
.m
[0][0] = 1.0f
- 2.0f
* Nplane
.a
* Nplane
.a
;
353 pout
->u
.m
[0][1] = -2.0f
* Nplane
.a
* Nplane
.b
;
354 pout
->u
.m
[0][2] = -2.0f
* Nplane
.a
* Nplane
.c
;
355 pout
->u
.m
[1][0] = -2.0f
* Nplane
.a
* Nplane
.b
;
356 pout
->u
.m
[1][1] = 1.0f
- 2.0f
* Nplane
.b
* Nplane
.b
;
357 pout
->u
.m
[1][2] = -2.0f
* Nplane
.b
* Nplane
.c
;
358 pout
->u
.m
[2][0] = -2.0f
* Nplane
.c
* Nplane
.a
;
359 pout
->u
.m
[2][1] = -2.0f
* Nplane
.c
* Nplane
.b
;
360 pout
->u
.m
[2][2] = 1.0f
- 2.0f
* Nplane
.c
* Nplane
.c
;
361 pout
->u
.m
[3][0] = -2.0f
* Nplane
.d
* Nplane
.a
;
362 pout
->u
.m
[3][1] = -2.0f
* Nplane
.d
* Nplane
.b
;
363 pout
->u
.m
[3][2] = -2.0f
* Nplane
.d
* Nplane
.c
;
367 D3DXMATRIX
* WINAPI
D3DXMatrixRotationAxis(D3DXMATRIX
*pout
, CONST D3DXVECTOR3
*pv
, FLOAT angle
)
371 D3DXVec3Normalize(&v
,pv
);
372 D3DXMatrixIdentity(pout
);
373 pout
->u
.m
[0][0] = (1.0f
- cos(angle
)) * v
.x
* v
.x
+ cos(angle
);
374 pout
->u
.m
[1][0] = (1.0f
- cos(angle
)) * v
.x
* v
.y
- sin(angle
) * v
.z
;
375 pout
->u
.m
[2][0] = (1.0f
- cos(angle
)) * v
.x
* v
.z
+ sin(angle
) * v
.y
;
376 pout
->u
.m
[0][1] = (1.0f
- cos(angle
)) * v
.y
* v
.x
+ sin(angle
) * v
.z
;
377 pout
->u
.m
[1][1] = (1.0f
- cos(angle
)) * v
.y
* v
.y
+ cos(angle
);
378 pout
->u
.m
[2][1] = (1.0f
- cos(angle
)) * v
.y
* v
.z
- sin(angle
) * v
.x
;
379 pout
->u
.m
[0][2] = (1.0f
- cos(angle
)) * v
.z
* v
.x
- sin(angle
) * v
.y
;
380 pout
->u
.m
[1][2] = (1.0f
- cos(angle
)) * v
.z
* v
.y
+ sin(angle
) * v
.x
;
381 pout
->u
.m
[2][2] = (1.0f
- cos(angle
)) * v
.z
* v
.z
+ cos(angle
);
385 D3DXMATRIX
* WINAPI
D3DXMatrixRotationQuaternion(D3DXMATRIX
*pout
, CONST D3DXQUATERNION
*pq
)
387 D3DXMatrixIdentity(pout
);
388 pout
->u
.m
[0][0] = 1.0f
- 2.0f
* (pq
->y
* pq
->y
+ pq
->z
* pq
->z
);
389 pout
->u
.m
[0][1] = 2.0f
* (pq
->x
*pq
->y
+ pq
->z
* pq
->w
);
390 pout
->u
.m
[0][2] = 2.0f
* (pq
->x
* pq
->z
- pq
->y
* pq
->w
);
391 pout
->u
.m
[1][0] = 2.0f
* (pq
->x
* pq
->y
- pq
->z
* pq
->w
);
392 pout
->u
.m
[1][1] = 1.0f
- 2.0f
* (pq
->x
* pq
->x
+ pq
->z
* pq
->z
);
393 pout
->u
.m
[1][2] = 2.0f
* (pq
->y
*pq
->z
+ pq
->x
*pq
->w
);
394 pout
->u
.m
[2][0] = 2.0f
* (pq
->x
* pq
->z
+ pq
->y
* pq
->w
);
395 pout
->u
.m
[2][1] = 2.0f
* (pq
->y
*pq
->z
- pq
->x
*pq
->w
);
396 pout
->u
.m
[2][2] = 1.0f
- 2.0f
* (pq
->x
* pq
->x
+ pq
->y
* pq
->y
);
400 D3DXMATRIX
* WINAPI
D3DXMatrixRotationX(D3DXMATRIX
*pout
, FLOAT angle
)
402 D3DXMatrixIdentity(pout
);
403 pout
->u
.m
[1][1] = cos(angle
);
404 pout
->u
.m
[2][2] = cos(angle
);
405 pout
->u
.m
[1][2] = sin(angle
);
406 pout
->u
.m
[2][1] = -sin(angle
);
410 D3DXMATRIX
* WINAPI
D3DXMatrixRotationY(D3DXMATRIX
*pout
, FLOAT angle
)
412 D3DXMatrixIdentity(pout
);
413 pout
->u
.m
[0][0] = cos(angle
);
414 pout
->u
.m
[2][2] = cos(angle
);
415 pout
->u
.m
[0][2] = -sin(angle
);
416 pout
->u
.m
[2][0] = sin(angle
);
420 D3DXMATRIX
* WINAPI
D3DXMatrixRotationYawPitchRoll(D3DXMATRIX
*pout
, FLOAT yaw
, FLOAT pitch
, FLOAT roll
)
424 D3DXMatrixIdentity(pout
);
425 D3DXMatrixRotationZ(&m
, roll
);
426 D3DXMatrixMultiply(pout
, pout
, &m
);
427 D3DXMatrixRotationX(&m
, pitch
);
428 D3DXMatrixMultiply(pout
, pout
, &m
);
429 D3DXMatrixRotationY(&m
, yaw
);
430 D3DXMatrixMultiply(pout
, pout
, &m
);
433 D3DXMATRIX
* WINAPI
D3DXMatrixRotationZ(D3DXMATRIX
*pout
, FLOAT angle
)
435 D3DXMatrixIdentity(pout
);
436 pout
->u
.m
[0][0] = cos(angle
);
437 pout
->u
.m
[1][1] = cos(angle
);
438 pout
->u
.m
[0][1] = sin(angle
);
439 pout
->u
.m
[1][0] = -sin(angle
);
443 D3DXMATRIX
* WINAPI
D3DXMatrixScaling(D3DXMATRIX
*pout
, FLOAT sx
, FLOAT sy
, FLOAT sz
)
445 D3DXMatrixIdentity(pout
);
446 pout
->u
.m
[0][0] = sx
;
447 pout
->u
.m
[1][1] = sy
;
448 pout
->u
.m
[2][2] = sz
;
452 D3DXMATRIX
* WINAPI
D3DXMatrixShadow(D3DXMATRIX
*pout
, CONST D3DXVECTOR4
*plight
, CONST D3DXPLANE
*pplane
)
457 D3DXPlaneNormalize(&Nplane
, pplane
);
458 dot
= D3DXPlaneDot(&Nplane
, plight
);
459 pout
->u
.m
[0][0] = dot
- Nplane
.a
* plight
->x
;
460 pout
->u
.m
[0][1] = -Nplane
.a
* plight
->y
;
461 pout
->u
.m
[0][2] = -Nplane
.a
* plight
->z
;
462 pout
->u
.m
[0][3] = -Nplane
.a
* plight
->w
;
463 pout
->u
.m
[1][0] = -Nplane
.b
* plight
->x
;
464 pout
->u
.m
[1][1] = dot
- Nplane
.b
* plight
->y
;
465 pout
->u
.m
[1][2] = -Nplane
.b
* plight
->z
;
466 pout
->u
.m
[1][3] = -Nplane
.b
* plight
->w
;
467 pout
->u
.m
[2][0] = -Nplane
.c
* plight
->x
;
468 pout
->u
.m
[2][1] = -Nplane
.c
* plight
->y
;
469 pout
->u
.m
[2][2] = dot
- Nplane
.c
* plight
->z
;
470 pout
->u
.m
[2][3] = -Nplane
.c
* plight
->w
;
471 pout
->u
.m
[3][0] = -Nplane
.d
* plight
->x
;
472 pout
->u
.m
[3][1] = -Nplane
.d
* plight
->y
;
473 pout
->u
.m
[3][2] = -Nplane
.d
* plight
->z
;
474 pout
->u
.m
[3][3] = dot
- Nplane
.d
* plight
->w
;
478 D3DXMATRIX
* WINAPI
D3DXMatrixTransformation(D3DXMATRIX
*pout
, CONST D3DXVECTOR3
*pscalingcenter
, CONST D3DXQUATERNION
*pscalingrotation
, CONST D3DXVECTOR3
*pscaling
, CONST D3DXVECTOR3
*protationcenter
, CONST D3DXQUATERNION
*protation
, CONST D3DXVECTOR3
*ptranslation
)
480 D3DXMATRIX m1
, m2
, m3
, m4
, m5
, m6
, m7
;
484 if ( !pscalingcenter
)
492 psc
.x
= pscalingcenter
->x
;
493 psc
.y
= pscalingcenter
->y
;
494 psc
.z
= pscalingcenter
->z
;
496 if ( !protationcenter
)
504 prc
.x
= protationcenter
->x
;
505 prc
.y
= protationcenter
->y
;
506 prc
.z
= protationcenter
->z
;
516 pt
.x
= ptranslation
->x
;
517 pt
.y
= ptranslation
->y
;
518 pt
.z
= ptranslation
->z
;
520 D3DXMatrixTranslation(&m1
, -psc
.x
, -psc
.y
, -psc
.z
);
521 if ( !pscalingrotation
)
523 D3DXMatrixIdentity(&m2
);
524 D3DXMatrixIdentity(&m4
);
528 D3DXMatrixRotationQuaternion(&m4
, pscalingrotation
);
529 D3DXMatrixInverse(&m2
, NULL
, &m4
);
533 D3DXMatrixIdentity(&m3
);
537 D3DXMatrixScaling(&m3
, pscaling
->x
, pscaling
->y
, pscaling
->z
);
541 D3DXMatrixIdentity(&m6
);
545 D3DXMatrixRotationQuaternion(&m6
, protation
);
547 D3DXMatrixTranslation(&m5
, psc
.x
- prc
.x
, psc
.y
- prc
.y
, psc
.z
- prc
.z
);
548 D3DXMatrixTranslation(&m7
, prc
.x
+ pt
.x
, prc
.y
+ pt
.y
, prc
.z
+ pt
.z
);
549 D3DXMatrixMultiply(&m1
, &m1
, &m2
);
550 D3DXMatrixMultiply(&m1
, &m1
, &m3
);
551 D3DXMatrixMultiply(&m1
, &m1
, &m4
);
552 D3DXMatrixMultiply(&m1
, &m1
, &m5
);
553 D3DXMatrixMultiply(&m1
, &m1
, &m6
);
554 D3DXMatrixMultiply(pout
, &m1
, &m7
);
558 D3DXMATRIX
* WINAPI
D3DXMatrixTranslation(D3DXMATRIX
*pout
, FLOAT x
, FLOAT y
, FLOAT z
)
560 D3DXMatrixIdentity(pout
);
567 D3DXMATRIX
* WINAPI
D3DXMatrixTranspose(D3DXMATRIX
*pout
, CONST D3DXMATRIX
*pm
)
569 CONST D3DXMATRIX m
= *pm
;
576 pout
->u
.m
[i
][j
] = m
.u
.m
[j
][i
];
582 /*_________________D3DXMatrixStack____________________*/
584 HRESULT WINAPI
D3DXCreateMatrixStack(DWORD flags
, LPD3DXMATRIXSTACK
* ppstack
)
586 ID3DXMatrixStackImpl
* object
;
588 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(ID3DXMatrixStackImpl
));
589 if ( object
== NULL
)
592 return E_OUTOFMEMORY
;
594 object
->lpVtbl
= &ID3DXMatrixStack_Vtbl
;
597 *ppstack
= (LPD3DXMATRIXSTACK
)object
;
601 static HRESULT WINAPI
ID3DXMatrixStackImpl_QueryInterface(ID3DXMatrixStack
*iface
, REFIID riid
, void **ppobj
)
603 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
604 if (IsEqualGUID(riid
, &IID_IUnknown
) || IsEqualGUID(riid
, &IID_ID3DXMatrixStack
))
606 ID3DXMatrixStack_AddRef(iface
);
611 ERR("(%p)->(%s,%p),not found\n",This
,debugstr_guid(riid
),ppobj
);
612 return E_NOINTERFACE
;
615 static ULONG WINAPI
ID3DXMatrixStackImpl_AddRef(ID3DXMatrixStack
*iface
)
617 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
618 ULONG ref
= InterlockedIncrement(&This
->ref
);
619 TRACE("(%p) : AddRef from %d\n", This
, ref
- 1);
623 static ULONG WINAPI
ID3DXMatrixStackImpl_Release(ID3DXMatrixStack
* iface
)
625 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
626 ULONG ref
= InterlockedDecrement(&This
->ref
);
627 if ( !ref
) HeapFree(GetProcessHeap(), 0, This
);
628 TRACE("(%p) : ReleaseRef to %d\n", This
, ref
);
632 static D3DXMATRIX
* WINAPI
ID3DXMatrixStackImpl_GetTop(ID3DXMatrixStack
*iface
)
634 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
635 FIXME("(%p) : stub\n",This
);
639 static HRESULT WINAPI
ID3DXMatrixStackImpl_LoadIdentity(ID3DXMatrixStack
*iface
)
641 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
642 FIXME("(%p) : stub\n",This
);
646 static HRESULT WINAPI
ID3DXMatrixStackImpl_LoadMatrix(ID3DXMatrixStack
*iface
, LPD3DXMATRIX pm
)
648 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
649 FIXME("(%p) : stub\n",This
);
653 static HRESULT WINAPI
ID3DXMatrixStackImpl_MultMatrix(ID3DXMatrixStack
*iface
, LPD3DXMATRIX pm
)
655 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
656 FIXME("(%p) : stub\n",This
);
660 static HRESULT WINAPI
ID3DXMatrixStackImpl_MultMatrixLocal(ID3DXMatrixStack
*iface
, LPD3DXMATRIX pm
)
662 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
663 FIXME("(%p) : stub\n",This
);
667 static HRESULT WINAPI
ID3DXMatrixStackImpl_Pop(ID3DXMatrixStack
*iface
)
669 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
670 FIXME("(%p) : stub\n",This
);
674 static HRESULT WINAPI
ID3DXMatrixStackImpl_Push(ID3DXMatrixStack
*iface
)
676 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
677 FIXME("(%p) : stub\n",This
);
681 static HRESULT WINAPI
ID3DXMatrixStackImpl_RotateAxis(ID3DXMatrixStack
*iface
, LPD3DXVECTOR3 pv
, FLOAT angle
)
683 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
684 FIXME("(%p) : stub\n",This
);
688 static HRESULT WINAPI
ID3DXMatrixStackImpl_RotateAxisLocal(ID3DXMatrixStack
*iface
, LPD3DXVECTOR3 pv
, FLOAT angle
)
690 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
691 FIXME("(%p) : stub\n",This
);
695 static HRESULT WINAPI
ID3DXMatrixStackImpl_RotateYawPitchRoll(ID3DXMatrixStack
*iface
, FLOAT x
, FLOAT y
, FLOAT z
)
697 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
698 FIXME("(%p) : stub\n",This
);
702 static HRESULT WINAPI
ID3DXMatrixStackImpl_RotateYawPitchRollLocal(ID3DXMatrixStack
*iface
, FLOAT x
, FLOAT y
, FLOAT z
)
704 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
705 FIXME("(%p) : stub\n",This
);
709 static HRESULT WINAPI
ID3DXMatrixStackImpl_Scale(ID3DXMatrixStack
*iface
, FLOAT x
, FLOAT y
, FLOAT z
)
711 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
712 FIXME("(%p) : stub\n",This
);
716 static HRESULT WINAPI
ID3DXMatrixStackImpl_ScaleLocal(ID3DXMatrixStack
*iface
, FLOAT x
, FLOAT y
, FLOAT z
)
718 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
719 FIXME("(%p) : stub\n",This
);
723 static HRESULT WINAPI
ID3DXMatrixStackImpl_Translate(ID3DXMatrixStack
*iface
, FLOAT x
, FLOAT y
, FLOAT z
)
725 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
726 FIXME("(%p) : stub\n",This
);
730 static HRESULT WINAPI
ID3DXMatrixStackImpl_TranslateLocal(ID3DXMatrixStack
*iface
, FLOAT x
, FLOAT y
, FLOAT z
)
732 ID3DXMatrixStackImpl
*This
= (ID3DXMatrixStackImpl
*)iface
;
733 FIXME("(%p) : stub\n",This
);
737 static const ID3DXMatrixStackVtbl ID3DXMatrixStack_Vtbl
=
739 ID3DXMatrixStackImpl_QueryInterface
,
740 ID3DXMatrixStackImpl_AddRef
,
741 ID3DXMatrixStackImpl_Release
,
742 ID3DXMatrixStackImpl_Pop
,
743 ID3DXMatrixStackImpl_Push
,
744 ID3DXMatrixStackImpl_LoadIdentity
,
745 ID3DXMatrixStackImpl_LoadMatrix
,
746 ID3DXMatrixStackImpl_MultMatrix
,
747 ID3DXMatrixStackImpl_MultMatrixLocal
,
748 ID3DXMatrixStackImpl_RotateAxis
,
749 ID3DXMatrixStackImpl_RotateAxisLocal
,
750 ID3DXMatrixStackImpl_RotateYawPitchRoll
,
751 ID3DXMatrixStackImpl_RotateYawPitchRollLocal
,
752 ID3DXMatrixStackImpl_Scale
,
753 ID3DXMatrixStackImpl_ScaleLocal
,
754 ID3DXMatrixStackImpl_Translate
,
755 ID3DXMatrixStackImpl_TranslateLocal
,
756 ID3DXMatrixStackImpl_GetTop
759 /*_________________D3DXPLANE________________*/
761 D3DXPLANE
* WINAPI
D3DXPlaneFromPointNormal(D3DXPLANE
*pout
, CONST D3DXVECTOR3
*pvpoint
, CONST D3DXVECTOR3
*pvnormal
)
763 pout
->a
= pvnormal
->x
;
764 pout
->b
= pvnormal
->y
;
765 pout
->c
= pvnormal
->z
;
766 pout
->d
= -D3DXVec3Dot(pvpoint
, pvnormal
);
770 D3DXPLANE
* WINAPI
D3DXPlaneFromPoints(D3DXPLANE
*pout
, CONST D3DXVECTOR3
*pv1
, CONST D3DXVECTOR3
*pv2
, CONST D3DXVECTOR3
*pv3
)
772 D3DXVECTOR3 edge1
, edge2
, normal
, Nnormal
;
774 edge1
.x
= 0.0f
; edge1
.y
= 0.0f
; edge1
.z
= 0.0f
;
775 edge2
.x
= 0.0f
; edge2
.y
= 0.0f
; edge2
.z
= 0.0f
;
776 D3DXVec3Subtract(&edge1
, pv2
, pv1
);
777 D3DXVec3Subtract(&edge2
, pv3
, pv1
);
778 D3DXVec3Cross(&normal
, &edge1
, &edge2
);
779 D3DXVec3Normalize(&Nnormal
, &normal
);
780 D3DXPlaneFromPointNormal(pout
, pv1
, &Nnormal
);
784 D3DXVECTOR3
* WINAPI
D3DXPlaneIntersectLine(D3DXVECTOR3
*pout
, CONST D3DXPLANE
*pp
, CONST D3DXVECTOR3
*pv1
, CONST D3DXVECTOR3
*pv2
)
786 D3DXVECTOR3 direction
, normal
;
792 direction
.x
= pv2
->x
- pv1
->x
;
793 direction
.y
= pv2
->y
- pv1
->y
;
794 direction
.z
= pv2
->z
- pv1
->z
;
795 dot
= D3DXVec3Dot(&normal
, &direction
);
796 if ( !dot
) return NULL
;
797 temp
= ( pp
->d
+ D3DXVec3Dot(&normal
, pv1
) ) / dot
;
798 pout
->x
= pv1
->x
- temp
* direction
.x
;
799 pout
->y
= pv1
->y
- temp
* direction
.y
;
800 pout
->z
= pv1
->z
- temp
* direction
.z
;
804 D3DXPLANE
* WINAPI
D3DXPlaneNormalize(D3DXPLANE
*pout
, CONST D3DXPLANE
*pp
)
808 norm
= sqrt(pp
->a
* pp
->a
+ pp
->b
* pp
->b
+ pp
->c
* pp
->c
);
811 pout
->a
= pp
->a
/ norm
;
812 pout
->b
= pp
->b
/ norm
;
813 pout
->c
= pp
->c
/ norm
;
814 pout
->d
= pp
->d
/ norm
;
826 D3DXPLANE
* WINAPI
D3DXPlaneTransform(D3DXPLANE
*pout
, CONST D3DXPLANE
*pplane
, CONST D3DXMATRIX
*pm
)
828 CONST D3DXPLANE plane
= *pplane
;
829 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
;
830 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
;
831 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
;
832 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
;
836 /*_________________D3DXQUATERNION________________*/
838 D3DXQUATERNION
* WINAPI
D3DXQuaternionBaryCentric(D3DXQUATERNION
*pout
, CONST D3DXQUATERNION
*pq1
, CONST D3DXQUATERNION
*pq2
, CONST D3DXQUATERNION
*pq3
, FLOAT f
, FLOAT g
)
840 D3DXQUATERNION temp1
, temp2
;
841 D3DXQuaternionSlerp(pout
, D3DXQuaternionSlerp(&temp1
, pq1
, pq2
, f
+ g
), D3DXQuaternionSlerp(&temp2
, pq1
, pq3
, f
+g
), g
/ (f
+ g
));
845 D3DXQUATERNION
* WINAPI
D3DXQuaternionExp(D3DXQUATERNION
*pout
, CONST D3DXQUATERNION
*pq
)
849 norm
= sqrt(pq
->x
* pq
->x
+ pq
->y
* pq
->y
+ pq
->z
* pq
->z
);
852 pout
->x
= sin(norm
) * pq
->x
/ norm
;
853 pout
->y
= sin(norm
) * pq
->y
/ norm
;
854 pout
->z
= sin(norm
) * pq
->z
/ norm
;
867 D3DXQUATERNION
* WINAPI
D3DXQuaternionInverse(D3DXQUATERNION
*pout
, CONST D3DXQUATERNION
*pq
)
877 norm
= D3DXQuaternionLengthSq(pq
);
887 D3DXQuaternionConjugate(&temp
, pq
);
888 pout
->x
= temp
.x
/ norm
;
889 pout
->y
= temp
.y
/ norm
;
890 pout
->z
= temp
.z
/ norm
;
891 pout
->w
= temp
.w
/ norm
;
896 D3DXQUATERNION
* WINAPI
D3DXQuaternionLn(D3DXQUATERNION
*pout
, CONST D3DXQUATERNION
*pq
)
898 FLOAT norm
, normvec
, theta
;
900 norm
= D3DXQuaternionLengthSq(pq
);
901 if ( norm
> 1.0001f
)
908 else if( norm
> 0.99999f
)
910 normvec
= sqrt( pq
->x
* pq
->x
+ pq
->y
* pq
->y
+ pq
->z
* pq
->z
);
911 theta
= atan2(normvec
, pq
->w
) / normvec
;
912 pout
->x
= theta
* pq
->x
;
913 pout
->y
= theta
* pq
->y
;
914 pout
->z
= theta
* pq
->z
;
919 FIXME("The quaternion (%f, %f, %f, %f) has a norm <1. This should not happen. Windows returns a result anyway. This case is not implemented yet.\n", pq
->x
, pq
->y
, pq
->z
, pq
->w
);
924 D3DXQUATERNION
* WINAPI
D3DXQuaternionMultiply(D3DXQUATERNION
*pout
, CONST D3DXQUATERNION
*pq1
, CONST D3DXQUATERNION
*pq2
)
927 out
.x
= pq2
->w
* pq1
->x
+ pq2
->x
* pq1
->w
+ pq2
->y
* pq1
->z
- pq2
->z
* pq1
->y
;
928 out
.y
= pq2
->w
* pq1
->y
- pq2
->x
* pq1
->z
+ pq2
->y
* pq1
->w
+ pq2
->z
* pq1
->x
;
929 out
.z
= pq2
->w
* pq1
->z
+ pq2
->x
* pq1
->y
- pq2
->y
* pq1
->x
+ pq2
->z
* pq1
->w
;
930 out
.w
= pq2
->w
* pq1
->w
- pq2
->x
* pq1
->x
- pq2
->y
* pq1
->y
- pq2
->z
* pq1
->z
;
935 D3DXQUATERNION
* WINAPI
D3DXQuaternionNormalize(D3DXQUATERNION
*pout
, CONST D3DXQUATERNION
*pq
)
939 norm
= D3DXQuaternionLength(pq
);
949 pout
->x
= pq
->x
/ norm
;
950 pout
->y
= pq
->y
/ norm
;
951 pout
->z
= pq
->z
/ norm
;
952 pout
->w
= pq
->w
/ norm
;
957 D3DXQUATERNION
* WINAPI
D3DXQuaternionRotationAxis(D3DXQUATERNION
*pout
, CONST D3DXVECTOR3
*pv
, FLOAT angle
)
961 D3DXVec3Normalize(&temp
, pv
);
962 pout
->x
= sin( angle
/ 2.0f
) * temp
.x
;
963 pout
->y
= sin( angle
/ 2.0f
) * temp
.y
;
964 pout
->z
= sin( angle
/ 2.0f
) * temp
.z
;
965 pout
->w
= cos( angle
/ 2.0f
);
969 D3DXQUATERNION
* WINAPI
D3DXQuaternionRotationMatrix(D3DXQUATERNION
*pout
, CONST D3DXMATRIX
*pm
)
972 FLOAT maxdiag
, S
, trace
;
974 trace
= pm
->u
.m
[0][0] + pm
->u
.m
[1][1] + pm
->u
.m
[2][2] + 1.0f
;
977 pout
->x
= ( pm
->u
.m
[1][2] - pm
->u
.m
[2][1] ) / ( 2.0f
* sqrt(trace
) );
978 pout
->y
= ( pm
->u
.m
[2][0] - pm
->u
.m
[0][2] ) / ( 2.0f
* sqrt(trace
) );
979 pout
->z
= ( pm
->u
.m
[0][1] - pm
->u
.m
[1][0] ) / ( 2.0f
* sqrt(trace
) );
980 pout
->w
= sqrt(trace
) / 2.0f
;
984 maxdiag
= pm
->u
.m
[0][0];
987 if ( pm
->u
.m
[i
][i
] > maxdiag
)
990 maxdiag
= pm
->u
.m
[i
][i
];
996 S
= 2.0f
* sqrt(1.0f
+ pm
->u
.m
[0][0] - pm
->u
.m
[1][1] - pm
->u
.m
[2][2]);
998 pout
->y
= ( pm
->u
.m
[0][1] + pm
->u
.m
[1][0] ) / S
;
999 pout
->z
= ( pm
->u
.m
[0][2] + pm
->u
.m
[2][0] ) / S
;
1000 pout
->w
= ( pm
->u
.m
[1][2] - pm
->u
.m
[2][1] ) / S
;
1003 S
= 2.0f
* sqrt(1.0f
+ pm
->u
.m
[1][1] - pm
->u
.m
[0][0] - pm
->u
.m
[2][2]);
1004 pout
->x
= ( pm
->u
.m
[0][1] + pm
->u
.m
[1][0] ) / S
;
1005 pout
->y
= 0.25f
* S
;
1006 pout
->z
= ( pm
->u
.m
[1][2] + pm
->u
.m
[2][1] ) / S
;
1007 pout
->w
= ( pm
->u
.m
[2][0] - pm
->u
.m
[0][2] ) / S
;
1010 S
= 2.0f
* sqrt(1.0f
+ pm
->u
.m
[2][2] - pm
->u
.m
[0][0] - pm
->u
.m
[1][1]);
1011 pout
->x
= ( pm
->u
.m
[0][2] + pm
->u
.m
[2][0] ) / S
;
1012 pout
->y
= ( pm
->u
.m
[1][2] + pm
->u
.m
[2][1] ) / S
;
1013 pout
->z
= 0.25f
* S
;
1014 pout
->w
= ( pm
->u
.m
[0][1] - pm
->u
.m
[1][0] ) / S
;
1020 D3DXQUATERNION
* WINAPI
D3DXQuaternionRotationYawPitchRoll(D3DXQUATERNION
*pout
, FLOAT yaw
, FLOAT pitch
, FLOAT roll
)
1022 pout
->x
= sin( yaw
/ 2.0f
) * cos(pitch
/ 2.0f
) * sin(roll
/ 2.0f
) + cos(yaw
/ 2.0f
) * sin(pitch
/ 2.0f
) * cos(roll
/ 2.0f
);
1023 pout
->y
= sin( yaw
/ 2.0f
) * cos(pitch
/ 2.0f
) * cos(roll
/ 2.0f
) - cos(yaw
/ 2.0f
) * sin(pitch
/ 2.0f
) * sin(roll
/ 2.0f
);
1024 pout
->z
= cos(yaw
/ 2.0f
) * cos(pitch
/ 2.0f
) * sin(roll
/ 2.0f
) - sin( yaw
/ 2.0f
) * sin(pitch
/ 2.0f
) * cos(roll
/ 2.0f
);
1025 pout
->w
= cos( yaw
/ 2.0f
) * cos(pitch
/ 2.0f
) * cos(roll
/ 2.0f
) + sin(yaw
/ 2.0f
) * sin(pitch
/ 2.0f
) * sin(roll
/ 2.0f
);
1029 D3DXQUATERNION
* WINAPI
D3DXQuaternionSlerp(D3DXQUATERNION
*pout
, CONST D3DXQUATERNION
*pq1
, CONST D3DXQUATERNION
*pq2
, FLOAT t
)
1034 dot
= D3DXQuaternionDot(pq1
, pq2
);
1035 if ( dot
< 0.0f
) epsilon
= -1.0f
;
1036 pout
->x
= (1.0f
- t
) * pq1
->x
+ epsilon
* t
* pq2
->x
;
1037 pout
->y
= (1.0f
- t
) * pq1
->y
+ epsilon
* t
* pq2
->y
;
1038 pout
->z
= (1.0f
- t
) * pq1
->z
+ epsilon
* t
* pq2
->z
;
1039 pout
->w
= (1.0f
- t
) * pq1
->w
+ epsilon
* t
* pq2
->w
;
1043 D3DXQUATERNION
* WINAPI
D3DXQuaternionSquad(D3DXQUATERNION
*pout
, CONST D3DXQUATERNION
*pq1
, CONST D3DXQUATERNION
*pq2
, CONST D3DXQUATERNION
*pq3
, CONST D3DXQUATERNION
*pq4
, FLOAT t
)
1045 D3DXQUATERNION temp1
, temp2
;
1047 D3DXQuaternionSlerp(pout
, D3DXQuaternionSlerp(&temp1
, pq1
, pq4
, t
), D3DXQuaternionSlerp(&temp2
, pq2
, pq3
, t
), 2.0f
* t
* (1.0f
- t
));
1051 void WINAPI
D3DXQuaternionToAxisAngle(CONST D3DXQUATERNION
*pq
, D3DXVECTOR3
*paxis
, FLOAT
*pangle
)
1056 norm
= D3DXQuaternionLength(pq
);
1059 paxis
->x
= pq
->x
/ norm
;
1060 paxis
->y
= pq
->y
/ norm
;
1061 paxis
->z
= pq
->z
/ norm
;
1062 if ( fabs( pq
->w
) <= 1.0f
) *pangle
= 2.0f
* acos(pq
->w
);
1072 /*_________________D3DXVec2_____________________*/
1074 D3DXVECTOR2
* WINAPI
D3DXVec2BaryCentric(D3DXVECTOR2
*pout
, CONST D3DXVECTOR2
*pv1
, CONST D3DXVECTOR2
*pv2
, CONST D3DXVECTOR2
*pv3
, FLOAT f
, FLOAT g
)
1076 pout
->x
= (1.0f
-f
-g
) * (pv1
->x
) + f
* (pv2
->x
) + g
* (pv3
->x
);
1077 pout
->y
= (1.0f
-f
-g
) * (pv1
->y
) + f
* (pv2
->y
) + g
* (pv3
->y
);
1081 D3DXVECTOR2
* WINAPI
D3DXVec2CatmullRom(D3DXVECTOR2
*pout
, CONST D3DXVECTOR2
*pv0
, CONST D3DXVECTOR2
*pv1
, CONST D3DXVECTOR2
*pv2
, CONST D3DXVECTOR2
*pv3
, FLOAT s
)
1083 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
);
1084 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
);
1088 D3DXVECTOR2
* WINAPI
D3DXVec2Hermite(D3DXVECTOR2
*pout
, CONST D3DXVECTOR2
*pv1
, CONST D3DXVECTOR2
*pt1
, CONST D3DXVECTOR2
*pv2
, CONST D3DXVECTOR2
*pt2
, FLOAT s
)
1090 FLOAT h1
, h2
, h3
, h4
;
1092 h1
= 2.0f
* s
* s
* s
- 3.0f
* s
* s
+ 1.0f
;
1093 h2
= s
* s
* s
- 2.0f
* s
* s
+ s
;
1094 h3
= -2.0f
* s
* s
* s
+ 3.0f
* s
* s
;
1095 h4
= s
* s
* s
- s
* s
;
1097 pout
->x
= h1
* (pv1
->x
) + h2
* (pt1
->x
) + h3
* (pv2
->x
) + h4
* (pt2
->x
);
1098 pout
->y
= h1
* (pv1
->y
) + h2
* (pt1
->y
) + h3
* (pv2
->y
) + h4
* (pt2
->y
);
1102 D3DXVECTOR2
* WINAPI
D3DXVec2Normalize(D3DXVECTOR2
*pout
, CONST D3DXVECTOR2
*pv
)
1106 norm
= D3DXVec2Length(pv
);
1114 pout
->x
= pv
->x
/ norm
;
1115 pout
->y
= pv
->y
/ norm
;
1120 D3DXVECTOR4
* WINAPI
D3DXVec2Transform(D3DXVECTOR4
*pout
, CONST D3DXVECTOR2
*pv
, CONST D3DXMATRIX
*pm
)
1122 pout
->x
= pm
->u
.m
[0][0] * pv
->x
+ pm
->u
.m
[1][0] * pv
->y
+ pm
->u
.m
[3][0];
1123 pout
->y
= pm
->u
.m
[0][1] * pv
->x
+ pm
->u
.m
[1][1] * pv
->y
+ pm
->u
.m
[3][1];
1124 pout
->z
= pm
->u
.m
[0][2] * pv
->x
+ pm
->u
.m
[1][2] * pv
->y
+ pm
->u
.m
[3][2];
1125 pout
->w
= pm
->u
.m
[0][3] * pv
->x
+ pm
->u
.m
[1][3] * pv
->y
+ pm
->u
.m
[3][3];
1129 D3DXVECTOR2
* WINAPI
D3DXVec2TransformCoord(D3DXVECTOR2
*pout
, CONST D3DXVECTOR2
*pv
, CONST D3DXMATRIX
*pm
)
1133 norm
= pm
->u
.m
[0][3] * pv
->x
+ pm
->u
.m
[1][3] * pv
->y
+ pm
->u
.m
[3][3];
1136 CONST D3DXVECTOR2 v
= *pv
;
1137 pout
->x
= (pm
->u
.m
[0][0] * v
.x
+ pm
->u
.m
[1][0] * v
.y
+ pm
->u
.m
[3][0]) / norm
;
1138 pout
->y
= (pm
->u
.m
[0][1] * v
.x
+ pm
->u
.m
[1][1] * v
.y
+ pm
->u
.m
[3][1]) / norm
;
1148 D3DXVECTOR2
* WINAPI
D3DXVec2TransformNormal(D3DXVECTOR2
*pout
, CONST D3DXVECTOR2
*pv
, CONST D3DXMATRIX
*pm
)
1150 CONST D3DXVECTOR2 v
= *pv
;
1151 pout
->x
= pm
->u
.m
[0][0] * v
.x
+ pm
->u
.m
[1][0] * v
.y
;
1152 pout
->y
= pm
->u
.m
[0][1] * v
.x
+ pm
->u
.m
[1][1] * v
.y
;
1156 /*_________________D3DXVec3_____________________*/
1158 D3DXVECTOR3
* WINAPI
D3DXVec3BaryCentric(D3DXVECTOR3
*pout
, CONST D3DXVECTOR3
*pv1
, CONST D3DXVECTOR3
*pv2
, CONST D3DXVECTOR3
*pv3
, FLOAT f
, FLOAT g
)
1160 pout
->x
= (1.0f
-f
-g
) * (pv1
->x
) + f
* (pv2
->x
) + g
* (pv3
->x
);
1161 pout
->y
= (1.0f
-f
-g
) * (pv1
->y
) + f
* (pv2
->y
) + g
* (pv3
->y
);
1162 pout
->z
= (1.0f
-f
-g
) * (pv1
->z
) + f
* (pv2
->z
) + g
* (pv3
->z
);
1166 D3DXVECTOR3
* WINAPI
D3DXVec3CatmullRom( D3DXVECTOR3
*pout
, CONST D3DXVECTOR3
*pv0
, CONST D3DXVECTOR3
*pv1
, CONST D3DXVECTOR3
*pv2
, CONST D3DXVECTOR3
*pv3
, FLOAT s
)
1168 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
);
1169 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
);
1170 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
);
1174 D3DXVECTOR3
* WINAPI
D3DXVec3Hermite(D3DXVECTOR3
*pout
, CONST D3DXVECTOR3
*pv1
, CONST D3DXVECTOR3
*pt1
, CONST D3DXVECTOR3
*pv2
, CONST D3DXVECTOR3
*pt2
, FLOAT s
)
1176 FLOAT h1
, h2
, h3
, h4
;
1178 h1
= 2.0f
* s
* s
* s
- 3.0f
* s
* s
+ 1.0f
;
1179 h2
= s
* s
* s
- 2.0f
* s
* s
+ s
;
1180 h3
= -2.0f
* s
* s
* s
+ 3.0f
* s
* s
;
1181 h4
= s
* s
* s
- s
* s
;
1183 pout
->x
= h1
* (pv1
->x
) + h2
* (pt1
->x
) + h3
* (pv2
->x
) + h4
* (pt2
->x
);
1184 pout
->y
= h1
* (pv1
->y
) + h2
* (pt1
->y
) + h3
* (pv2
->y
) + h4
* (pt2
->y
);
1185 pout
->z
= h1
* (pv1
->z
) + h2
* (pt1
->z
) + h3
* (pv2
->z
) + h4
* (pt2
->z
);
1189 D3DXVECTOR3
* WINAPI
D3DXVec3Normalize(D3DXVECTOR3
*pout
, CONST D3DXVECTOR3
*pv
)
1193 norm
= D3DXVec3Length(pv
);
1202 pout
->x
= pv
->x
/ norm
;
1203 pout
->y
= pv
->y
/ norm
;
1204 pout
->z
= pv
->z
/ norm
;
1209 D3DXVECTOR3
* WINAPI
D3DXVec3Project(D3DXVECTOR3
*pout
, CONST D3DXVECTOR3
*pv
, CONST D3DVIEWPORT8
*pviewport
, CONST D3DXMATRIX
*pprojection
, CONST D3DXMATRIX
*pview
, CONST D3DXMATRIX
*pworld
)
1214 D3DXMatrixMultiply(&m1
, pworld
, pview
);
1215 D3DXMatrixMultiply(&m2
, &m1
, pprojection
);
1216 D3DXVec3TransformCoord(&vec
, pv
, &m2
);
1217 pout
->x
= pviewport
->X
+ ( 1.0f
+ vec
.x
) * pviewport
->Width
/ 2.0f
;
1218 pout
->y
= pviewport
->Y
+ ( 1.0f
- vec
.y
) * pviewport
->Height
/ 2.0f
;
1219 pout
->z
= pviewport
->MinZ
+ vec
.z
* ( pviewport
->MaxZ
- pviewport
->MinZ
);
1223 D3DXVECTOR4
* WINAPI
D3DXVec3Transform(D3DXVECTOR4
*pout
, CONST D3DXVECTOR3
*pv
, CONST D3DXMATRIX
*pm
)
1225 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];
1226 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];
1227 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];
1228 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];
1232 D3DXVECTOR3
* WINAPI
D3DXVec3TransformCoord(D3DXVECTOR3
*pout
, CONST D3DXVECTOR3
*pv
, CONST D3DXMATRIX
*pm
)
1236 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];
1240 CONST D3DXVECTOR3 v
= *pv
;
1241 pout
->x
= (pm
->u
.m
[0][0] * v
.x
+ pm
->u
.m
[1][0] * v
.y
+ pm
->u
.m
[2][0] * v
.z
+ pm
->u
.m
[3][0]) / norm
;
1242 pout
->y
= (pm
->u
.m
[0][1] * v
.x
+ pm
->u
.m
[1][1] * v
.y
+ pm
->u
.m
[2][1] * v
.z
+ pm
->u
.m
[3][1]) / norm
;
1243 pout
->z
= (pm
->u
.m
[0][2] * v
.x
+ pm
->u
.m
[1][2] * v
.y
+ pm
->u
.m
[2][2] * v
.z
+ pm
->u
.m
[3][2]) / norm
;
1254 D3DXVECTOR3
* WINAPI
D3DXVec3TransformNormal(D3DXVECTOR3
*pout
, CONST D3DXVECTOR3
*pv
, CONST D3DXMATRIX
*pm
)
1256 CONST D3DXVECTOR3 v
= *pv
;
1257 pout
->x
= pm
->u
.m
[0][0] * v
.x
+ pm
->u
.m
[1][0] * v
.y
+ pm
->u
.m
[2][0] * v
.z
;
1258 pout
->y
= pm
->u
.m
[0][1] * v
.x
+ pm
->u
.m
[1][1] * v
.y
+ pm
->u
.m
[2][1] * v
.z
;
1259 pout
->z
= pm
->u
.m
[0][2] * v
.x
+ pm
->u
.m
[1][2] * v
.y
+ pm
->u
.m
[2][2] * v
.z
;
1264 D3DXVECTOR3
* WINAPI
D3DXVec3Unproject(D3DXVECTOR3
*pout
, CONST D3DXVECTOR3
*pv
, CONST D3DVIEWPORT8
*pviewport
, CONST D3DXMATRIX
*pprojection
, CONST D3DXMATRIX
*pview
, CONST D3DXMATRIX
*pworld
)
1266 D3DXMATRIX m1
, m2
, m3
;
1269 D3DXMatrixMultiply(&m1
, pworld
, pview
);
1270 D3DXMatrixMultiply(&m2
, &m1
, pprojection
);
1271 D3DXMatrixInverse(&m3
, NULL
, &m2
);
1272 vec
.x
= 2.0f
* ( pv
->x
- pviewport
->X
) / pviewport
->Width
- 1.0f
;
1273 vec
.y
= 1.0f
- 2.0f
* ( pv
->y
- pviewport
->Y
) / pviewport
->Height
;
1274 vec
.z
= ( pv
->z
- pviewport
->MinZ
) / ( pviewport
->MaxZ
- pviewport
->MinZ
);
1275 D3DXVec3TransformCoord(pout
, &vec
, &m3
);
1279 /*_________________D3DXVec4_____________________*/
1281 D3DXVECTOR4
* WINAPI
D3DXVec4BaryCentric(D3DXVECTOR4
*pout
, CONST D3DXVECTOR4
*pv1
, CONST D3DXVECTOR4
*pv2
, CONST D3DXVECTOR4
*pv3
, FLOAT f
, FLOAT g
)
1283 pout
->x
= (1.0f
-f
-g
) * (pv1
->x
) + f
* (pv2
->x
) + g
* (pv3
->x
);
1284 pout
->y
= (1.0f
-f
-g
) * (pv1
->y
) + f
* (pv2
->y
) + g
* (pv3
->y
);
1285 pout
->z
= (1.0f
-f
-g
) * (pv1
->z
) + f
* (pv2
->z
) + g
* (pv3
->z
);
1286 pout
->w
= (1.0f
-f
-g
) * (pv1
->w
) + f
* (pv2
->w
) + g
* (pv3
->w
);
1290 D3DXVECTOR4
* WINAPI
D3DXVec4CatmullRom(D3DXVECTOR4
*pout
, CONST D3DXVECTOR4
*pv0
, CONST D3DXVECTOR4
*pv1
, CONST D3DXVECTOR4
*pv2
, CONST D3DXVECTOR4
*pv3
, FLOAT s
)
1292 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
);
1293 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
);
1294 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
);
1295 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
);
1299 D3DXVECTOR4
* WINAPI
D3DXVec4Cross(D3DXVECTOR4
*pout
, CONST D3DXVECTOR4
*pv1
, CONST D3DXVECTOR4
*pv2
, CONST D3DXVECTOR4
*pv3
)
1302 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
);
1303 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
));
1304 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
);
1305 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
));
1310 D3DXVECTOR4
* WINAPI
D3DXVec4Hermite(D3DXVECTOR4
*pout
, CONST D3DXVECTOR4
*pv1
, CONST D3DXVECTOR4
*pt1
, CONST D3DXVECTOR4
*pv2
, CONST D3DXVECTOR4
*pt2
, FLOAT s
)
1312 FLOAT h1
, h2
, h3
, h4
;
1314 h1
= 2.0f
* s
* s
* s
- 3.0f
* s
* s
+ 1.0f
;
1315 h2
= s
* s
* s
- 2.0f
* s
* s
+ s
;
1316 h3
= -2.0f
* s
* s
* s
+ 3.0f
* s
* s
;
1317 h4
= s
* s
* s
- s
* s
;
1319 pout
->x
= h1
* (pv1
->x
) + h2
* (pt1
->x
) + h3
* (pv2
->x
) + h4
* (pt2
->x
);
1320 pout
->y
= h1
* (pv1
->y
) + h2
* (pt1
->y
) + h3
* (pv2
->y
) + h4
* (pt2
->y
);
1321 pout
->z
= h1
* (pv1
->z
) + h2
* (pt1
->z
) + h3
* (pv2
->z
) + h4
* (pt2
->z
);
1322 pout
->w
= h1
* (pv1
->w
) + h2
* (pt1
->w
) + h3
* (pv2
->w
) + h4
* (pt2
->w
);
1326 D3DXVECTOR4
* WINAPI
D3DXVec4Normalize(D3DXVECTOR4
*pout
, CONST D3DXVECTOR4
*pv
)
1330 norm
= D3DXVec4Length(pv
);
1340 pout
->x
= pv
->x
/ norm
;
1341 pout
->y
= pv
->y
/ norm
;
1342 pout
->z
= pv
->z
/ norm
;
1343 pout
->w
= pv
->w
/ norm
;
1348 D3DXVECTOR4
* WINAPI
D3DXVec4Transform(D3DXVECTOR4
*pout
, CONST D3DXVECTOR4
*pv
, CONST D3DXMATRIX
*pm
)
1351 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
;
1352 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
;
1353 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
;
1354 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
;