Mercurial > projects > ddbg_continued
comparison win32/directx/d3dx10math.d @ 1:4a9dcbd9e54f
-files of 0.13 beta
-fixes so that it now compiles with the current dmd version
author | marton@basel.hu |
---|---|
date | Tue, 05 Apr 2011 20:44:01 +0200 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
0:586e4a649642 | 1:4a9dcbd9e54f |
---|---|
1 /***********************************************************************\ | |
2 * d3dx10math.d * | |
3 * * | |
4 * Windows API header module * | |
5 * * | |
6 * Placed into public domain * | |
7 \***********************************************************************/ | |
8 module win32.directx.d3dx10math; | |
9 | |
10 version(Tango) { | |
11 import tango.math.Math; | |
12 alias sqrt sqrtf; | |
13 } else { | |
14 import std.c.math; | |
15 } | |
16 | |
17 private import win32.windows; | |
18 private import win32.directx.d3dx10; | |
19 | |
20 struct D3DVECTOR { | |
21 float x; | |
22 float y; | |
23 float z; | |
24 } | |
25 | |
26 struct D3DMATRIX { | |
27 union { | |
28 struct { | |
29 float _11, _12, _13, _14; | |
30 float _21, _22, _23, _24; | |
31 float _31, _32, _33, _34; | |
32 float _41, _42, _43, _44; | |
33 } | |
34 float[4][4] m; | |
35 } | |
36 } | |
37 | |
38 const D3DX_PI = 3.14159265358979323846; | |
39 const D3DX_1BYPI = 1.0 / D3DX_PI; | |
40 | |
41 float D3DXToRadian(float degree) { | |
42 return degree * (D3DX_PI / 180.0); | |
43 } | |
44 | |
45 float D3DXToDegree(float radian) { | |
46 return radian * (180.0 / D3DX_PI); | |
47 } | |
48 | |
49 const D3DX_16F_DIG = 3; | |
50 const D3DX_16F_EPSILON = 4.8875809e-4f; | |
51 const D3DX_16F_MANT_DIG = 11; | |
52 const D3DX_16F_MAX = 6.550400e+004; | |
53 const D3DX_16F_MAX_10_EXP = 4; | |
54 const D3DX_16F_MAX_EXP = 15; | |
55 const D3DX_16F_MIN = 6.1035156e-5f; | |
56 const D3DX_16F_MIN_10_EXP = -4; | |
57 const D3DX_16F_MIN_EXP = -14; | |
58 const D3DX_16F_RADIX = 2; | |
59 const D3DX_16F_ROUNDS = 1; | |
60 const D3DX_16F_SIGN_MASK = 0x8000; | |
61 const D3DX_16F_EXP_MASK = 0x7C00; | |
62 const D3DX_16F_FRAC_MASK = 0x03FF; | |
63 | |
64 struct D3DXFLOAT16 { | |
65 //TODO | |
66 protected: | |
67 WORD value; | |
68 } | |
69 | |
70 struct D3DXVECTOR2 { | |
71 //TODO | |
72 float x, y; | |
73 } | |
74 | |
75 struct D3DXVECTOR2_16F { | |
76 //TODO | |
77 D3DXFLOAT16 x, y; | |
78 } | |
79 | |
80 struct D3DXVECTOR3 { | |
81 //TODO | |
82 float x, y, z; | |
83 } | |
84 | |
85 struct D3DXVECTOR3_16F { | |
86 //TODO | |
87 D3DXFLOAT16 x, y, z; | |
88 } | |
89 | |
90 struct D3DXVECTOR4 { | |
91 //TODO | |
92 float x, y, z, w; | |
93 } | |
94 | |
95 struct D3DXVECTOR4_16F { | |
96 //TODO | |
97 D3DXFLOAT16 x, y, z, w; | |
98 } | |
99 | |
100 struct D3DXMATRIX { | |
101 //TODO | |
102 union { | |
103 struct { | |
104 float _11, _12, _13, _14; | |
105 float _21, _22, _23, _24; | |
106 float _31, _32, _33, _34; | |
107 float _41, _42, _43, _44; | |
108 } | |
109 float[4][4] m; | |
110 } | |
111 } | |
112 | |
113 //TODO struct _D3DXMATRIXA16 : D3DXMATRIX | |
114 | |
115 struct D3DXQUATERNION { | |
116 //TODO | |
117 float x, y, z, w; | |
118 } | |
119 | |
120 struct D3DXPLANE { | |
121 //TODO | |
122 float a, b, c, d; | |
123 } | |
124 | |
125 struct D3DXCOLOR { | |
126 //TODO | |
127 float r, g, b, a; | |
128 } | |
129 | |
130 extern(Windows) { | |
131 D3DXFLOAT16* D3DXFloat32To16Array(D3DXFLOAT16* pOut, float* pIn, UINT n); | |
132 float* D3DXFloat16To32Array(float* pOut, D3DXFLOAT16* pIn, UINT n); | |
133 } | |
134 | |
135 float D3DXVec2Length(D3DXVECTOR2* pV) { | |
136 debug(D3DX10_DEBUG) { | |
137 if (pV is null) return 0.0; | |
138 } | |
139 return sqrtf((pV.x * pV.x) + (pV.y * pV.y)); | |
140 } | |
141 | |
142 float D3DXVec2LengthSq(D3DXVECTOR2* pV) { | |
143 debug(D3DX10_DEBUG) { | |
144 if (pV is null) return 0.0; | |
145 } | |
146 return (pV.x * pV.x) + (pV.y * pV.y); | |
147 } | |
148 | |
149 float D3DXVec2Dot(D3DXVECTOR2* pV1, D3DXVECTOR2* pV2) { | |
150 debug(D3DX10_DEBUG) { | |
151 if ((pV1 is null) || (pV2 is null)) return 0.0; | |
152 } | |
153 return (pV1.x * pV2.x) + (pV1.y * pV2.y); | |
154 } | |
155 | |
156 float D3DXVec2CCW(D3DXVECTOR2* pV1, D3DXVECTOR2* pV2) { | |
157 debug(D3DX10_DEBUG) { | |
158 if ((pV1 is null) || (pV2 is null)) return 0.0; | |
159 } | |
160 return (pV1.x * pV2.y) + (pV1.y * pV2.x); | |
161 } | |
162 | |
163 D3DXVECTOR2* D3DXVec2Add(D3DXVECTOR2* pOut, D3DXVECTOR2* pV1, D3DXVECTOR2* pV2) { | |
164 debug(D3DX10_DEBUG) { | |
165 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return null; | |
166 } | |
167 pOut.x = pV1.x + pV2.x; | |
168 pOut.y = pV1.y + pV2.y; | |
169 return pOut; | |
170 } | |
171 | |
172 D3DXVECTOR2* D3DXVec2Subtract(D3DXVECTOR2* pOut, D3DXVECTOR2* pV1, D3DXVECTOR2* pV2) { | |
173 debug(D3DX10_DEBUG) { | |
174 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return null; | |
175 } | |
176 pOut.x = pV1.x - pV2.x; | |
177 pOut.y = pV1.y - pV2.y; | |
178 return pOut; | |
179 } | |
180 | |
181 D3DXVECTOR2* D3DXVec2Minimize(D3DXVECTOR2* pOut, D3DXVECTOR2* pV1, D3DXVECTOR2* pV2) { | |
182 debug(D3DX10_DEBUG) { | |
183 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return null; | |
184 } | |
185 pOut.x = pV1.x < pV2.x ? pV1.x : pV2.x; | |
186 pOut.y = pV1.y < pV2.y ? pV1.y : pV2.y; | |
187 return pOut; | |
188 } | |
189 | |
190 D3DXVECTOR2* D3DXVec2Maximize(D3DXVECTOR2* pOut, D3DXVECTOR2* pV1, D3DXVECTOR2* pV2) { | |
191 debug(D3DX10_DEBUG) { | |
192 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return null; | |
193 } | |
194 pOut.x = pV1.x > pV2.x ? pV1.x : pV2.x; | |
195 pOut.y = pV1.y > pV2.y ? pV1.y : pV2.y; | |
196 return pOut; | |
197 } | |
198 | |
199 D3DXVECTOR2* D3DXVec2Scale(D3DXVECTOR2* pOut, D3DXVECTOR2* pV, float s) { | |
200 debug(D3DX10_DEBUG) { | |
201 if ((pOut is null) || (pV is null)) return null; | |
202 } | |
203 pOut.x = pV.x * s; | |
204 pOut.y = pV.y * s; | |
205 return pOut; | |
206 } | |
207 | |
208 D3DXVECTOR2* D3DXVec2Lerp(D3DXVECTOR2* pOut, D3DXVECTOR2* pV1, D3DXVECTOR2* pV2, float s) { | |
209 debug(D3DX10_DEBUG) { | |
210 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return null; | |
211 } | |
212 pOut.x = pV1.x + s * (pV2.x - pV1.x); | |
213 pOut.y = pV1.y + s * (pV2.y - pV1.y); | |
214 return pOut; | |
215 } | |
216 | |
217 extern(Windows) { | |
218 D3DXVECTOR2* D3DXVec2Normalize(D3DXVECTOR2* pOut, D3DXVECTOR2* pV); | |
219 D3DXVECTOR2* D3DXVec2Hermite(D3DXVECTOR2* pOut, D3DXVECTOR2* pV1, D3DXVECTOR2* pT1, D3DXVECTOR2* pV2, D3DXVECTOR2* pT2, float s); | |
220 D3DXVECTOR2* D3DXVec2CatmullRom(D3DXVECTOR2* pOut, D3DXVECTOR2* pV0, D3DXVECTOR2* pV1, D3DXVECTOR2* pV2, D3DXVECTOR2* pV3, float s); | |
221 D3DXVECTOR2* D3DXVec2BaryCentric(D3DXVECTOR2* pOut, D3DXVECTOR2* pV1, D3DXVECTOR2* pV2, D3DXVECTOR2* pV3, float f, float g); | |
222 D3DXVECTOR4* D3DXVec2Transform(D3DXVECTOR4* pOut, D3DXVECTOR2* pV, D3DXMATRIX* pM); | |
223 D3DXVECTOR2* D3DXVec2TransformCoord(D3DXVECTOR2* pOut, D3DXVECTOR2* pV, D3DXMATRIX* pM); | |
224 D3DXVECTOR2* D3DXVec2TransformNormal(D3DXVECTOR2* pOut, D3DXVECTOR2* pV, D3DXMATRIX* pM); | |
225 D3DXVECTOR4* D3DXVec2TransformArray(D3DXVECTOR4* pOut, UINT OutStride, D3DXVECTOR2* pV, UINT VStride, D3DXMATRIX* pM, UINT n); | |
226 D3DXVECTOR2* D3DXVec2TransformCoordArray(D3DXVECTOR2* pOut, UINT OutStride, D3DXVECTOR2* pV, UINT VStride, D3DXMATRIX* pM, UINT n); | |
227 D3DXVECTOR2* D3DXVec2TransformNormalArray(D3DXVECTOR2* pOut, UINT OutStride, D3DXVECTOR2* pV, UINT VStride, D3DXMATRIX* pM, UINT n); | |
228 } | |
229 | |
230 float D3DXVec3Length(D3DXVECTOR3* pV) { | |
231 debug(D3DX10_DEBUG) { | |
232 if (pV is null) return 0.0; | |
233 } | |
234 return sqrtf((pV.x * pV.x) + (pV.y * pV.y) + (pV.z * pV.z)); | |
235 } | |
236 | |
237 float D3DXVec3LengthSq(D3DXVECTOR3* pV) { | |
238 debug(D3DX10_DEBUG) { | |
239 if (pV is null) return 0.0; | |
240 } | |
241 return (pV.x * pV.x) + (pV.y * pV.y) + (pV.z * pV.z); | |
242 } | |
243 | |
244 float D3DXVec3Dot(D3DXVECTOR3* pV1, D3DXVECTOR3* pV2) { | |
245 debug(D3DX10_DEBUG) { | |
246 if ((pV1 is null) || (pV2 is null)) return 0.0; | |
247 } | |
248 return (pV1.x * pV2.x) + (pV1.y * pV2.y) + (pV1.z * pV2.z); | |
249 } | |
250 | |
251 D3DXVECTOR3* D3DXVec3Cross(D3DXVECTOR3* pOut, D3DXVECTOR3* pV1, D3DXVECTOR3* pV2) { | |
252 debug(D3DX10_DEBUG) { | |
253 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return 0.0; | |
254 } | |
255 D3DXVECTOR3 v; | |
256 v.x = (pV1.y * pV2.z) - (pV1.z * pV2.y); | |
257 v.y = (pV1.z * pV2.x) - (pV1.x * pV2.z); | |
258 v.z = (pV1.x * pV2.y) - (pV1.y * pV2.x); | |
259 *pOut = v; | |
260 return pOut; | |
261 } | |
262 | |
263 D3DXVECTOR3* D3DXVec3Add(D3DXVECTOR3* pOut, D3DXVECTOR3* pV1, D3DXVECTOR3* pV2) { | |
264 debug(D3DX10_DEBUG) { | |
265 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return null; | |
266 } | |
267 pOut.x = pV1.x + pV2.x; | |
268 pOut.y = pV1.y + pV2.y; | |
269 pOut.z = pV1.z + pV2.z; | |
270 return pOut; | |
271 } | |
272 | |
273 D3DXVECTOR3* D3DXVec3Subtract(D3DXVECTOR3* pOut, D3DXVECTOR3* pV1, D3DXVECTOR3* pV2) { | |
274 debug(D3DX10_DEBUG) { | |
275 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return null; | |
276 } | |
277 pOut.x = pV1.x - pV2.x; | |
278 pOut.y = pV1.y - pV2.y; | |
279 pOut.z = pV1.z - pV2.z; | |
280 return pOut; | |
281 } | |
282 | |
283 D3DXVECTOR3* D3DXVec3Minimize(D3DXVECTOR3* pOut, D3DXVECTOR3* pV1, D3DXVECTOR3* pV2) { | |
284 debug(D3DX10_DEBUG) { | |
285 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return null; | |
286 } | |
287 pOut.x = pV1.x < pV2.x ? pV1.x : pV2.x; | |
288 pOut.y = pV1.y < pV2.y ? pV1.y : pV2.y; | |
289 pOut.z = pV1.z < pV2.z ? pV1.z : pV2.z; | |
290 return pOut; | |
291 } | |
292 | |
293 D3DXVECTOR3* D3DXVec3Maximize(D3DXVECTOR3* pOut, D3DXVECTOR3* pV1, D3DXVECTOR3* pV2) { | |
294 debug(D3DX10_DEBUG) { | |
295 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return null; | |
296 } | |
297 pOut.x = pV1.x > pV2.x ? pV1.x : pV2.x; | |
298 pOut.y = pV1.y > pV2.y ? pV1.y : pV2.y; | |
299 pOut.z = pV1.z > pV2.z ? pV1.z : pV2.z; | |
300 return pOut; | |
301 } | |
302 | |
303 D3DXVECTOR3* D3DXVec3Scale(D3DXVECTOR3* pOut, D3DXVECTOR3* pV, float s) { | |
304 debug(D3DX10_DEBUG) { | |
305 if ((pOut is null) || (pV is null)) return null; | |
306 } | |
307 pOut.x = pV.x * s; | |
308 pOut.y = pV.y * s; | |
309 pOut.z = pV.z * s; | |
310 return pOut; | |
311 } | |
312 | |
313 D3DXVECTOR3* D3DXVec3Lerp(D3DXVECTOR3* pOut, D3DXVECTOR3* pV1, D3DXVECTOR3* pV2, float s) { | |
314 debug(D3DX10_DEBUG) { | |
315 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return null; | |
316 } | |
317 pOut.x = pV1.x + s * (pV2.x - pV1.x); | |
318 pOut.y = pV1.y + s * (pV2.y - pV1.y); | |
319 pOut.z = pV1.z + s * (pV2.z - pV1.z); | |
320 return pOut; | |
321 } | |
322 | |
323 extern(Windows) { | |
324 D3DXVECTOR3* D3DXVec3Normalize(D3DXVECTOR3* pOut, D3DXVECTOR3* pV); | |
325 D3DXVECTOR3* D3DXVec3Hermite(D3DXVECTOR3* pOut, D3DXVECTOR3* pV1, D3DXVECTOR3* pT1, D3DXVECTOR3* pV2, D3DXVECTOR3* pT2, FLOAT s); | |
326 D3DXVECTOR3* D3DXVec3CatmullRom(D3DXVECTOR3* pOut, D3DXVECTOR3* pV0, D3DXVECTOR3* pV1, D3DXVECTOR3* pV2, D3DXVECTOR3* pV3, FLOAT s); | |
327 D3DXVECTOR3* D3DXVec3BaryCentric(D3DXVECTOR3* pOut, D3DXVECTOR3* pV1, D3DXVECTOR3* pV2, D3DXVECTOR3* pV3, FLOAT f, FLOAT g); | |
328 D3DXVECTOR4* D3DXVec3Transform(D3DXVECTOR4* pOut, D3DXVECTOR3* pV, D3DXMATRIX* pM); | |
329 D3DXVECTOR3* D3DXVec3TransformCoord(D3DXVECTOR3* pOut, D3DXVECTOR3* pV, D3DXMATRIX* pM); | |
330 D3DXVECTOR3* D3DXVec3TransformNormal(D3DXVECTOR3* pOut, D3DXVECTOR3* pV, D3DXMATRIX* pM); | |
331 D3DXVECTOR4* D3DXVec3TransformArray(D3DXVECTOR4* pOut, UINT OutStride, D3DXVECTOR3* pV, UINT VStride, D3DXMATRIX* pM, UINT n); | |
332 D3DXVECTOR3* D3DXVec3TransformCoordArray(D3DXVECTOR3* pOut, UINT OutStride, D3DXVECTOR3* pV, UINT VStride, D3DXMATRIX* pM, UINT n); | |
333 D3DXVECTOR3* D3DXVec3TransformNormalArray(D3DXVECTOR3* pOut, UINT OutStride, D3DXVECTOR3* pV, UINT VStride, D3DXMATRIX* pM, UINT n); | |
334 D3DXVECTOR3* D3DXVec3Project(D3DXVECTOR3* pOut, D3DXVECTOR3* pV, D3D10_VIEWPORT* pViewport, D3DXMATRIX* pProjection, D3DXMATRIX* pView, D3DXMATRIX* pWorld); | |
335 D3DXVECTOR3* D3DXVec3Unproject(D3DXVECTOR3* pOut, D3DXVECTOR3* pV, D3D10_VIEWPORT* pViewport, D3DXMATRIX* pProjection, D3DXMATRIX* pView, D3DXMATRIX* pWorld); | |
336 D3DXVECTOR3* D3DXVec3ProjectArray(D3DXVECTOR3* pOut, UINT OutStride,D3DXVECTOR3* pV, UINT VStride,D3D10_VIEWPORT* pViewport, D3DXMATRIX* pProjection, D3DXMATRIX* pView, D3DXMATRIX* pWorld, UINT n); | |
337 D3DXVECTOR3* D3DXVec3UnprojectArray(D3DXVECTOR3* pOut, UINT OutStride, D3DXVECTOR3* pV, UINT VStride, D3D10_VIEWPORT* pViewport, D3DXMATRIX* pProjection, D3DXMATRIX* pView, D3DXMATRIX* pWorld, UINT n); | |
338 } | |
339 | |
340 float D3DXVec4Length(D3DXVECTOR4* pV) { | |
341 debug(D3DX10_DEBUG) { | |
342 if (pV is null) return 0.0; | |
343 } | |
344 return sqrtf((pV.x * pV.x) + (pV.y * pV.y) + (pV.z * pV.z) + (pV.w * pV.w)); | |
345 } | |
346 | |
347 float D3DXVec4LengthSq(D3DXVECTOR4* pV) { | |
348 debug(D3DX10_DEBUG) { | |
349 if (pV is null) return 0.0; | |
350 } | |
351 return (pV.x * pV.x) + (pV.y * pV.y) + (pV.z * pV.z) + (pV.w * pV.w); | |
352 } | |
353 | |
354 float D3DXVec4Dot(D3DXVECTOR4* pV1, D3DXVECTOR4* pV2) { | |
355 debug(D3DX10_DEBUG) { | |
356 if ((pV1 is null) || (pV2 is null)) return 0.0; | |
357 } | |
358 return (pV1.x * pV2.x) + (pV1.y * pV2.y) + (pV1.z * pV2.z) + (pV1.w * pV2.w); | |
359 } | |
360 | |
361 D3DXVECTOR4* D3DXVec4Add(D3DXVECTOR4* pOut, D3DXVECTOR4* pV1, D3DXVECTOR4* pV2) { | |
362 debug(D3DX10_DEBUG) { | |
363 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return null; | |
364 } | |
365 pOut.x = pV1.x + pV2.x; | |
366 pOut.y = pV1.y + pV2.y; | |
367 pOut.z = pV1.z + pV2.z; | |
368 pOut.w = pV1.w + pV2.w; | |
369 return pOut; | |
370 } | |
371 | |
372 D3DXVECTOR4* D3DXVec4Subtract(D3DXVECTOR4* pOut, D3DXVECTOR4* pV1, D3DXVECTOR4* pV2) { | |
373 debug(D3DX10_DEBUG) { | |
374 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return null; | |
375 } | |
376 pOut.x = pV1.x - pV2.x; | |
377 pOut.y = pV1.y - pV2.y; | |
378 pOut.z = pV1.z - pV2.z; | |
379 pOut.w = pV1.w - pV2.w; | |
380 return pOut; | |
381 } | |
382 | |
383 D3DXVECTOR4* D3DXVec4Minimize(D3DXVECTOR4* pOut, D3DXVECTOR4* pV1, D3DXVECTOR4* pV2) { | |
384 debug(D3DX10_DEBUG) { | |
385 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return null; | |
386 } | |
387 pOut.x = pV1.x < pV2.x ? pV1.x : pV2.x; | |
388 pOut.y = pV1.y < pV2.y ? pV1.y : pV2.y; | |
389 pOut.z = pV1.z < pV2.z ? pV1.z : pV2.z; | |
390 pOut.w = pV1.w < pV2.w ? pV1.w : pV2.w; | |
391 return pOut; | |
392 } | |
393 | |
394 D3DXVECTOR4* D3DXVec4Maximize(D3DXVECTOR4* pOut, D3DXVECTOR4* pV1, D3DXVECTOR4* pV2) { | |
395 debug(D3DX10_DEBUG) { | |
396 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return null; | |
397 } | |
398 pOut.x = pV1.x > pV2.x ? pV1.x : pV2.x; | |
399 pOut.y = pV1.y > pV2.y ? pV1.y : pV2.y; | |
400 pOut.z = pV1.z > pV2.z ? pV1.z : pV2.z; | |
401 pOut.w = pV1.w > pV2.w ? pV1.w : pV2.w; | |
402 return pOut; | |
403 } | |
404 | |
405 D3DXVECTOR4* D3DXVec4Scale(D3DXVECTOR4* pOut, D3DXVECTOR4* pV, float s) { | |
406 debug(D3DX10_DEBUG) { | |
407 if ((pOut is null) || (pV is null)) return null; | |
408 } | |
409 pOut.x = pV.x * s; | |
410 pOut.y = pV.y * s; | |
411 pOut.z = pV.z * s; | |
412 pOut.w = pV.w * s; | |
413 return pOut; | |
414 } | |
415 | |
416 D3DXVECTOR4* D3DXVec4Lerp(D3DXVECTOR4* pOut, D3DXVECTOR4* pV1, D3DXVECTOR4* pV2, float s) { | |
417 debug(D3DX10_DEBUG) { | |
418 if ((pOut is null) || (pV1 is null) || (pV2 is null)) return null; | |
419 } | |
420 pOut.x = pV1.x + s * (pV2.x - pV1.x); | |
421 pOut.y = pV1.y + s * (pV2.y - pV1.y); | |
422 pOut.z = pV1.z + s * (pV2.z - pV1.z); | |
423 pOut.w = pV1.w + s * (pV2.w - pV1.w); | |
424 return pOut; | |
425 } | |
426 | |
427 extern(Windows) { | |
428 D3DXVECTOR4* D3DXVec4Cross(D3DXVECTOR4* pOut, D3DXVECTOR4* pV1, D3DXVECTOR4* pV2, D3DXVECTOR4* pV3); | |
429 D3DXVECTOR4* D3DXVec4Normalize(D3DXVECTOR4* pOut, D3DXVECTOR4* pV); | |
430 D3DXVECTOR4* D3DXVec4Hermite(D3DXVECTOR4* pOut, D3DXVECTOR4* pV1, D3DXVECTOR4* pT1, D3DXVECTOR4* pV2, D3DXVECTOR4* pT2, FLOAT s); | |
431 D3DXVECTOR4* D3DXVec4CatmullRom(D3DXVECTOR4* pOut, D3DXVECTOR4* pV0, D3DXVECTOR4* pV1, D3DXVECTOR4* pV2, D3DXVECTOR4* pV3, FLOAT s); | |
432 D3DXVECTOR4* D3DXVec4BaryCentric(D3DXVECTOR4* pOut, D3DXVECTOR4* pV1, D3DXVECTOR4* pV2, D3DXVECTOR4* pV3, FLOAT f, FLOAT g); | |
433 D3DXVECTOR4* D3DXVec4Transform(D3DXVECTOR4* pOut, D3DXVECTOR4* pV, D3DXMATRIX* pM); | |
434 D3DXVECTOR4* D3DXVec4TransformArray(D3DXVECTOR4* pOut, UINT OutStride, D3DXVECTOR4* pV, UINT VStride, D3DXMATRIX* pM, UINT n); | |
435 } | |
436 | |
437 D3DXMATRIX* D3DXMatrixIdentity(D3DXMATRIX *pOut) { | |
438 debug(D3DX10_DEBUG) { | |
439 if (pOut is null) return NULL; | |
440 } | |
441 pOut.m[0][1] = pOut.m[0][2] = pOut.m[0][3] = | |
442 pOut.m[1][0] = pOut.m[1][2] = pOut.m[1][3] = | |
443 pOut.m[2][0] = pOut.m[2][1] = pOut.m[2][3] = | |
444 pOut.m[3][0] = pOut.m[3][1] = pOut.m[3][2] = 0.0; | |
445 pOut.m[0][0] = pOut.m[1][1] = pOut.m[2][2] = pOut.m[3][3] = 1.0; | |
446 return pOut; | |
447 } | |
448 | |
449 | |
450 BOOL D3DXMatrixIsIdentity(D3DXMATRIX *pM) { | |
451 debug(D3DX10_DEBUG) { | |
452 if(pM is null) return FALSE; | |
453 } | |
454 return (pM.m[0][0] == 1.0f) && (pM.m[0][1] == 0.0f) && (pM.m[0][2] == 0.0f) && (pM.m[0][3] == 0.0f) && | |
455 (pM.m[1][0] == 0.0f) && (pM.m[1][1] == 1.0f) && (pM.m[1][2] == 0.0f) && (pM.m[1][3] == 0.0f) && | |
456 (pM.m[2][0] == 0.0f) && (pM.m[2][1] == 0.0f) && (pM.m[2][2] == 1.0f) && (pM.m[2][3] == 0.0f) && | |
457 (pM.m[3][0] == 0.0f) && (pM.m[3][1] == 0.0f) && (pM.m[3][2] == 0.0f) && (pM.m[3][3] == 1.0f); | |
458 } | |
459 | |
460 extern(Windows) { | |
461 FLOAT D3DXMatrixDeterminant(D3DXMATRIX* pM); | |
462 HRESULT D3DXMatrixDecompose(D3DXVECTOR3* pOutScale, D3DXQUATERNION* pOutRotation, D3DXVECTOR3* pOutTranslation, D3DXMATRIX* pM); | |
463 D3DXMATRIX* D3DXMatrixTranspose(D3DXMATRIX* pOut, D3DXMATRIX* pM); | |
464 D3DXMATRIX* D3DXMatrixMultiply(D3DXMATRIX* pOut, D3DXMATRIX* pM1, D3DXMATRIX* pM2); | |
465 D3DXMATRIX* D3DXMatrixMultiplyTranspose(D3DXMATRIX* pOut, D3DXMATRIX* pM1, D3DXMATRIX* pM2); | |
466 D3DXMATRIX* D3DXMatrixInverse(D3DXMATRIX* pOut, FLOAT* pDeterminant, D3DXMATRIX* pM); | |
467 D3DXMATRIX* D3DXMatrixScaling(D3DXMATRIX* pOut, FLOAT sx, FLOAT sy, FLOAT sz); | |
468 D3DXMATRIX* D3DXMatrixTranslation(D3DXMATRIX* pOut, FLOAT x, FLOAT y, FLOAT z); | |
469 D3DXMATRIX* D3DXMatrixRotationX(D3DXMATRIX* pOut, FLOAT Angle); | |
470 D3DXMATRIX* D3DXMatrixRotationY(D3DXMATRIX* pOut, FLOAT Angle); | |
471 D3DXMATRIX* D3DXMatrixRotationZ(D3DXMATRIX* pOut, FLOAT Angle); | |
472 D3DXMATRIX* D3DXMatrixRotationAxis(D3DXMATRIX* pOut, D3DXVECTOR3* pV, FLOAT Angle); | |
473 D3DXMATRIX* D3DXMatrixRotationQuaternion(D3DXMATRIX* pOut, D3DXQUATERNION* pQ); | |
474 D3DXMATRIX* D3DXMatrixRotationYawPitchRoll(D3DXMATRIX* pOut, FLOAT Yaw, FLOAT Pitch, FLOAT Roll); | |
475 D3DXMATRIX* D3DXMatrixTransformation(D3DXMATRIX* pOut, D3DXVECTOR3* pScalingCenter, D3DXQUATERNION* pScalingRotation, D3DXVECTOR3* pScaling, D3DXVECTOR3* pRotationCenter, D3DXQUATERNION* pRotation, D3DXVECTOR3* pTranslation); | |
476 D3DXMATRIX* D3DXMatrixTransformation2D(D3DXMATRIX* pOut, D3DXVECTOR2* pScalingCenter, FLOAT ScalingRotation, D3DXVECTOR2* pScaling, D3DXVECTOR2* pRotationCenter, FLOAT Rotation, D3DXVECTOR2* pTranslation); | |
477 D3DXMATRIX* D3DXMatrixAffineTransformation(D3DXMATRIX* pOut, FLOAT Scaling, D3DXVECTOR3* pRotationCenter, D3DXQUATERNION* pRotation, D3DXVECTOR3* pTranslation); | |
478 D3DXMATRIX* D3DXMatrixAffineTransformation2D(D3DXMATRIX* pOut, FLOAT Scaling, D3DXVECTOR2* pRotationCenter, FLOAT Rotation, D3DXVECTOR2* pTranslation); | |
479 D3DXMATRIX* D3DXMatrixLookAtRH(D3DXMATRIX* pOut, D3DXVECTOR3* pEye, D3DXVECTOR3* pAt, D3DXVECTOR3* pUp); | |
480 D3DXMATRIX* D3DXMatrixLookAtLH(D3DXMATRIX* pOut, D3DXVECTOR3* pEye, D3DXVECTOR3* pAt, D3DXVECTOR3* pUp); | |
481 D3DXMATRIX* D3DXMatrixPerspectiveRH(D3DXMATRIX* pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf); | |
482 D3DXMATRIX* D3DXMatrixPerspectiveLH(D3DXMATRIX* pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf); | |
483 D3DXMATRIX* D3DXMatrixPerspectiveFovRH(D3DXMATRIX* pOut, FLOAT fovy, FLOAT Aspect, FLOAT zn, FLOAT zf); | |
484 D3DXMATRIX* D3DXMatrixPerspectiveFovLH(D3DXMATRIX* pOut, FLOAT fovy, FLOAT Aspect, FLOAT zn, FLOAT zf); | |
485 D3DXMATRIX* D3DXMatrixPerspectiveOffCenterRH(D3DXMATRIX* pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf); | |
486 D3DXMATRIX* D3DXMatrixPerspectiveOffCenterLH(D3DXMATRIX* pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf); | |
487 D3DXMATRIX* D3DXMatrixOrthoRH(D3DXMATRIX* pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf); | |
488 D3DXMATRIX* D3DXMatrixOrthoLH(D3DXMATRIX* pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf); | |
489 D3DXMATRIX* D3DXMatrixOrthoOffCenterRH(D3DXMATRIX* pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf); | |
490 D3DXMATRIX* D3DXMatrixOrthoOffCenterLH(D3DXMATRIX* pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf); | |
491 D3DXMATRIX* D3DXMatrixShadow(D3DXMATRIX* pOut, D3DXVECTOR4* pLight, D3DXPLANE* pPlane); | |
492 D3DXMATRIX* D3DXMatrixReflect(D3DXMATRIX* pOut, D3DXPLANE* pPlane); | |
493 } | |
494 | |
495 float D3DXQuaternionLength(D3DXQUATERNION *pQ) { | |
496 debug(D3DX10_DEBUG) { | |
497 if (pQ is null) return 0.0f; | |
498 } | |
499 return sqrtf((pQ.x * pQ.x) + (pQ.y * pQ.y) + (pQ.z * pQ.z) + (pQ.w * pQ.w)); | |
500 } | |
501 | |
502 float D3DXQuaternionLengthSq(D3DXQUATERNION *pQ) { | |
503 debug(D3DX10_DEBUG) { | |
504 if(pQ is null) return 0.0f; | |
505 } | |
506 return (pQ.x * pQ.x) + (pQ.y * pQ.y) + (pQ.z * pQ.z) + (pQ.w * pQ.w); | |
507 } | |
508 | |
509 float D3DXQuaternionDot(D3DXQUATERNION *pQ1, D3DXQUATERNION *pQ2) { | |
510 debug(D3DX10_DEBUG) { | |
511 if((pQ1 is null) || (pQ2 is null)) return 0.0f; | |
512 } | |
513 return (pQ1.x * pQ2.x) + (pQ1.y * pQ2.y) + (pQ1.z * pQ2.z) + (pQ1.w * pQ2.w); | |
514 } | |
515 | |
516 D3DXQUATERNION* D3DXQuaternionIdentity(D3DXQUATERNION *pOut) { | |
517 debug(D3DX10_DEBUG) { | |
518 if(pOut is null) return null; | |
519 } | |
520 pOut.x = pOut.y = pOut.z = 0.0f; | |
521 pOut.w = 1.0f; | |
522 return pOut; | |
523 } | |
524 | |
525 bool D3DXQuaternionIsIdentity(D3DXQUATERNION *pQ) { | |
526 debug(D3DX10_DEBUG) { | |
527 if(pQ is null) return false; | |
528 } | |
529 return (pQ.x == 0.0f) && (pQ.y == 0.0f) && (pQ.z == 0.0f) && (pQ.w == 1.0f); | |
530 } | |
531 | |
532 D3DXQUATERNION* D3DXQuaternionConjugate(D3DXQUATERNION *pOut, D3DXQUATERNION *pQ) { | |
533 debug(D3DX10_DEBUG) { | |
534 if((pOut is null) || (pQis is null)) return null; | |
535 } | |
536 pOut.x = -pQ.x; | |
537 pOut.y = -pQ.y; | |
538 pOut.z = -pQ.z; | |
539 pOut.w = pQ.w; | |
540 return pOut; | |
541 } | |
542 | |
543 extern(Windows) { | |
544 void D3DXQuaternionToAxisAngle(D3DXQUATERNION* pQ, D3DXVECTOR3* pAxis, FLOAT* pAngle); | |
545 D3DXQUATERNION* D3DXQuaternionRotationMatrix(D3DXQUATERNION* pOut, D3DXMATRIX* pM); | |
546 D3DXQUATERNION* D3DXQuaternionRotationAxis(D3DXQUATERNION* pOut, D3DXVECTOR3* pV, FLOAT Angle); | |
547 D3DXQUATERNION* D3DXQuaternionRotationYawPitchRoll(D3DXQUATERNION* pOut, FLOAT Yaw, FLOAT Pitch, FLOAT Roll); | |
548 D3DXQUATERNION* D3DXQuaternionMultiply(D3DXQUATERNION* pOut, D3DXQUATERNION* pQ1, D3DXQUATERNION* pQ2); | |
549 D3DXQUATERNION* D3DXQuaternionNormalize(D3DXQUATERNION* pOut, D3DXQUATERNION* pQ); | |
550 D3DXQUATERNION* D3DXQuaternionInverse(D3DXQUATERNION* pOut, D3DXQUATERNION* pQ); | |
551 D3DXQUATERNION* D3DXQuaternionLn(D3DXQUATERNION* pOut, D3DXQUATERNION* pQ); | |
552 D3DXQUATERNION* D3DXQuaternionExp(D3DXQUATERNION* pOut, D3DXQUATERNION* pQ); | |
553 D3DXQUATERNION* D3DXQuaternionSlerp(D3DXQUATERNION* pOut, D3DXQUATERNION* pQ1, D3DXQUATERNION* pQ2, FLOAT t); | |
554 D3DXQUATERNION* D3DXQuaternionSquad(D3DXQUATERNION* pOut, D3DXQUATERNION* pQ1, D3DXQUATERNION* pA, D3DXQUATERNION* pB, D3DXQUATERNION* pC, FLOAT t); | |
555 void D3DXQuaternionSquadSetup(D3DXQUATERNION* pAOut, D3DXQUATERNION* pBOut, D3DXQUATERNION* pCOut, D3DXQUATERNION* pQ0, D3DXQUATERNION* pQ1, D3DXQUATERNION* pQ2, D3DXQUATERNION* pQ3); | |
556 D3DXQUATERNION* D3DXQuaternionBaryCentric(D3DXQUATERNION* pOut, D3DXQUATERNION* pQ1, D3DXQUATERNION* pQ2, D3DXQUATERNION* pQ3, FLOAT f, FLOAT g); | |
557 } | |
558 | |
559 float D3DXPlaneDot(D3DXPLANE *pP, D3DXVECTOR4 *pV) { | |
560 debug(D3DX10_DEBUG) { | |
561 if((pP is null) || (pV is null)) return 0.0f; | |
562 } | |
563 return (pP.a * pV.x) + (pP.b * pV.y) + (pP.c * pV.z) + (pP.d * pV.w); | |
564 } | |
565 | |
566 float D3DXPlaneDotCoord(D3DXPLANE *pP, D3DXVECTOR3 *pV) { | |
567 debug(D3DX10_DEBUG) { | |
568 if((pP is null) || (pV is null)) return 0.0f; | |
569 } | |
570 return (pP.a * pV.x) + (pP.b * pV.y) + (pP.c * pV.z) + pP.d; | |
571 } | |
572 | |
573 float D3DXPlaneDotNormal(D3DXPLANE *pP, D3DXVECTOR3 *pV) { | |
574 debug(D3DX10_DEBUG) { | |
575 if((pP is null) || (pV is null)) return 0.0f; | |
576 } | |
577 return (pP.a * pV.x) + (pP.b * pV.y) + (pP.c * pV.z); | |
578 } | |
579 | |
580 D3DXPLANE* D3DXPlaneScale(D3DXPLANE *pOut, D3DXPLANE *pP, float s) { | |
581 debug(D3DX10_DEBUG) { | |
582 if((pOut is null) || (pP is null)) return null; | |
583 } | |
584 pOut.a = pP.a * s; | |
585 pOut.b = pP.b * s; | |
586 pOut.c = pP.c * s; | |
587 pOut.d = pP.d * s; | |
588 return pOut; | |
589 } | |
590 | |
591 extern(Windows) { | |
592 D3DXPLANE* D3DXPlaneNormalize(D3DXPLANE* pOut, D3DXPLANE* pP); | |
593 D3DXVECTOR3* D3DXPlaneIntersectLine(D3DXVECTOR3* pOut, D3DXPLANE* pP, D3DXVECTOR3* pV1, D3DXVECTOR3* pV2); | |
594 D3DXPLANE* D3DXPlaneFromPointNormal(D3DXPLANE* pOut, D3DXVECTOR3* pPoint, D3DXVECTOR3* pNormal); | |
595 D3DXPLANE* D3DXPlaneFromPoints(D3DXPLANE* pOut, D3DXVECTOR3* pV1, D3DXVECTOR3* pV2, D3DXVECTOR3* pV3); | |
596 D3DXPLANE* D3DXPlaneTransform(D3DXPLANE* pOut, D3DXPLANE* pP, D3DXMATRIX* pM); | |
597 D3DXPLANE* D3DXPlaneTransformArray(D3DXPLANE* pOut, UINT OutStride, D3DXPLANE* pP, UINT PStride, D3DXMATRIX* pM, UINT n); | |
598 } | |
599 | |
600 D3DXCOLOR* D3DXColorNegative(D3DXCOLOR* pOut, D3DXCOLOR* pC) { | |
601 debug(D3DX10_DEBUG) { | |
602 if((pOut is null) || (pC is null)) return null; | |
603 } | |
604 pOut.r = 1.0f - pC.r; | |
605 pOut.g = 1.0f - pC.g; | |
606 pOut.b = 1.0f - pC.b; | |
607 pOut.a = pC.a; | |
608 return pOut; | |
609 } | |
610 | |
611 D3DXCOLOR* D3DXColorAdd(D3DXCOLOR* pOut, D3DXCOLOR* pC1, D3DXCOLOR* pC2) { | |
612 debug(D3DX10_DEBUG) { | |
613 if((pOut is null) || (pC1 is null) || (pC2 is null)) return null; | |
614 } | |
615 pOut.r = pC1.r + pC2.r; | |
616 pOut.g = pC1.g + pC2.g; | |
617 pOut.b = pC1.b + pC2.b; | |
618 pOut.a = pC1.a + pC2.a; | |
619 return pOut; | |
620 } | |
621 | |
622 D3DXCOLOR* D3DXColorSubtract(D3DXCOLOR* pOut, D3DXCOLOR* pC1, D3DXCOLOR* pC2) { | |
623 debug(D3DX10_DEBUG) { | |
624 if((pOut is null) || (pC1 is null) || (pC2 is null)) return null; | |
625 } | |
626 pOut.r = pC1.r - pC2.r; | |
627 pOut.g = pC1.g - pC2.g; | |
628 pOut.b = pC1.b - pC2.b; | |
629 pOut.a = pC1.a - pC2.a; | |
630 return pOut; | |
631 } | |
632 | |
633 D3DXCOLOR* D3DXColorScale(D3DXCOLOR* pOut, D3DXCOLOR* pC, float s) { | |
634 debug(D3DX10_DEBUG) { | |
635 if((pOut is null) || (pC is null)) return null; | |
636 } | |
637 pOut.r = pC.r * s; | |
638 pOut.g = pC.g * s; | |
639 pOut.b = pC.b * s; | |
640 pOut.a = pC.a * s; | |
641 return pOut; | |
642 } | |
643 | |
644 D3DXCOLOR* D3DXColorModulate(D3DXCOLOR* pOut, D3DXCOLOR* pC1, D3DXCOLOR* pC2) { | |
645 debug(D3DX10_DEBUG) { | |
646 if((pOut is null) || (pC1 is null) || (pC2 is null)) return null; | |
647 } | |
648 pOut.r = pC1.r * pC2.r; | |
649 pOut.g = pC1.g * pC2.g; | |
650 pOut.b = pC1.b * pC2.b; | |
651 pOut.a = pC1.a * pC2.a; | |
652 return pOut; | |
653 } | |
654 | |
655 D3DXCOLOR* D3DXColorLerp(D3DXCOLOR* pOut, D3DXCOLOR* pC1, D3DXCOLOR* pC2, float s) { | |
656 debug(D3DX10_DEBUG) { | |
657 if((pOut is null) || (pC1 is null) || (pC2 is null)) return null; | |
658 } | |
659 pOut.r = pC1.r + s * (pC2.r - pC1.r); | |
660 pOut.g = pC1.g + s * (pC2.g - pC1.g); | |
661 pOut.b = pC1.b + s * (pC2.b - pC1.b); | |
662 pOut.a = pC1.a + s * (pC2.a - pC1.a); | |
663 return pOut; | |
664 } | |
665 | |
666 extern(Windows) { | |
667 D3DXCOLOR* D3DXColorAdjustSaturation(D3DXCOLOR* pOut, D3DXCOLOR* pC, float s); | |
668 D3DXCOLOR* D3DXColorAdjustContrast(D3DXCOLOR* pOut, D3DXCOLOR* pC, float c); | |
669 FLOAT D3DXFresnelTerm(float CosTheta, float RefractionIndex); | |
670 } | |
671 | |
672 extern (C) const GUID IID_ID3DXMatrixStack = {0xc7885ba7, 0xf990, 0x4fe7, [0x92, 0x2d, 0x85, 0x15, 0xe4, 0x77, 0xdd, 0x85]}; | |
673 | |
674 interface ID3DXMatrixStack : IUnknown { | |
675 extern(Windows) : | |
676 HRESULT Pop(); | |
677 HRESULT Push(); | |
678 HRESULT LoadIdentity(); | |
679 HRESULT LoadMatrix(D3DXMATRIX* pM ); | |
680 HRESULT MultMatrix(D3DXMATRIX* pM ); | |
681 HRESULT MultMatrixLocal(D3DXMATRIX* pM ); | |
682 HRESULT RotateAxis(D3DXVECTOR3* pV, float Angle); | |
683 HRESULT RotateAxisLocal(D3DXVECTOR3* pV, float Angle); | |
684 HRESULT RotateYawPitchRoll(float Yaw, float Pitch, float Roll); | |
685 HRESULT RotateYawPitchRollLocal(float Yaw, float Pitch, float Roll); | |
686 HRESULT Scale(float x, float y, float z); | |
687 HRESULT ScaleLocal(float x, float y, float z); | |
688 HRESULT Translate(float x, float y, float z ); | |
689 HRESULT TranslateLocal(float x, float y, float z); | |
690 D3DXMATRIX* GetTop(); | |
691 } | |
692 | |
693 //TODO extern(Windows) HRESULT D3DXCreateMatrixStack(UINT Flags, D3DXMATRIXSTACK* ppStack); | |
694 | |
695 const D3DXSH_MINORDER = 2; | |
696 const D3DXSH_MAXORDER = 6; | |
697 | |
698 extern(Windows) { | |
699 float* D3DXSHEvalDirection(float* pOut, UINT Order, D3DXVECTOR3* pDir); | |
700 float* D3DXSHRotate(float* pOut, UINT Order, D3DXMATRIX* pMatrix, float* pIn); | |
701 float* D3DXSHRotateZ(float* pOut, UINT Order, float Angle, float* pIn); | |
702 float* D3DXSHAdd(float* pOut, UINT Order, float* pA, float* pB); | |
703 float* D3DXSHScale(float* pOut, UINT Order, float* pIn, float Scale); | |
704 float D3DXSHDot(UINT Order, float* pA, float* pB); | |
705 float* D3DXSHMultiply2(float* pOut, float* pF, float* pG); | |
706 float* D3DXSHMultiply3(float* pOut, float* pF, float* pG); | |
707 float* D3DXSHMultiply4(float* pOut, float* pF, float* pG); | |
708 float* D3DXSHMultiply5(float* pOut, float* pF, float* pG); | |
709 float* D3DXSHMultiply6(float* pOut, float* pF, float* pG); | |
710 HRESULT D3DXSHEvalDirectionalLight(UINT Order, D3DXVECTOR3* pDir, float RIntensity, float GIntensity, float BIntensity, float* pROut, float* pGOut, float* pBOut); | |
711 HRESULT D3DXSHEvalSphericalLight(UINT Order, D3DXVECTOR3* pPos, float Radius, float RIntensity, float GIntensity, float BIntensity, float* pROut, float* pGOut, float* pBOut); | |
712 HRESULT D3DXSHEvalConeLight(UINT Order, D3DXVECTOR3* pDir, float Radius, float RIntensity, float GIntensity, float BIntensity, float* pROut, float* pGOut, float* pBOut); | |
713 HRESULT D3DXSHEvalHemisphereLight(UINT Order, D3DXVECTOR3* pDir, D3DXCOLOR Top, D3DXCOLOR Bottom, float* pROut, float* pGOut, float* pBOut); | |
714 BOOL D3DXIntersectTri(D3DXVECTOR3* p0, D3DXVECTOR3* p1, D3DXVECTOR3* p2, D3DXVECTOR3* pRayPos, D3DXVECTOR3* pRayDir, float* pU, float* pV, float* pDist); | |
715 BOOL D3DXSphereBoundProbe(D3DXVECTOR3* pCenter, float Radius, D3DXVECTOR3* pRayPosition, D3DXVECTOR3* pRayDirection); | |
716 BOOL D3DXBoxBoundProbe(D3DXVECTOR3* pMin, D3DXVECTOR3* pMax, D3DXVECTOR3* pRayPosition, D3DXVECTOR3* pRayDirection); | |
717 HRESULT D3DXComputeBoundingSphere(D3DXVECTOR3* pFirstPosition, DWORD NumVertices, DWORD dwStride, D3DXVECTOR3* pCenter, float* pRadius); | |
718 HRESULT D3DXComputeBoundingBox(D3DXVECTOR3* pFirstPosition, DWORD NumVertices, DWORD dwStride, D3DXVECTOR3* pMin, D3DXVECTOR3* pMax); | |
719 } | |
720 | |
721 enum D3DX_CPU_OPTIMIZATION { | |
722 D3DX_NOT_OPTIMIZED = 0, | |
723 D3DX_3DNOW_OPTIMIZED, | |
724 D3DX_SSE2_OPTIMIZED, | |
725 D3DX_SSE_OPTIMIZED | |
726 } | |
727 | |
728 extern(Windows) D3DX_CPU_OPTIMIZATION D3DXCpuOptimizations(bool Enable); |