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
31 #include "wine/debug.h"
33 WINE_DEFAULT_DEBUG_CHANNEL(d3dx8
);
35 /*_________________D3DXColor____________________*/
37 D3DXCOLOR
* WINAPI
D3DXColorAdjustContrast(D3DXCOLOR
*pout
, CONST D3DXCOLOR
*pc
, FLOAT s
)
39 pout
->r
= 0.5f
+ s
* (pc
->r
- 0.5f
);
40 pout
->g
= 0.5f
+ s
* (pc
->g
- 0.5f
);
41 pout
->b
= 0.5f
+ s
* (pc
->b
- 0.5f
);
46 D3DXCOLOR
* WINAPI
D3DXColorAdjustSaturation(D3DXCOLOR
*pout
, CONST D3DXCOLOR
*pc
, FLOAT s
)
50 grey
= pc
->r
* 0.2125f
+ pc
->g
* 0.7154f
+ pc
->b
* 0.0721f
;
51 pout
->r
= grey
+ s
* (pc
->r
- grey
);
52 pout
->g
= grey
+ s
* (pc
->g
- grey
);
53 pout
->b
= grey
+ s
* (pc
->b
- grey
);
58 /*_________________D3DXMatrix____________________*/
60 D3DXMATRIX
* WINAPI
D3DXMatrixAffineTransformation(D3DXMATRIX
*pout
, float scaling
, D3DXVECTOR3
*rotationcenter
, D3DXQUATERNION
*rotation
, D3DXVECTOR3
*translation
)
62 D3DXMATRIX m1
, m2
, m3
, m4
, m5
, p1
, p2
, p3
;
64 D3DXMatrixScaling(&m1
, scaling
, scaling
, scaling
);
65 if ( !rotationcenter
)
67 D3DXMatrixIdentity(&m2
);
68 D3DXMatrixIdentity(&m4
);
72 D3DXMatrixTranslation(&m2
, -rotationcenter
->x
, -rotationcenter
->y
, -rotationcenter
->z
);
73 D3DXMatrixTranslation(&m4
, rotationcenter
->x
, rotationcenter
->y
, rotationcenter
->z
);
77 D3DXMatrixIdentity(&m3
);
81 D3DXMatrixRotationQuaternion(&m3
, rotation
);
85 D3DXMatrixIdentity(&m5
);
89 D3DXMatrixTranslation(&m5
, translation
->x
, translation
->y
, translation
->z
);
91 D3DXMatrixMultiply(&p1
, &m1
, &m2
);
92 D3DXMatrixMultiply(&p2
, &p1
, &m3
);
93 D3DXMatrixMultiply(&p3
, &p2
, &m4
);
94 D3DXMatrixMultiply(pout
, &p3
, &m5
);
98 FLOAT WINAPI
D3DXMatrixfDeterminant(CONST D3DXMATRIX
*pm
)
100 D3DXVECTOR4 minor
, v1
, v2
, v3
;
103 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];
104 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];
105 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];
106 D3DXVec4Cross(&minor
,&v1
,&v2
,&v3
);
107 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
);
111 D3DXMATRIX
* WINAPI
D3DXMatrixInverse(D3DXMATRIX
*pout
, FLOAT
*pdeterminant
, CONST D3DXMATRIX
*pm
)
114 D3DXVECTOR4 v
, vec
[3];
117 det
= D3DXMatrixfDeterminant(pm
);
118 if ( !det
) return NULL
;
119 if ( pdeterminant
) *pdeterminant
= det
;
127 if ( j
> i
) a
= a
-1;
128 vec
[a
].x
= pm
->u
.m
[j
][0];
129 vec
[a
].y
= pm
->u
.m
[j
][1];
130 vec
[a
].z
= pm
->u
.m
[j
][2];
131 vec
[a
].w
= pm
->u
.m
[j
][3];
134 D3DXVec4Cross(&v
, &vec
[0], &vec
[1], &vec
[2]);
139 case 0: cofactor
= v
.x
; break;
140 case 1: cofactor
= v
.y
; break;
141 case 2: cofactor
= v
.z
; break;
142 case 3: cofactor
= v
.w
; break;
144 pout
->u
.m
[j
][i
] = pow(-1.0f
, i
) * cofactor
/ det
;
150 D3DXMATRIX
* WINAPI
D3DXMatrixLookAtLH(D3DXMATRIX
*pout
, CONST D3DXVECTOR3
*peye
, CONST D3DXVECTOR3
*pat
, CONST D3DXVECTOR3
*pup
)
152 D3DXVECTOR3 right
, rightn
, up
, upn
, vec
, vec2
;
154 D3DXVec3Subtract(&vec2
, pat
, peye
);
155 D3DXVec3Normalize(&vec
, &vec2
);
156 D3DXVec3Cross(&right
, pup
, &vec
);
157 D3DXVec3Cross(&up
, &vec
, &right
);
158 D3DXVec3Normalize(&rightn
, &right
);
159 D3DXVec3Normalize(&upn
, &up
);
160 pout
->u
.m
[0][0] = rightn
.x
;
161 pout
->u
.m
[1][0] = rightn
.y
;
162 pout
->u
.m
[2][0] = rightn
.z
;
163 pout
->u
.m
[3][0] = -D3DXVec3Dot(&rightn
,peye
);
164 pout
->u
.m
[0][1] = upn
.x
;
165 pout
->u
.m
[1][1] = upn
.y
;
166 pout
->u
.m
[2][1] = upn
.z
;
167 pout
->u
.m
[3][1] = -D3DXVec3Dot(&upn
, peye
);
168 pout
->u
.m
[0][2] = vec
.x
;
169 pout
->u
.m
[1][2] = vec
.y
;
170 pout
->u
.m
[2][2] = vec
.z
;
171 pout
->u
.m
[3][2] = -D3DXVec3Dot(&vec
, peye
);
172 pout
->u
.m
[0][3] = 0.0f
;
173 pout
->u
.m
[1][3] = 0.0f
;
174 pout
->u
.m
[2][3] = 0.0f
;
175 pout
->u
.m
[3][3] = 1.0f
;
179 D3DXMATRIX
* WINAPI
D3DXMatrixLookAtRH(D3DXMATRIX
*pout
, CONST D3DXVECTOR3
*peye
, CONST D3DXVECTOR3
*pat
, CONST D3DXVECTOR3
*pup
)
181 D3DXVECTOR3 right
, rightn
, up
, upn
, vec
, vec2
;
183 D3DXVec3Subtract(&vec2
, pat
, peye
);
184 D3DXVec3Normalize(&vec
, &vec2
);
185 D3DXVec3Cross(&right
, pup
, &vec
);
186 D3DXVec3Cross(&up
, &vec
, &right
);
187 D3DXVec3Normalize(&rightn
, &right
);
188 D3DXVec3Normalize(&upn
, &up
);
189 pout
->u
.m
[0][0] = -rightn
.x
;
190 pout
->u
.m
[1][0] = -rightn
.y
;
191 pout
->u
.m
[2][0] = -rightn
.z
;
192 pout
->u
.m
[3][0] = D3DXVec3Dot(&rightn
,peye
);
193 pout
->u
.m
[0][1] = upn
.x
;
194 pout
->u
.m
[1][1] = upn
.y
;
195 pout
->u
.m
[2][1] = upn
.z
;
196 pout
->u
.m
[3][1] = -D3DXVec3Dot(&upn
, peye
);
197 pout
->u
.m
[0][2] = -vec
.x
;
198 pout
->u
.m
[1][2] = -vec
.y
;
199 pout
->u
.m
[2][2] = -vec
.z
;
200 pout
->u
.m
[3][2] = D3DXVec3Dot(&vec
, peye
);
201 pout
->u
.m
[0][3] = 0.0f
;
202 pout
->u
.m
[1][3] = 0.0f
;
203 pout
->u
.m
[2][3] = 0.0f
;
204 pout
->u
.m
[3][3] = 1.0f
;
208 D3DXMATRIX
* WINAPI
D3DXMatrixMultiply(D3DXMATRIX
*pout
, CONST D3DXMATRIX
*pm1
, CONST D3DXMATRIX
*pm2
)
216 pout
->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
];
222 D3DXMATRIX
* WINAPI
D3DXMatrixMultiplyTranspose(D3DXMATRIX
*pout
, CONST D3DXMATRIX
*pm1
, CONST D3DXMATRIX
*pm2
)
226 D3DXMatrixMultiply(&temp
, pm1
, pm2
);
227 D3DXMatrixTranspose(pout
, &temp
);
231 D3DXMATRIX
* WINAPI
D3DXMatrixOrthoLH(D3DXMATRIX
*pout
, FLOAT w
, FLOAT h
, FLOAT zn
, FLOAT zf
)
233 D3DXMatrixIdentity(pout
);
234 pout
->u
.m
[0][0] = 2.0f
/ w
;
235 pout
->u
.m
[1][1] = 2.0f
/ h
;
236 pout
->u
.m
[2][2] = 1.0f
/ (zf
- zn
);
237 pout
->u
.m
[3][2] = zn
/ (zn
- zf
);
241 D3DXMATRIX
* WINAPI
D3DXMatrixOrthoOffCenterLH(D3DXMATRIX
*pout
, FLOAT l
, FLOAT r
, FLOAT b
, FLOAT t
, FLOAT zn
, FLOAT zf
)
243 D3DXMatrixIdentity(pout
);
244 pout
->u
.m
[0][0] = 2.0f
/ (r
- l
);
245 pout
->u
.m
[1][1] = 2.0f
/ (t
- b
);
246 pout
->u
.m
[2][2] = 1.0f
/ (zf
-zn
);
247 pout
->u
.m
[3][0] = -1.0f
-2.0f
*l
/ (r
- l
);
248 pout
->u
.m
[3][1] = 1.0f
+ 2.0f
* t
/ (b
- t
);
249 pout
->u
.m
[3][2] = zn
/ (zn
-zf
);
253 D3DXMATRIX
* WINAPI
D3DXMatrixOrthoOffCenterRH(D3DXMATRIX
*pout
, FLOAT l
, FLOAT r
, FLOAT b
, FLOAT t
, FLOAT zn
, FLOAT zf
)
255 D3DXMatrixIdentity(pout
);
256 pout
->u
.m
[0][0] = 2.0f
/ (r
- l
);
257 pout
->u
.m
[1][1] = 2.0f
/ (t
- b
);
258 pout
->u
.m
[2][2] = 1.0f
/ (zn
-zf
);
259 pout
->u
.m
[3][0] = -1.0f
-2.0f
*l
/ (r
- l
);
260 pout
->u
.m
[3][1] = 1.0f
+ 2.0f
* t
/ (b
- t
);
261 pout
->u
.m
[3][2] = zn
/ (zn
-zf
);
265 D3DXMATRIX
* WINAPI
D3DXMatrixOrthoRH(D3DXMATRIX
*pout
, FLOAT w
, FLOAT h
, FLOAT zn
, FLOAT zf
)
267 D3DXMatrixIdentity(pout
);
268 pout
->u
.m
[0][0] = 2.0f
/ w
;
269 pout
->u
.m
[1][1] = 2.0f
/ h
;
270 pout
->u
.m
[2][2] = 1.0f
/ (zn
- zf
);
271 pout
->u
.m
[3][2] = zn
/ (zn
- zf
);
275 D3DXMATRIX
* WINAPI
D3DXMatrixPerspectiveFovLH(D3DXMATRIX
*pout
, FLOAT fovy
, FLOAT aspect
, FLOAT zn
, FLOAT zf
)
277 D3DXMatrixIdentity(pout
);
278 pout
->u
.m
[0][0] = 1.0f
/ (aspect
* tan(fovy
/2.0f
));
279 pout
->u
.m
[1][1] = 1.0f
/ tan(fovy
/2.0f
);
280 pout
->u
.m
[2][2] = zf
/ (zf
- zn
);
281 pout
->u
.m
[2][3] = 1.0f
;
282 pout
->u
.m
[3][2] = (zf
* zn
) / (zn
- zf
);
283 pout
->u
.m
[3][3] = 0.0f
;
287 D3DXMATRIX
* WINAPI
D3DXMatrixPerspectiveFovRH(D3DXMATRIX
*pout
, FLOAT fovy
, FLOAT aspect
, FLOAT zn
, FLOAT zf
)
289 D3DXMatrixIdentity(pout
);
290 pout
->u
.m
[0][0] = 1.0f
/ (aspect
* tan(fovy
/2.0f
));
291 pout
->u
.m
[1][1] = 1.0f
/ tan(fovy
/2.0f
);
292 pout
->u
.m
[2][2] = zf
/ (zn
- zf
);
293 pout
->u
.m
[2][3] = -1.0f
;
294 pout
->u
.m
[3][2] = (zf
* zn
) / (zn
- zf
);
295 pout
->u
.m
[3][3] = 0.0f
;
299 D3DXMATRIX
* WINAPI
D3DXMatrixPerspectiveLH(D3DXMATRIX
*pout
, FLOAT w
, FLOAT h
, FLOAT zn
, FLOAT zf
)
301 D3DXMatrixIdentity(pout
);
302 pout
->u
.m
[0][0] = 2.0f
* zn
/ w
;
303 pout
->u
.m
[1][1] = 2.0f
* zn
/ h
;
304 pout
->u
.m
[2][2] = zf
/ (zf
- zn
);
305 pout
->u
.m
[3][2] = (zn
* zf
) / (zn
- zf
);
306 pout
->u
.m
[2][3] = 1.0f
;
307 pout
->u
.m
[3][3] = 0.0f
;
311 D3DXMATRIX
* WINAPI
D3DXMatrixPerspectiveOffCenterLH(D3DXMATRIX
*pout
, FLOAT l
, FLOAT r
, FLOAT b
, FLOAT t
, FLOAT zn
, FLOAT zf
)
313 D3DXMatrixIdentity(pout
);
314 pout
->u
.m
[0][0] = 2.0f
* zn
/ (r
- l
);
315 pout
->u
.m
[1][1] = -2.0f
* zn
/ (b
- t
);
316 pout
->u
.m
[2][0] = -1.0f
- 2.0f
* l
/ (r
- l
);
317 pout
->u
.m
[2][1] = 1.0f
+ 2.0f
* t
/ (b
- t
);
318 pout
->u
.m
[2][2] = - zf
/ (zn
- zf
);
319 pout
->u
.m
[3][2] = (zn
* zf
) / (zn
-zf
);
320 pout
->u
.m
[2][3] = 1.0f
;
321 pout
->u
.m
[3][3] = 0.0f
;
325 D3DXMATRIX
* WINAPI
D3DXMatrixPerspectiveOffCenterRH(D3DXMATRIX
*pout
, FLOAT l
, FLOAT r
, FLOAT b
, FLOAT t
, FLOAT zn
, FLOAT zf
)
327 D3DXMatrixIdentity(pout
);
328 pout
->u
.m
[0][0] = 2.0f
* zn
/ (r
- l
);
329 pout
->u
.m
[1][1] = -2.0f
* zn
/ (b
- t
);
330 pout
->u
.m
[2][0] = 1.0f
+ 2.0f
* l
/ (r
- l
);
331 pout
->u
.m
[2][1] = -1.0f
-2.0f
* t
/ (b
- t
);
332 pout
->u
.m
[2][2] = zf
/ (zn
- zf
);
333 pout
->u
.m
[3][2] = (zn
* zf
) / (zn
-zf
);
334 pout
->u
.m
[2][3] = -1.0f
;
335 pout
->u
.m
[3][3] = 0.0f
;
339 D3DXMATRIX
* WINAPI
D3DXMatrixPerspectiveRH(D3DXMATRIX
*pout
, FLOAT w
, FLOAT h
, FLOAT zn
, FLOAT zf
)
341 D3DXMatrixIdentity(pout
);
342 pout
->u
.m
[0][0] = 2.0f
* zn
/ w
;
343 pout
->u
.m
[1][1] = 2.0f
* zn
/ h
;
344 pout
->u
.m
[2][2] = zf
/ (zn
- zf
);
345 pout
->u
.m
[3][2] = (zn
* zf
) / (zn
- zf
);
346 pout
->u
.m
[2][3] = -1.0f
;
347 pout
->u
.m
[3][3] = 0.0f
;
351 D3DXMATRIX
* WINAPI
D3DXMatrixReflect(D3DXMATRIX
*pout
, CONST D3DXPLANE
*pplane
)
355 D3DXPlaneNormalize(&Nplane
, pplane
);
356 D3DXMatrixIdentity(pout
);
357 pout
->u
.m
[0][0] = 1.0f
- 2.0f
* Nplane
.a
* Nplane
.a
;
358 pout
->u
.m
[0][1] = -2.0f
* Nplane
.a
* Nplane
.b
;
359 pout
->u
.m
[0][2] = -2.0f
* Nplane
.a
* Nplane
.c
;
360 pout
->u
.m
[1][0] = -2.0f
* Nplane
.a
* Nplane
.b
;
361 pout
->u
.m
[1][1] = 1.0f
- 2.0f
* Nplane
.b
* Nplane
.b
;
362 pout
->u
.m
[1][2] = -2.0f
* Nplane
.b
* Nplane
.c
;
363 pout
->u
.m
[2][0] = -2.0f
* Nplane
.c
* Nplane
.a
;
364 pout
->u
.m
[2][1] = -2.0f
* Nplane
.c
* Nplane
.b
;
365 pout
->u
.m
[2][2] = 1.0f
- 2.0f
* Nplane
.c
* Nplane
.c
;
366 pout
->u
.m
[3][0] = -2.0f
* Nplane
.d
* Nplane
.a
;
367 pout
->u
.m
[3][1] = -2.0f
* Nplane
.d
* Nplane
.b
;
368 pout
->u
.m
[3][2] = -2.0f
* Nplane
.d
* Nplane
.c
;
372 D3DXMATRIX
* WINAPI
D3DXMatrixRotationAxis(D3DXMATRIX
*pout
, CONST D3DXVECTOR3
*pv
, FLOAT angle
)
376 D3DXVec3Normalize(&v
,pv
);
377 D3DXMatrixIdentity(pout
);
378 pout
->u
.m
[0][0] = (1.0f
- cos(angle
)) * v
.x
* v
.x
+ cos(angle
);
379 pout
->u
.m
[1][0] = (1.0f
- cos(angle
)) * v
.x
* v
.y
- sin(angle
) * v
.z
;
380 pout
->u
.m
[2][0] = (1.0f
- cos(angle
)) * v
.x
* v
.z
+ sin(angle
) * v
.y
;
381 pout
->u
.m
[0][1] = (1.0f
- cos(angle
)) * v
.y
* v
.x
+ sin(angle
) * v
.z
;
382 pout
->u
.m
[1][1] = (1.0f
- cos(angle
)) * v
.y
* v
.y
+ cos(angle
);
383 pout
->u
.m
[2][1] = (1.0f
- cos(angle
)) * v
.y
* v
.z
- sin(angle
) * v
.x
;
384 pout
->u
.m
[0][2] = (1.0f
- cos(angle
)) * v
.z
* v
.x
- sin(angle
) * v
.y
;
385 pout
->u
.m
[1][2] = (1.0f
- cos(angle
)) * v
.z
* v
.y
+ sin(angle
) * v
.x
;
386 pout
->u
.m
[2][2] = (1.0f
- cos(angle
)) * v
.z
* v
.z
+ cos(angle
);
390 D3DXMATRIX
* WINAPI
D3DXMatrixRotationQuaternion(D3DXMATRIX
*pout
, CONST D3DXQUATERNION
*pq
)
392 D3DXMatrixIdentity(pout
);
393 pout
->u
.m
[0][0] = 1.0f
- 2.0f
* (pq
->y
* pq
->y
+ pq
->z
* pq
->z
);
394 pout
->u
.m
[0][1] = 2.0f
* (pq
->x
*pq
->y
+ pq
->z
* pq
->w
);
395 pout
->u
.m
[0][2] = 2.0f
* (pq
->x
* pq
->z
- pq
->y
* pq
->w
);
396 pout
->u
.m
[1][0] = 2.0f
* (pq
->x
* pq
->y
- pq
->z
* pq
->w
);
397 pout
->u
.m
[1][1] = 1.0f
- 2.0f
* (pq
->x
* pq
->x
+ pq
->z
* pq
->z
);
398 pout
->u
.m
[1][2] = 2.0f
* (pq
->y
*pq
->z
+ pq
->x
*pq
->w
);
399 pout
->u
.m
[2][0] = 2.0f
* (pq
->x
* pq
->z
+ pq
->y
* pq
->w
);
400 pout
->u
.m
[2][1] = 2.0f
* (pq
->y
*pq
->z
- pq
->x
*pq
->w
);
401 pout
->u
.m
[2][2] = 1.0f
- 2.0f
* (pq
->x
* pq
->x
+ pq
->y
* pq
->y
);
405 D3DXMATRIX
* WINAPI
D3DXMatrixRotationX(D3DXMATRIX
*pout
, FLOAT angle
)
407 D3DXMatrixIdentity(pout
);
408 pout
->u
.m
[1][1] = cos(angle
);
409 pout
->u
.m
[2][2] = cos(angle
);
410 pout
->u
.m
[1][2] = sin(angle
);
411 pout
->u
.m
[2][1] = -sin(angle
);
415 D3DXMATRIX
* WINAPI
D3DXMatrixRotationY(D3DXMATRIX
*pout
, FLOAT angle
)
417 D3DXMatrixIdentity(pout
);
418 pout
->u
.m
[0][0] = cos(angle
);
419 pout
->u
.m
[2][2] = cos(angle
);
420 pout
->u
.m
[0][2] = -sin(angle
);
421 pout
->u
.m
[2][0] = sin(angle
);
425 D3DXMATRIX
* WINAPI
D3DXMatrixRotationYawPitchRoll(D3DXMATRIX
*pout
, FLOAT yaw
, FLOAT pitch
, FLOAT roll
)
427 D3DXMATRIX m
, pout1
, pout2
, pout3
;
429 D3DXMatrixIdentity(&pout3
);
430 D3DXMatrixRotationZ(&m
,roll
);
431 D3DXMatrixMultiply(&pout2
,&pout3
,&m
);
432 D3DXMatrixRotationX(&m
,pitch
);
433 D3DXMatrixMultiply(&pout1
,&pout2
,&m
);
434 D3DXMatrixRotationY(&m
,yaw
);
435 D3DXMatrixMultiply(pout
,&pout1
,&m
);
438 D3DXMATRIX
* WINAPI
D3DXMatrixRotationZ(D3DXMATRIX
*pout
, FLOAT angle
)
440 D3DXMatrixIdentity(pout
);
441 pout
->u
.m
[0][0] = cos(angle
);
442 pout
->u
.m
[1][1] = cos(angle
);
443 pout
->u
.m
[0][1] = sin(angle
);
444 pout
->u
.m
[1][0] = -sin(angle
);
448 D3DXMATRIX
* WINAPI
D3DXMatrixScaling(D3DXMATRIX
*pout
, FLOAT sx
, FLOAT sy
, FLOAT sz
)
450 D3DXMatrixIdentity(pout
);
451 pout
->u
.m
[0][0] = sx
;
452 pout
->u
.m
[1][1] = sy
;
453 pout
->u
.m
[2][2] = sz
;
457 D3DXMATRIX
* WINAPI
D3DXMatrixShadow(D3DXMATRIX
*pout
, CONST D3DXVECTOR4
*plight
, CONST D3DXPLANE
*pplane
)
462 D3DXPlaneNormalize(&Nplane
, pplane
);
463 dot
= D3DXPlaneDot(&Nplane
, plight
);
464 pout
->u
.m
[0][0] = dot
- Nplane
.a
* plight
->x
;
465 pout
->u
.m
[0][1] = -Nplane
.a
* plight
->y
;
466 pout
->u
.m
[0][2] = -Nplane
.a
* plight
->z
;
467 pout
->u
.m
[0][3] = -Nplane
.a
* plight
->w
;
468 pout
->u
.m
[1][0] = -Nplane
.b
* plight
->x
;
469 pout
->u
.m
[1][1] = dot
- Nplane
.b
* plight
->y
;
470 pout
->u
.m
[1][2] = -Nplane
.b
* plight
->z
;
471 pout
->u
.m
[1][3] = -Nplane
.b
* plight
->w
;
472 pout
->u
.m
[2][0] = -Nplane
.c
* plight
->x
;
473 pout
->u
.m
[2][1] = -Nplane
.c
* plight
->y
;
474 pout
->u
.m
[2][2] = dot
- Nplane
.c
* plight
->z
;
475 pout
->u
.m
[2][3] = -Nplane
.c
* plight
->w
;
476 pout
->u
.m
[3][0] = -Nplane
.d
* plight
->x
;
477 pout
->u
.m
[3][1] = -Nplane
.d
* plight
->y
;
478 pout
->u
.m
[3][2] = -Nplane
.d
* plight
->z
;
479 pout
->u
.m
[3][3] = dot
- Nplane
.d
* plight
->w
;
483 D3DXMATRIX
* WINAPI
D3DXMatrixTranslation(D3DXMATRIX
*pout
, FLOAT x
, FLOAT y
, FLOAT z
)
485 D3DXMatrixIdentity(pout
);
492 D3DXMATRIX
* WINAPI
D3DXMatrixTranspose(D3DXMATRIX
*pout
, CONST D3DXMATRIX
*pm
)
500 pout
->u
.m
[i
][j
] = pm
->u
.m
[j
][i
];
506 /*_________________D3DXPLANE________________*/
508 D3DXPLANE
* WINAPI
D3DXPlaneFromPointNormal(D3DXPLANE
*pout
, CONST D3DXVECTOR3
*pvpoint
, CONST D3DXVECTOR3
*pvnormal
)
510 pout
->a
= pvnormal
->x
;
511 pout
->b
= pvnormal
->y
;
512 pout
->c
= pvnormal
->z
;
513 pout
->d
= -D3DXVec3Dot(pvpoint
, pvnormal
);
517 D3DXPLANE
* WINAPI
D3DXPlaneFromPoints(D3DXPLANE
*pout
, CONST D3DXVECTOR3
*pv1
, CONST D3DXVECTOR3
*pv2
, CONST D3DXVECTOR3
*pv3
)
519 D3DXVECTOR3 edge1
, edge2
, normal
, Nnormal
;
521 edge1
.x
= 0.0f
; edge1
.y
= 0.0f
; edge1
.z
= 0.0f
;
522 edge2
.x
= 0.0f
; edge2
.y
= 0.0f
; edge2
.z
= 0.0f
;
523 D3DXVec3Subtract(&edge1
, pv2
, pv1
);
524 D3DXVec3Subtract(&edge2
, pv3
, pv1
);
525 D3DXVec3Cross(&normal
, &edge1
, &edge2
);
526 D3DXVec3Normalize(&Nnormal
, &normal
);
527 D3DXPlaneFromPointNormal(pout
, pv1
, &Nnormal
);
531 D3DXVECTOR3
* WINAPI
D3DXPlaneIntersectLine(D3DXVECTOR3
*pout
, CONST D3DXPLANE
*pp
, CONST D3DXVECTOR3
*pv1
, CONST D3DXVECTOR3
*pv2
)
533 D3DXVECTOR3 direction
, normal
;
539 direction
.x
= pv2
->x
- pv1
->x
;
540 direction
.y
= pv2
->y
- pv1
->y
;
541 direction
.z
= pv2
->z
- pv1
->z
;
542 dot
= D3DXVec3Dot(&normal
, &direction
);
543 if ( !dot
) return NULL
;
544 temp
= ( pp
->d
+ D3DXVec3Dot(&normal
, pv1
) ) / dot
;
545 pout
->x
= pv1
->x
- temp
* direction
.x
;
546 pout
->y
= pv1
->y
- temp
* direction
.y
;
547 pout
->z
= pv1
->z
- temp
* direction
.z
;
551 D3DXPLANE
* WINAPI
D3DXPlaneNormalize(D3DXPLANE
*pout
, CONST D3DXPLANE
*pp
)
555 norm
= sqrt(pp
->a
* pp
->a
+ pp
->b
* pp
->b
+ pp
->c
* pp
->c
);
558 pout
->a
= pp
->a
/ norm
;
559 pout
->b
= pp
->b
/ norm
;
560 pout
->c
= pp
->c
/ norm
;
561 pout
->d
= pp
->d
/ norm
;
573 D3DXPLANE
* WINAPI
D3DXPlaneTransform(D3DXPLANE
*pout
, CONST D3DXPLANE
*pplane
, CONST D3DXMATRIX
*pm
)
575 pout
->a
= pm
->u
.m
[0][0] * pplane
->a
+ pm
->u
.m
[1][0] * pplane
->b
+ pm
->u
.m
[2][0] * pplane
->c
+ pm
->u
.m
[3][0] * pplane
->d
;
576 pout
->b
= pm
->u
.m
[0][1] * pplane
->a
+ pm
->u
.m
[1][1] * pplane
->b
+ pm
->u
.m
[2][1] * pplane
->c
+ pm
->u
.m
[3][1] * pplane
->d
;
577 pout
->c
= pm
->u
.m
[0][2] * pplane
->a
+ pm
->u
.m
[1][2] * pplane
->b
+ pm
->u
.m
[2][2] * pplane
->c
+ pm
->u
.m
[3][2] * pplane
->d
;
578 pout
->d
= pm
->u
.m
[0][3] * pplane
->a
+ pm
->u
.m
[1][3] * pplane
->b
+ pm
->u
.m
[2][3] * pplane
->c
+ pm
->u
.m
[3][3] * pplane
->d
;
582 /*_________________D3DXQUATERNION________________*/
584 D3DXQUATERNION
* WINAPI
D3DXQuaternionBaryCentric(D3DXQUATERNION
*pout
, CONST D3DXQUATERNION
*pq1
, CONST D3DXQUATERNION
*pq2
, CONST D3DXQUATERNION
*pq3
, FLOAT f
, FLOAT g
)
586 D3DXQUATERNION temp1
, temp2
;
587 D3DXQuaternionSlerp(pout
, D3DXQuaternionSlerp(&temp1
, pq1
, pq2
, f
+ g
), D3DXQuaternionSlerp(&temp2
, pq1
, pq3
, f
+g
), g
/ (f
+ g
));
591 D3DXQUATERNION
* WINAPI
D3DXQuaternionInverse(D3DXQUATERNION
*pout
, CONST D3DXQUATERNION
*pq
)
596 norm
= D3DXQuaternionLengthSq(pq
);
606 D3DXQuaternionConjugate(&temp
, pq
);
607 pout
->x
= temp
.x
/ norm
;
608 pout
->y
= temp
.y
/ norm
;
609 pout
->z
= temp
.z
/ norm
;
610 pout
->w
= temp
.w
/ norm
;
615 D3DXQUATERNION
* WINAPI
D3DXQuaternionMultiply(D3DXQUATERNION
*pout
, CONST D3DXQUATERNION
*pq1
, CONST D3DXQUATERNION
*pq2
)
617 pout
->x
= pq2
->w
* pq1
->x
+ pq2
->x
* pq1
->w
+ pq2
->y
* pq1
->z
- pq2
->z
* pq1
->y
;
618 pout
->y
= pq2
->w
* pq1
->y
- pq2
->x
* pq1
->z
+ pq2
->y
* pq1
->w
+ pq2
->z
* pq1
->x
;
619 pout
->z
= pq2
->w
* pq1
->z
+ pq2
->x
* pq1
->y
- pq2
->y
* pq1
->x
+ pq2
->z
* pq1
->w
;
620 pout
->w
= pq2
->w
* pq1
->w
- pq2
->x
* pq1
->x
- pq2
->y
* pq1
->y
- pq2
->z
* pq1
->z
;
624 D3DXQUATERNION
* WINAPI
D3DXQuaternionNormalize(D3DXQUATERNION
*pout
, CONST D3DXQUATERNION
*pq
)
628 norm
= D3DXQuaternionLength(pq
);
638 pout
->x
= pq
->x
/ norm
;
639 pout
->y
= pq
->y
/ norm
;
640 pout
->z
= pq
->z
/ norm
;
641 pout
->w
= pq
->w
/ norm
;
646 D3DXQUATERNION
* WINAPI
D3DXQuaternionSlerp(D3DXQUATERNION
*pout
, CONST D3DXQUATERNION
*pq1
, CONST D3DXQUATERNION
*pq2
, FLOAT t
)
651 dot
= D3DXQuaternionDot(pq1
, pq2
);
652 if ( dot
< 0.0f
) epsilon
= -1.0f
;
653 pout
->x
= (1.0f
- t
) * pq1
->x
+ epsilon
* t
* pq2
->x
;
654 pout
->y
= (1.0f
- t
) * pq1
->y
+ epsilon
* t
* pq2
->y
;
655 pout
->z
= (1.0f
- t
) * pq1
->z
+ epsilon
* t
* pq2
->z
;
656 pout
->w
= (1.0f
- t
) * pq1
->w
+ epsilon
* t
* pq2
->w
;
660 D3DXQUATERNION
* WINAPI
D3DXQuaternionSquad(D3DXQUATERNION
*pout
, CONST D3DXQUATERNION
*pq1
, CONST D3DXQUATERNION
*pq2
, CONST D3DXQUATERNION
*pq3
, CONST D3DXQUATERNION
*pq4
, FLOAT t
)
662 D3DXQUATERNION temp1
, temp2
;
664 D3DXQuaternionSlerp(pout
, D3DXQuaternionSlerp(&temp1
, pq1
, pq4
, t
), D3DXQuaternionSlerp(&temp2
, pq2
, pq3
, t
), 2.0f
* t
* (1.0f
- t
));
668 /*_________________D3DXVec2_____________________*/
670 D3DXVECTOR2
* WINAPI
D3DXVec2BaryCentric(D3DXVECTOR2
*pout
, CONST D3DXVECTOR2
*pv1
, CONST D3DXVECTOR2
*pv2
, CONST D3DXVECTOR2
*pv3
, FLOAT f
, FLOAT g
)
672 pout
->x
= (1.0f
-f
-g
) * (pv1
->x
) + f
* (pv2
->x
) + g
* (pv3
->x
);
673 pout
->y
= (1.0f
-f
-g
) * (pv1
->y
) + f
* (pv2
->y
) + g
* (pv3
->y
);
677 D3DXVECTOR2
* WINAPI
D3DXVec2CatmullRom(D3DXVECTOR2
*pout
, CONST D3DXVECTOR2
*pv0
, CONST D3DXVECTOR2
*pv1
, CONST D3DXVECTOR2
*pv2
, CONST D3DXVECTOR2
*pv3
, FLOAT s
)
679 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
);
680 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
);
684 D3DXVECTOR2
* WINAPI
D3DXVec2Hermite(D3DXVECTOR2
*pout
, CONST D3DXVECTOR2
*pv1
, CONST D3DXVECTOR2
*pt1
, CONST D3DXVECTOR2
*pv2
, CONST D3DXVECTOR2
*pt2
, FLOAT s
)
686 FLOAT h1
, h2
, h3
, h4
;
688 h1
= 2.0f
* s
* s
* s
- 3.0f
* s
* s
+ 1.0f
;
689 h2
= s
* s
* s
- 2.0f
* s
* s
+ s
;
690 h3
= -2.0f
* s
* s
* s
+ 3.0f
* s
* s
;
691 h4
= s
* s
* s
- s
* s
;
693 pout
->x
= h1
* (pv1
->x
) + h2
* (pt1
->x
) + h3
* (pv2
->x
) + h4
* (pt2
->x
);
694 pout
->y
= h1
* (pv1
->y
) + h2
* (pt1
->y
) + h3
* (pv2
->y
) + h4
* (pt2
->y
);
698 D3DXVECTOR2
* WINAPI
D3DXVec2Normalize(D3DXVECTOR2
*pout
, CONST D3DXVECTOR2
*pv
)
702 norm
= D3DXVec2Length(pv
);
710 pout
->x
= pv
->x
/ norm
;
711 pout
->y
= pv
->y
/ norm
;
716 D3DXVECTOR4
* WINAPI
D3DXVec2Transform(D3DXVECTOR4
*pout
, CONST D3DXVECTOR2
*pv
, CONST D3DXMATRIX
*pm
)
718 pout
->x
= pm
->u
.m
[0][0] * pv
->x
+ pm
->u
.m
[1][0] * pv
->y
+ pm
->u
.m
[3][0];
719 pout
->y
= pm
->u
.m
[0][1] * pv
->x
+ pm
->u
.m
[1][1] * pv
->y
+ pm
->u
.m
[3][1];
720 pout
->z
= pm
->u
.m
[0][2] * pv
->x
+ pm
->u
.m
[1][2] * pv
->y
+ pm
->u
.m
[3][2];
721 pout
->w
= pm
->u
.m
[0][3] * pv
->x
+ pm
->u
.m
[1][3] * pv
->y
+ pm
->u
.m
[3][3];
725 D3DXVECTOR2
* WINAPI
D3DXVec2TransformCoord(D3DXVECTOR2
*pout
, CONST D3DXVECTOR2
*pv
, CONST D3DXMATRIX
*pm
)
729 norm
= pm
->u
.m
[0][3] * pv
->x
+ pm
->u
.m
[1][3] * pv
->y
+ pm
->u
.m
[3][3];
732 pout
->x
= (pm
->u
.m
[0][0] * pv
->x
+ pm
->u
.m
[1][0] * pv
->y
+ pm
->u
.m
[3][0]) / norm
;
733 pout
->y
= (pm
->u
.m
[0][1] * pv
->x
+ pm
->u
.m
[1][1] * pv
->y
+ pm
->u
.m
[3][1]) / norm
;
743 D3DXVECTOR2
* WINAPI
D3DXVec2TransformNormal(D3DXVECTOR2
*pout
, CONST D3DXVECTOR2
*pv
, CONST D3DXMATRIX
*pm
)
745 pout
->x
= pm
->u
.m
[0][0] * pv
->x
+ pm
->u
.m
[1][0] * pv
->y
;
746 pout
->y
= pm
->u
.m
[0][1] * pv
->x
+ pm
->u
.m
[1][1] * pv
->y
;
750 /*_________________D3DXVec3_____________________*/
752 D3DXVECTOR3
* WINAPI
D3DXVec3BaryCentric(D3DXVECTOR3
*pout
, CONST D3DXVECTOR3
*pv1
, CONST D3DXVECTOR3
*pv2
, CONST D3DXVECTOR3
*pv3
, FLOAT f
, FLOAT g
)
754 pout
->x
= (1.0f
-f
-g
) * (pv1
->x
) + f
* (pv2
->x
) + g
* (pv3
->x
);
755 pout
->y
= (1.0f
-f
-g
) * (pv1
->y
) + f
* (pv2
->y
) + g
* (pv3
->y
);
756 pout
->z
= (1.0f
-f
-g
) * (pv1
->z
) + f
* (pv2
->z
) + g
* (pv3
->z
);
760 D3DXVECTOR3
* WINAPI
D3DXVec3CatmullRom( D3DXVECTOR3
*pout
, CONST D3DXVECTOR3
*pv0
, CONST D3DXVECTOR3
*pv1
, CONST D3DXVECTOR3
*pv2
, CONST D3DXVECTOR3
*pv3
, FLOAT s
)
762 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
);
763 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
);
764 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
);
768 D3DXVECTOR3
* WINAPI
D3DXVec3Hermite(D3DXVECTOR3
*pout
, CONST D3DXVECTOR3
*pv1
, CONST D3DXVECTOR3
*pt1
, CONST D3DXVECTOR3
*pv2
, CONST D3DXVECTOR3
*pt2
, FLOAT s
)
770 FLOAT h1
, h2
, h3
, h4
;
772 h1
= 2.0f
* s
* s
* s
- 3.0f
* s
* s
+ 1.0f
;
773 h2
= s
* s
* s
- 2.0f
* s
* s
+ s
;
774 h3
= -2.0f
* s
* s
* s
+ 3.0f
* s
* s
;
775 h4
= s
* s
* s
- s
* s
;
777 pout
->x
= h1
* (pv1
->x
) + h2
* (pt1
->x
) + h3
* (pv2
->x
) + h4
* (pt2
->x
);
778 pout
->y
= h1
* (pv1
->y
) + h2
* (pt1
->y
) + h3
* (pv2
->y
) + h4
* (pt2
->y
);
779 pout
->z
= h1
* (pv1
->z
) + h2
* (pt1
->z
) + h3
* (pv2
->z
) + h4
* (pt2
->z
);
783 D3DXVECTOR3
* WINAPI
D3DXVec3Normalize(D3DXVECTOR3
*pout
, CONST D3DXVECTOR3
*pv
)
787 norm
= D3DXVec3Length(pv
);
796 pout
->x
= pv
->x
/ norm
;
797 pout
->y
= pv
->y
/ norm
;
798 pout
->z
= pv
->z
/ norm
;
803 D3DXVECTOR3
* WINAPI
D3DXVec3Project(D3DXVECTOR3
*pout
, CONST D3DXVECTOR3
*pv
, CONST D3DVIEWPORT8
*pviewport
, CONST D3DXMATRIX
*pprojection
, CONST D3DXMATRIX
*pview
, CONST D3DXMATRIX
*pworld
)
808 D3DXMatrixMultiply(&m1
, pworld
, pview
);
809 D3DXMatrixMultiply(&m2
, &m1
, pprojection
);
810 D3DXVec3TransformCoord(&vec
, pv
, &m2
);
811 pout
->x
= pviewport
->X
+ ( 1.0f
+ vec
.x
) * pviewport
->Width
/ 2.0f
;
812 pout
->y
= pviewport
->Y
+ ( 1.0f
- vec
.y
) * pviewport
->Height
/ 2.0f
;
813 pout
->z
= pviewport
->MinZ
+ vec
.z
* ( pviewport
->MaxZ
- pviewport
->MinZ
);
817 D3DXVECTOR4
* WINAPI
D3DXVec3Transform(D3DXVECTOR4
*pout
, CONST D3DXVECTOR3
*pv
, CONST D3DXMATRIX
*pm
)
819 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];
820 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];
821 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];
822 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];
826 D3DXVECTOR3
* WINAPI
D3DXVec3TransformCoord(D3DXVECTOR3
*pout
, CONST D3DXVECTOR3
*pv
, CONST D3DXMATRIX
*pm
)
830 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];
834 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]) / norm
;
835 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]) / norm
;
836 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]) / norm
;
847 D3DXVECTOR3
* WINAPI
D3DXVec3TransformNormal(D3DXVECTOR3
*pout
, CONST D3DXVECTOR3
*pv
, CONST D3DXMATRIX
*pm
)
849 pout
->x
= pm
->u
.m
[0][0] * pv
->x
+ pm
->u
.m
[1][0] * pv
->y
+ pm
->u
.m
[2][0] * pv
->z
;
850 pout
->y
= pm
->u
.m
[0][1] * pv
->x
+ pm
->u
.m
[1][1] * pv
->y
+ pm
->u
.m
[2][1] * pv
->z
;
851 pout
->z
= pm
->u
.m
[0][2] * pv
->x
+ pm
->u
.m
[1][2] * pv
->y
+ pm
->u
.m
[2][2] * pv
->z
;
856 D3DXVECTOR3
* WINAPI
D3DXVec3Unproject(D3DXVECTOR3
*pout
, CONST D3DXVECTOR3
*pv
, CONST D3DVIEWPORT8
*pviewport
, CONST D3DXMATRIX
*pprojection
, CONST D3DXMATRIX
*pview
, CONST D3DXMATRIX
*pworld
)
858 D3DXMATRIX m1
, m2
, m3
;
861 D3DXMatrixMultiply(&m1
, pworld
, pview
);
862 D3DXMatrixMultiply(&m2
, &m1
, pprojection
);
863 D3DXMatrixInverse(&m3
, NULL
, &m2
);
864 vec
.x
= 2.0f
* ( pv
->x
- pviewport
->X
) / pviewport
->Width
- 1.0f
;
865 vec
.y
= 1.0f
- 2.0f
* ( pv
->y
- pviewport
->Y
) / pviewport
->Height
;
866 vec
.z
= ( pv
->z
- pviewport
->MinZ
) / ( pviewport
->MaxZ
- pviewport
->MinZ
);
867 D3DXVec3TransformCoord(pout
, &vec
, &m3
);
871 /*_________________D3DXVec4_____________________*/
873 D3DXVECTOR4
* WINAPI
D3DXVec4BaryCentric(D3DXVECTOR4
*pout
, CONST D3DXVECTOR4
*pv1
, CONST D3DXVECTOR4
*pv2
, CONST D3DXVECTOR4
*pv3
, FLOAT f
, FLOAT g
)
875 pout
->x
= (1.0f
-f
-g
) * (pv1
->x
) + f
* (pv2
->x
) + g
* (pv3
->x
);
876 pout
->y
= (1.0f
-f
-g
) * (pv1
->y
) + f
* (pv2
->y
) + g
* (pv3
->y
);
877 pout
->z
= (1.0f
-f
-g
) * (pv1
->z
) + f
* (pv2
->z
) + g
* (pv3
->z
);
878 pout
->w
= (1.0f
-f
-g
) * (pv1
->w
) + f
* (pv2
->w
) + g
* (pv3
->w
);
882 D3DXVECTOR4
* WINAPI
D3DXVec4CatmullRom(D3DXVECTOR4
*pout
, CONST D3DXVECTOR4
*pv0
, CONST D3DXVECTOR4
*pv1
, CONST D3DXVECTOR4
*pv2
, CONST D3DXVECTOR4
*pv3
, FLOAT s
)
884 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
);
885 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
);
886 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
);
887 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
);
891 D3DXVECTOR4
* WINAPI
D3DXVec4Cross(D3DXVECTOR4
*pout
, CONST D3DXVECTOR4
*pv1
, CONST D3DXVECTOR4
*pv2
, CONST D3DXVECTOR4
*pv3
)
893 pout
->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
);
894 pout
->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
));
895 pout
->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
);
896 pout
->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
));
900 D3DXVECTOR4
* WINAPI
D3DXVec4Hermite(D3DXVECTOR4
*pout
, CONST D3DXVECTOR4
*pv1
, CONST D3DXVECTOR4
*pt1
, CONST D3DXVECTOR4
*pv2
, CONST D3DXVECTOR4
*pt2
, FLOAT s
)
902 FLOAT h1
, h2
, h3
, h4
;
904 h1
= 2.0f
* s
* s
* s
- 3.0f
* s
* s
+ 1.0f
;
905 h2
= s
* s
* s
- 2.0f
* s
* s
+ s
;
906 h3
= -2.0f
* s
* s
* s
+ 3.0f
* s
* s
;
907 h4
= s
* s
* s
- s
* s
;
909 pout
->x
= h1
* (pv1
->x
) + h2
* (pt1
->x
) + h3
* (pv2
->x
) + h4
* (pt2
->x
);
910 pout
->y
= h1
* (pv1
->y
) + h2
* (pt1
->y
) + h3
* (pv2
->y
) + h4
* (pt2
->y
);
911 pout
->z
= h1
* (pv1
->z
) + h2
* (pt1
->z
) + h3
* (pv2
->z
) + h4
* (pt2
->z
);
912 pout
->w
= h1
* (pv1
->w
) + h2
* (pt1
->w
) + h3
* (pv2
->w
) + h4
* (pt2
->w
);
916 D3DXVECTOR4
* WINAPI
D3DXVec4Normalize(D3DXVECTOR4
*pout
, CONST D3DXVECTOR4
*pv
)
920 norm
= D3DXVec4Length(pv
);
930 pout
->x
= pv
->x
/ norm
;
931 pout
->y
= pv
->y
/ norm
;
932 pout
->z
= pv
->z
/ norm
;
933 pout
->w
= pv
->w
/ norm
;
938 D3DXVECTOR4
* WINAPI
D3DXVec4Transform(D3DXVECTOR4
*pout
, CONST D3DXVECTOR4
*pv
, CONST D3DXMATRIX
*pm
)
940 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] * pv
->w
;
941 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] * pv
->w
;
942 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] * pv
->w
;
943 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] * pv
->w
;