?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winemac: Fix the logic for checking if a view is already in the intended z-order.
[wine.git] / dlls / d3dx9_36 / mesh.c
blob3204ea740b26ca372356e9340a89a2c276cc8973
1 /*
2 * Mesh operations specific to D3DX9.
3 *
4 * Copyright (C) 2005 Henri Verbeet
5 * Copyright (C) 2006 Ivan Gyurdiev
6 * Copyright (C) 2009 David Adam
7 * Copyright (C) 2010 Tony Wasserka
8 * Copyright (C) 2011 Dylan Smith
9 * Copyright (C) 2011 Michael Mc Donnell
10 * Copyright (C) 2013 Christian Costa
11 *
12 * This library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
16 *
17 * This library is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
21 *
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with this library; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 */
26
27 #include "config.h"
28 #include "wine/port.h"
29
30 #include <assert.h>
31 #ifdef HAVE_FLOAT_H
32 # include <float.h>
33 #endif
34
35 #include "d3dx9_private.h"
36 #undef MAKE_DDHRESULT
37 #include "dxfile.h"
38 #include "rmxfguid.h"
39 #include "rmxftmpl.h"
40 #include "wine/unicode.h"
41 #include "wine/list.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
44
45 struct d3dx9_mesh
46 {
47 ID3DXMesh ID3DXMesh_iface;
48 LONG ref;
49
50 DWORD numfaces;
51 DWORD numvertices;
52 DWORD options;
53 DWORD fvf;
54 IDirect3DDevice9 *device;
55 D3DVERTEXELEMENT9 cached_declaration[MAX_FVF_DECL_SIZE];
56 IDirect3DVertexDeclaration9 *vertex_declaration;
57 UINT vertex_declaration_size;
58 UINT num_elem;
59 IDirect3DVertexBuffer9 *vertex_buffer;
60 IDirect3DIndexBuffer9 *index_buffer;
61 DWORD *attrib_buffer;
62 int attrib_buffer_lock_count;
63 DWORD attrib_table_size;
64 D3DXATTRIBUTERANGE *attrib_table;
65 };
66
67 static const UINT d3dx_decltype_size[] =
68 {
69 /* D3DDECLTYPE_FLOAT1 */ sizeof(FLOAT),
70 /* D3DDECLTYPE_FLOAT2 */ sizeof(D3DXVECTOR2),
71 /* D3DDECLTYPE_FLOAT3 */ sizeof(D3DXVECTOR3),
72 /* D3DDECLTYPE_FLOAT4 */ sizeof(D3DXVECTOR4),
73 /* D3DDECLTYPE_D3DCOLOR */ sizeof(D3DCOLOR),
74 /* D3DDECLTYPE_UBYTE4 */ 4 * sizeof(BYTE),
75 /* D3DDECLTYPE_SHORT2 */ 2 * sizeof(SHORT),
76 /* D3DDECLTYPE_SHORT4 */ 4 * sizeof(SHORT),
77 /* D3DDECLTYPE_UBYTE4N */ 4 * sizeof(BYTE),
78 /* D3DDECLTYPE_SHORT2N */ 2 * sizeof(SHORT),
79 /* D3DDECLTYPE_SHORT4N */ 4 * sizeof(SHORT),
80 /* D3DDECLTYPE_USHORT2N */ 2 * sizeof(USHORT),
81 /* D3DDECLTYPE_USHORT4N */ 4 * sizeof(USHORT),
82 /* D3DDECLTYPE_UDEC3 */ 4, /* 3 * 10 bits + 2 padding */
83 /* D3DDECLTYPE_DEC3N */ 4,
84 /* D3DDECLTYPE_FLOAT16_2 */ 2 * sizeof(D3DXFLOAT16),
85 /* D3DDECLTYPE_FLOAT16_4 */ 4 * sizeof(D3DXFLOAT16),
86 };
87
88 static inline struct d3dx9_mesh *impl_from_ID3DXMesh(ID3DXMesh *iface)
89 {
90 return CONTAINING_RECORD(iface, struct d3dx9_mesh, ID3DXMesh_iface);
91 }
92
93 static HRESULT WINAPI d3dx9_mesh_QueryInterface(ID3DXMesh *iface, REFIID riid, void **out)
94 {
95 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
96
97 if (IsEqualGUID(riid, &IID_IUnknown) ||
98 IsEqualGUID(riid, &IID_ID3DXBaseMesh) ||
99 IsEqualGUID(riid, &IID_ID3DXMesh))
100 {
101 iface->lpVtbl->AddRef(iface);
102 *out = iface;
103 return S_OK;
104 }
105
106 WARN("Interface %s not found.\n", debugstr_guid(riid));
107
108 return E_NOINTERFACE;
109 }
110
111 static ULONG WINAPI d3dx9_mesh_AddRef(ID3DXMesh *iface)
112 {
113 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
114 ULONG refcount = InterlockedIncrement(&mesh->ref);
115
116 TRACE("%p increasing refcount to %u.\n", mesh, refcount);
117
118 return refcount;
119 }
120
121 static ULONG WINAPI d3dx9_mesh_Release(ID3DXMesh *iface)
122 {
123 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
124 ULONG refcount = InterlockedDecrement(&mesh->ref);
125
126 TRACE("%p decreasing refcount to %u.\n", mesh, refcount);
127
128 if (!refcount)
129 {
130 IDirect3DIndexBuffer9_Release(mesh->index_buffer);
131 IDirect3DVertexBuffer9_Release(mesh->vertex_buffer);
132 if (mesh->vertex_declaration)
133 IDirect3DVertexDeclaration9_Release(mesh->vertex_declaration);
134 IDirect3DDevice9_Release(mesh->device);
135 HeapFree(GetProcessHeap(), 0, mesh->attrib_buffer);
136 HeapFree(GetProcessHeap(), 0, mesh->attrib_table);
137 HeapFree(GetProcessHeap(), 0, mesh);
138 }
139
140 return refcount;
141 }
142
143 static HRESULT WINAPI d3dx9_mesh_DrawSubset(ID3DXMesh *iface, DWORD attrib_id)
144 {
145 struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
146 HRESULT hr;
147 DWORD face_start;
148 DWORD face_end = 0;
149 DWORD vertex_size;
150
151 TRACE("iface %p, attrib_id %u.\n", iface, attrib_id);
152
153 if (!This->vertex_declaration)
154 {
155 WARN("Can't draw a mesh with an invalid vertex declaration.\n");
156 return E_FAIL;
157 }
158
159 vertex_size = iface->lpVtbl->GetNumBytesPerVertex(iface);
160
161 hr = IDirect3DDevice9_SetVertexDeclaration(This->device, This->vertex_declaration);
162 if (FAILED(hr)) return hr;
163 hr = IDirect3DDevice9_SetStreamSource(This->device, 0, This->vertex_buffer, 0, vertex_size);
164 if (FAILED(hr)) return hr;
165 hr = IDirect3DDevice9_SetIndices(This->device, This->index_buffer);
166 if (FAILED(hr)) return hr;
167
168 while (face_end < This->numfaces)
169 {
170 for (face_start = face_end; face_start < This->numfaces; face_start++)
171 {
172 if (This->attrib_buffer[face_start] == attrib_id)
173 break;
174 }
175 if (face_start >= This->numfaces)
176 break;
177 for (face_end = face_start + 1; face_end < This->numfaces; face_end++)
178 {
179 if (This->attrib_buffer[face_end] != attrib_id)
180 break;
181 }
182
183 hr = IDirect3DDevice9_DrawIndexedPrimitive(This->device, D3DPT_TRIANGLELIST,
184 0, 0, This->numvertices, face_start * 3, face_end - face_start);
185 if (FAILED(hr)) return hr;
186 }
187
188 return D3D_OK;
189 }
190
191 static DWORD WINAPI d3dx9_mesh_GetNumFaces(ID3DXMesh *iface)
192 {
193 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
194
195 TRACE("iface %p.\n", iface);
196
197 return mesh->numfaces;
198 }
199
200 static DWORD WINAPI d3dx9_mesh_GetNumVertices(ID3DXMesh *iface)
201 {
202 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
203
204 TRACE("iface %p.\n", iface);
205
206 return mesh->numvertices;
207 }
208
209 static DWORD WINAPI d3dx9_mesh_GetFVF(ID3DXMesh *iface)
210 {
211 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
212
213 TRACE("iface %p.\n", iface);
214
215 return mesh->fvf;
216 }
217
218 static void copy_declaration(D3DVERTEXELEMENT9 *dst, const D3DVERTEXELEMENT9 *src, UINT num_elem)
219 {
220 memcpy(dst, src, num_elem * sizeof(*src));
221 }
222
223 static HRESULT WINAPI d3dx9_mesh_GetDeclaration(ID3DXMesh *iface, D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE])
224 {
225 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
226
227 TRACE("iface %p, declaration %p.\n", iface, declaration);
228
229 if (!declaration)
230 return D3DERR_INVALIDCALL;
231
232 copy_declaration(declaration, mesh->cached_declaration, mesh->num_elem);
233
234 return D3D_OK;
235 }
236
237 static DWORD WINAPI d3dx9_mesh_GetNumBytesPerVertex(ID3DXMesh *iface)
238 {
239 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
240
241 TRACE("iface %p.\n", iface);
242
243 return mesh->vertex_declaration_size;
244 }
245
246 static DWORD WINAPI d3dx9_mesh_GetOptions(ID3DXMesh *iface)
247 {
248 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
249
250 TRACE("iface %p.\n", iface);
251
252 return mesh->options;
253 }
254
255 static HRESULT WINAPI d3dx9_mesh_GetDevice(struct ID3DXMesh *iface, struct IDirect3DDevice9 **device)
256 {
257 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
258
259 TRACE("iface %p, device %p.\n", iface, device);
260
261 if (!device)
262 return D3DERR_INVALIDCALL;
263 *device = mesh->device;
264 IDirect3DDevice9_AddRef(mesh->device);
265
266 return D3D_OK;
267 }
268
269 static HRESULT WINAPI d3dx9_mesh_CloneMeshFVF(struct ID3DXMesh *iface, DWORD options, DWORD fvf,
270 struct IDirect3DDevice9 *device, struct ID3DXMesh **clone_mesh)
271 {
272 HRESULT hr;
273 D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE];
274
275 TRACE("iface %p, options %#x, fvf %#x, device %p, clone_mesh %p.\n",
276 iface, options, fvf, device, clone_mesh);
277
278 if (FAILED(hr = D3DXDeclaratorFromFVF(fvf, declaration)))
279 return hr;
280
281 return iface->lpVtbl->CloneMesh(iface, options, declaration, device, clone_mesh);
282 }
283
284 static FLOAT scale_clamp_ubyten(FLOAT value)
285 {
286 value = value * UCHAR_MAX;
287
288 if (value < 0.0f)
289 {
290 return 0.0f;
291 }
292 else
293 {
294 if (value > UCHAR_MAX) /* Clamp at 255 */
295 return UCHAR_MAX;
296 else
297 return value;
298 }
299 }
300
301 static FLOAT scale_clamp_shortn(FLOAT value)
302 {
303 value = value * SHRT_MAX;
304
305 /* The tests show that the range is SHRT_MIN + 1 to SHRT_MAX. */
306 if (value <= SHRT_MIN)
307 {
308 return SHRT_MIN + 1;
309 }
310 else if (value > SHRT_MAX)
311 {
312 return SHRT_MAX;
313 }
314 else
315 {
316 return value;
317 }
318 }
319
320 static FLOAT scale_clamp_ushortn(FLOAT value)
321 {
322 value = value * USHRT_MAX;
323
324 if (value < 0.0f)
325 {
326 return 0.0f;
327 }
328 else
329 {
330 if (value > USHRT_MAX) /* Clamp at 65535 */
331 return USHRT_MAX;
332 else
333 return value;
334 }
335 }
336
337 static INT simple_round(FLOAT value)
338 {
339 int res = (INT)(value + 0.5f);
340
341 return res;
342 }
343
344 static void convert_float4(BYTE *dst, const D3DXVECTOR4 *src, D3DDECLTYPE type_dst)
345 {
346 BOOL fixme_once = FALSE;
347
348 switch (type_dst)
349 {
350 case D3DDECLTYPE_FLOAT1:
351 {
352 FLOAT *dst_ptr = (FLOAT*)dst;
353 *dst_ptr = src->x;
354 break;
355 }
356 case D3DDECLTYPE_FLOAT2:
357 {
358 D3DXVECTOR2 *dst_ptr = (D3DXVECTOR2*)dst;
359 dst_ptr->x = src->x;
360 dst_ptr->y = src->y;
361 break;
362 }
363 case D3DDECLTYPE_FLOAT3:
364 {
365 D3DXVECTOR3 *dst_ptr = (D3DXVECTOR3*)dst;
366 dst_ptr->x = src->x;
367 dst_ptr->y = src->y;
368 dst_ptr->z = src->z;
369 break;
370 }
371 case D3DDECLTYPE_FLOAT4:
372 {
373 D3DXVECTOR4 *dst_ptr = (D3DXVECTOR4*)dst;
374 dst_ptr->x = src->x;
375 dst_ptr->y = src->y;
376 dst_ptr->z = src->z;
377 dst_ptr->w = src->w;
378 break;
379 }
380 case D3DDECLTYPE_D3DCOLOR:
381 {
382 dst[0] = (BYTE)simple_round(scale_clamp_ubyten(src->z));
383 dst[1] = (BYTE)simple_round(scale_clamp_ubyten(src->y));
384 dst[2] = (BYTE)simple_round(scale_clamp_ubyten(src->x));
385 dst[3] = (BYTE)simple_round(scale_clamp_ubyten(src->w));
386 break;
387 }
388 case D3DDECLTYPE_UBYTE4:
389 {
390 dst[0] = src->x < 0.0f ? 0 : (BYTE)simple_round(src->x);
391 dst[1] = src->y < 0.0f ? 0 : (BYTE)simple_round(src->y);
392 dst[2] = src->z < 0.0f ? 0 : (BYTE)simple_round(src->z);
393 dst[3] = src->w < 0.0f ? 0 : (BYTE)simple_round(src->w);
394 break;
395 }
396 case D3DDECLTYPE_SHORT2:
397 {
398 SHORT *dst_ptr = (SHORT*)dst;
399 dst_ptr[0] = (SHORT)simple_round(src->x);
400 dst_ptr[1] = (SHORT)simple_round(src->y);
401 break;
402 }
403 case D3DDECLTYPE_SHORT4:
404 {
405 SHORT *dst_ptr = (SHORT*)dst;
406 dst_ptr[0] = (SHORT)simple_round(src->x);
407 dst_ptr[1] = (SHORT)simple_round(src->y);
408 dst_ptr[2] = (SHORT)simple_round(src->z);
409 dst_ptr[3] = (SHORT)simple_round(src->w);
410 break;
411 }
412 case D3DDECLTYPE_UBYTE4N:
413 {
414 dst[0] = (BYTE)simple_round(scale_clamp_ubyten(src->x));
415 dst[1] = (BYTE)simple_round(scale_clamp_ubyten(src->y));
416 dst[2] = (BYTE)simple_round(scale_clamp_ubyten(src->z));
417 dst[3] = (BYTE)simple_round(scale_clamp_ubyten(src->w));
418 break;
419 }
420 case D3DDECLTYPE_SHORT2N:
421 {
422 SHORT *dst_ptr = (SHORT*)dst;
423 dst_ptr[0] = (SHORT)simple_round(scale_clamp_shortn(src->x));
424 dst_ptr[1] = (SHORT)simple_round(scale_clamp_shortn(src->y));
425 break;
426 }
427 case D3DDECLTYPE_SHORT4N:
428 {
429 SHORT *dst_ptr = (SHORT*)dst;
430 dst_ptr[0] = (SHORT)simple_round(scale_clamp_shortn(src->x));
431 dst_ptr[1] = (SHORT)simple_round(scale_clamp_shortn(src->y));
432 dst_ptr[2] = (SHORT)simple_round(scale_clamp_shortn(src->z));
433 dst_ptr[3] = (SHORT)simple_round(scale_clamp_shortn(src->w));
434 break;
435 }
436 case D3DDECLTYPE_USHORT2N:
437 {
438 USHORT *dst_ptr = (USHORT*)dst;
439 dst_ptr[0] = (USHORT)simple_round(scale_clamp_ushortn(src->x));
440 dst_ptr[1] = (USHORT)simple_round(scale_clamp_ushortn(src->y));
441 break;
442 }
443 case D3DDECLTYPE_USHORT4N:
444 {
445 USHORT *dst_ptr = (USHORT*)dst;
446 dst_ptr[0] = (USHORT)simple_round(scale_clamp_ushortn(src->x));
447 dst_ptr[1] = (USHORT)simple_round(scale_clamp_ushortn(src->y));
448 dst_ptr[2] = (USHORT)simple_round(scale_clamp_ushortn(src->z));
449 dst_ptr[3] = (USHORT)simple_round(scale_clamp_ushortn(src->w));
450 break;
451 }
452 case D3DDECLTYPE_FLOAT16_2:
453 {
454 D3DXFloat32To16Array((D3DXFLOAT16*)dst, (FLOAT*)src, 2);
455 break;
456 }
457 case D3DDECLTYPE_FLOAT16_4:
458 {
459 D3DXFloat32To16Array((D3DXFLOAT16*)dst, (FLOAT*)src, 4);
460 break;
461 }
462 default:
463 if (!fixme_once++)
464 FIXME("Conversion from D3DDECLTYPE_FLOAT4 to %d not implemented.\n", type_dst);
465 break;
466 }
467 }
468
469 static void convert_component(BYTE *dst, BYTE *src, D3DDECLTYPE type_dst, D3DDECLTYPE type_src)
470 {
471 BOOL fixme_once = FALSE;
472
473 switch (type_src)
474 {
475 case D3DDECLTYPE_FLOAT1:
476 {
477 FLOAT *src_ptr = (FLOAT*)src;
478 D3DXVECTOR4 src_float4 = {*src_ptr, 0.0f, 0.0f, 1.0f};
479 convert_float4(dst, &src_float4, type_dst);
480 break;
481 }
482 case D3DDECLTYPE_FLOAT2:
483 {
484 D3DXVECTOR2 *src_ptr = (D3DXVECTOR2*)src;
485 D3DXVECTOR4 src_float4 = {src_ptr->x, src_ptr->y, 0.0f, 1.0f};
486 convert_float4(dst, &src_float4, type_dst);
487 break;
488 }
489 case D3DDECLTYPE_FLOAT3:
490 {
491 D3DXVECTOR3 *src_ptr = (D3DXVECTOR3*)src;
492 D3DXVECTOR4 src_float4 = {src_ptr->x, src_ptr->y, src_ptr->z, 1.0f};
493 convert_float4(dst, &src_float4, type_dst);
494 break;
495 }
496 case D3DDECLTYPE_FLOAT4:
497 {
498 D3DXVECTOR4 *src_ptr = (D3DXVECTOR4*)src;
499 D3DXVECTOR4 src_float4 = {src_ptr->x, src_ptr->y, src_ptr->z, src_ptr->w};
500 convert_float4(dst, &src_float4, type_dst);
501 break;
502 }
503 case D3DDECLTYPE_D3DCOLOR:
504 {
505 D3DXVECTOR4 src_float4 =
506 {
507 (FLOAT)src[2]/UCHAR_MAX,
508 (FLOAT)src[1]/UCHAR_MAX,
509 (FLOAT)src[0]/UCHAR_MAX,
510 (FLOAT)src[3]/UCHAR_MAX
511 };
512 convert_float4(dst, &src_float4, type_dst);
513 break;
514 }
515 case D3DDECLTYPE_UBYTE4:
516 {
517 D3DXVECTOR4 src_float4 = {src[0], src[1], src[2], src[3]};
518 convert_float4(dst, &src_float4, type_dst);
519 break;
520 }
521 case D3DDECLTYPE_SHORT2:
522 {
523 SHORT *src_ptr = (SHORT*)src;
524 D3DXVECTOR4 src_float4 = {src_ptr[0], src_ptr[1], 0.0f, 1.0f};
525 convert_float4(dst, &src_float4, type_dst);
526 break;
527 }
528 case D3DDECLTYPE_SHORT4:
529 {
530 SHORT *src_ptr = (SHORT*)src;
531 D3DXVECTOR4 src_float4 = {src_ptr[0], src_ptr[1], src_ptr[2], src_ptr[3]};
532 convert_float4(dst, &src_float4, type_dst);
533 break;
534 }
535 case D3DDECLTYPE_UBYTE4N:
536 {
537 D3DXVECTOR4 src_float4 =
538 {
539 (FLOAT)src[0]/UCHAR_MAX,
540 (FLOAT)src[1]/UCHAR_MAX,
541 (FLOAT)src[2]/UCHAR_MAX,
542 (FLOAT)src[3]/UCHAR_MAX
543 };
544 convert_float4(dst, &src_float4, type_dst);
545 break;
546 }
547 case D3DDECLTYPE_SHORT2N:
548 {
549 SHORT *src_ptr = (SHORT*)src;
550 D3DXVECTOR4 src_float4 = {(FLOAT)src_ptr[0]/SHRT_MAX, (FLOAT)src_ptr[1]/SHRT_MAX, 0.0f, 1.0f};
551 convert_float4(dst, &src_float4, type_dst);
552 break;
553 }
554 case D3DDECLTYPE_SHORT4N:
555 {
556 SHORT *src_ptr = (SHORT*)src;
557 D3DXVECTOR4 src_float4 =
558 {
559 (FLOAT)src_ptr[0]/SHRT_MAX,
560 (FLOAT)src_ptr[1]/SHRT_MAX,
561 (FLOAT)src_ptr[2]/SHRT_MAX,
562 (FLOAT)src_ptr[3]/SHRT_MAX
563 };
564 convert_float4(dst, &src_float4, type_dst);
565 break;
566 }
567 case D3DDECLTYPE_FLOAT16_2:
568 {
569 D3DXVECTOR4 src_float4 = {0.0f, 0.0f, 0.0f, 1.0f};
570 D3DXFloat16To32Array((FLOAT*)&src_float4, (D3DXFLOAT16*)src, 2);
571 convert_float4(dst, &src_float4, type_dst);
572 break;
573 }
574 case D3DDECLTYPE_FLOAT16_4:
575 {
576 D3DXVECTOR4 src_float4;
577 D3DXFloat16To32Array((FLOAT*)&src_float4, (D3DXFLOAT16*)src, 4);
578 convert_float4(dst, &src_float4, type_dst);
579 break;
580 }
581 default:
582 if (!fixme_once++)
583 FIXME("Conversion of D3DDECLTYPE %d to %d not implemented.\n", type_src, type_dst);
584 break;
585 }
586 }
587
588 static INT get_equivalent_declaration_index(D3DVERTEXELEMENT9 orig_declaration, D3DVERTEXELEMENT9 *declaration)
589 {
590 INT i;
591
592 for (i = 0; declaration[i].Stream != 0xff; i++)
593 {
594 if (orig_declaration.Usage == declaration[i].Usage
595 && orig_declaration.UsageIndex == declaration[i].UsageIndex)
596 {
597 return i;
598 }
599 }
600
601 return -1;
602 }
603
604 static HRESULT convert_vertex_buffer(ID3DXMesh *mesh_dst, ID3DXMesh *mesh_src)
605 {
606 HRESULT hr;
607 D3DVERTEXELEMENT9 orig_declaration[MAX_FVF_DECL_SIZE] = {D3DDECL_END()};
608 D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE] = {D3DDECL_END()};
609 BYTE *vb_dst = NULL;
610 BYTE *vb_src = NULL;
611 UINT i;
612 UINT num_vertices = mesh_src->lpVtbl->GetNumVertices(mesh_src);
613 UINT dst_vertex_size = mesh_dst->lpVtbl->GetNumBytesPerVertex(mesh_dst);
614 UINT src_vertex_size = mesh_src->lpVtbl->GetNumBytesPerVertex(mesh_src);
615
616 hr = mesh_src->lpVtbl->GetDeclaration(mesh_src, orig_declaration);
617 if (FAILED(hr)) return hr;
618 hr = mesh_dst->lpVtbl->GetDeclaration(mesh_dst, declaration);
619 if (FAILED(hr)) return hr;
620
621 hr = mesh_src->lpVtbl->LockVertexBuffer(mesh_src, D3DLOCK_READONLY, (void**)&vb_src);
622 if (FAILED(hr)) goto cleanup;
623 hr = mesh_dst->lpVtbl->LockVertexBuffer(mesh_dst, 0, (void**)&vb_dst);
624 if (FAILED(hr)) goto cleanup;
625
626 /* Clear all new fields by clearing the entire vertex buffer. */
627 memset(vb_dst, 0, num_vertices * dst_vertex_size);
628
629 for (i = 0; orig_declaration[i].Stream != 0xff; i++)
630 {
631 INT eq_idx = get_equivalent_declaration_index(orig_declaration[i], declaration);
632
633 if (eq_idx >= 0)
634 {
635 UINT j;
636 for (j = 0; j < num_vertices; j++)
637 {
638 UINT idx_dst = dst_vertex_size * j + declaration[eq_idx].Offset;
639 UINT idx_src = src_vertex_size * j + orig_declaration[i].Offset;
640 UINT type_size = d3dx_decltype_size[orig_declaration[i].Type];
641
642 if (orig_declaration[i].Type == declaration[eq_idx].Type)
643 memcpy(&vb_dst[idx_dst], &vb_src[idx_src], type_size);
644 else
645 convert_component(&vb_dst[idx_dst], &vb_src[idx_src], declaration[eq_idx].Type, orig_declaration[i].Type);
646 }
647 }
648 }
649
650 hr = D3D_OK;
651 cleanup:
652 if (vb_dst) mesh_dst->lpVtbl->UnlockVertexBuffer(mesh_dst);
653 if (vb_src) mesh_src->lpVtbl->UnlockVertexBuffer(mesh_src);
654
655 return hr;
656 }
657
658 static BOOL declaration_equals(const D3DVERTEXELEMENT9 *declaration1, const D3DVERTEXELEMENT9 *declaration2)
659 {
660 UINT size1 = 0, size2 = 0;
661
662 /* Find the size of each declaration */
663 while (declaration1[size1].Stream != 0xff) size1++;
664 while (declaration2[size2].Stream != 0xff) size2++;
665
666 /* If not same size then they are definitely not equal */
667 if (size1 != size2)
668 return FALSE;
669
670 /* Check that all components are the same */
671 if (memcmp(declaration1, declaration2, size1*sizeof(*declaration1)) == 0)
672 return TRUE;
673
674 return FALSE;
675 }
676
677 static HRESULT WINAPI d3dx9_mesh_CloneMesh(struct ID3DXMesh *iface, DWORD options,
678 const D3DVERTEXELEMENT9 *declaration, struct IDirect3DDevice9 *device, struct ID3DXMesh **clone_mesh_out)
679 {
680 struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
681 struct d3dx9_mesh *cloned_this;
682 ID3DXMesh *clone_mesh;
683 D3DVERTEXELEMENT9 orig_declaration[MAX_FVF_DECL_SIZE] = { D3DDECL_END() };
684 void *data_in, *data_out;
685 DWORD vertex_size;
686 HRESULT hr;
687 BOOL same_declaration;
688
689 TRACE("iface %p, options %#x, declaration %p, device %p, clone_mesh_out %p.\n",
690 iface, options, declaration, device, clone_mesh_out);
691
692 if (!clone_mesh_out)
693 return D3DERR_INVALIDCALL;
694
695 hr = iface->lpVtbl->GetDeclaration(iface, orig_declaration);
696 if (FAILED(hr)) return hr;
697
698 hr = D3DXCreateMesh(This->numfaces, This->numvertices, options & ~D3DXMESH_VB_SHARE,
699 declaration, device, &clone_mesh);
700 if (FAILED(hr)) return hr;
701
702 cloned_this = impl_from_ID3DXMesh(clone_mesh);
703 vertex_size = clone_mesh->lpVtbl->GetNumBytesPerVertex(clone_mesh);
704 same_declaration = declaration_equals(declaration, orig_declaration);
705
706 if (options & D3DXMESH_VB_SHARE) {
707 if (!same_declaration) {
708 hr = D3DERR_INVALIDCALL;
709 goto error;
710 }
711 IDirect3DVertexBuffer9_AddRef(This->vertex_buffer);
712 /* FIXME: refactor to avoid creating a new vertex buffer */
713 IDirect3DVertexBuffer9_Release(cloned_this->vertex_buffer);
714 cloned_this->vertex_buffer = This->vertex_buffer;
715 } else if (same_declaration) {
716 hr = iface->lpVtbl->LockVertexBuffer(iface, D3DLOCK_READONLY, &data_in);
717 if (FAILED(hr)) goto error;
718 hr = clone_mesh->lpVtbl->LockVertexBuffer(clone_mesh, 0, &data_out);
719 if (FAILED(hr)) {
720 iface->lpVtbl->UnlockVertexBuffer(iface);
721 goto error;
722 }
723 memcpy(data_out, data_in, This->numvertices * vertex_size);
724 clone_mesh->lpVtbl->UnlockVertexBuffer(clone_mesh);
725 iface->lpVtbl->UnlockVertexBuffer(iface);
726 } else {
727 hr = convert_vertex_buffer(clone_mesh, iface);
728 if (FAILED(hr)) goto error;
729 }
730
731 hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, &data_in);
732 if (FAILED(hr)) goto error;
733 hr = clone_mesh->lpVtbl->LockIndexBuffer(clone_mesh, 0, &data_out);
734 if (FAILED(hr)) {
735 iface->lpVtbl->UnlockIndexBuffer(iface);
736 goto error;
737 }
738 if ((options ^ This->options) & D3DXMESH_32BIT) {
739 DWORD i;
740 if (options & D3DXMESH_32BIT) {
741 for (i = 0; i < This->numfaces * 3; i++)
742 ((DWORD*)data_out)[i] = ((WORD*)data_in)[i];
743 } else {
744 for (i = 0; i < This->numfaces * 3; i++)
745 ((WORD*)data_out)[i] = ((DWORD*)data_in)[i];
746 }
747 } else {
748 memcpy(data_out, data_in, This->numfaces * 3 * (options & D3DXMESH_32BIT ? 4 : 2));
749 }
750 clone_mesh->lpVtbl->UnlockIndexBuffer(clone_mesh);
751 iface->lpVtbl->UnlockIndexBuffer(iface);
752
753 memcpy(cloned_this->attrib_buffer, This->attrib_buffer, This->numfaces * sizeof(*This->attrib_buffer));
754
755 if (This->attrib_table_size)
756 {
757 cloned_this->attrib_table_size = This->attrib_table_size;
758 cloned_this->attrib_table = HeapAlloc(GetProcessHeap(), 0, This->attrib_table_size * sizeof(*This->attrib_table));
759 if (!cloned_this->attrib_table) {
760 hr = E_OUTOFMEMORY;
761 goto error;
762 }
763 memcpy(cloned_this->attrib_table, This->attrib_table, This->attrib_table_size * sizeof(*This->attrib_table));
764 }
765
766 *clone_mesh_out = clone_mesh;
767
768 return D3D_OK;
769 error:
770 IUnknown_Release(clone_mesh);
771 return hr;
772 }
773
774 static HRESULT WINAPI d3dx9_mesh_GetVertexBuffer(struct ID3DXMesh *iface,
775 struct IDirect3DVertexBuffer9 **vertex_buffer)
776 {
777 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
778
779 TRACE("iface %p, vertex_buffer %p.\n", iface, vertex_buffer);
780
781 if (!vertex_buffer)
782 return D3DERR_INVALIDCALL;
783 *vertex_buffer = mesh->vertex_buffer;
784 IDirect3DVertexBuffer9_AddRef(mesh->vertex_buffer);
785
786 return D3D_OK;
787 }
788
789 static HRESULT WINAPI d3dx9_mesh_GetIndexBuffer(struct ID3DXMesh *iface,
790 struct IDirect3DIndexBuffer9 **index_buffer)
791 {
792 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
793
794 TRACE("iface %p, index_buffer %p.\n", iface, index_buffer);
795
796 if (!index_buffer)
797 return D3DERR_INVALIDCALL;
798 *index_buffer = mesh->index_buffer;
799 IDirect3DIndexBuffer9_AddRef(mesh->index_buffer);
800
801 return D3D_OK;
802 }
803
804 static HRESULT WINAPI d3dx9_mesh_LockVertexBuffer(ID3DXMesh *iface, DWORD flags, void **data)
805 {
806 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
807
808 TRACE("iface %p, flags %#x, data %p.\n", iface, flags, data);
809
810 return IDirect3DVertexBuffer9_Lock(mesh->vertex_buffer, 0, 0, data, flags);
811 }
812
813 static HRESULT WINAPI d3dx9_mesh_UnlockVertexBuffer(ID3DXMesh *iface)
814 {
815 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
816
817 TRACE("iface %p.\n", iface);
818
819 return IDirect3DVertexBuffer9_Unlock(mesh->vertex_buffer);
820 }
821
822 static HRESULT WINAPI d3dx9_mesh_LockIndexBuffer(ID3DXMesh *iface, DWORD flags, void **data)
823 {
824 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
825
826 TRACE("iface %p, flags %#x, data %p.\n", iface, flags, data);
827
828 return IDirect3DIndexBuffer9_Lock(mesh->index_buffer, 0, 0, data, flags);
829 }
830
831 static HRESULT WINAPI d3dx9_mesh_UnlockIndexBuffer(ID3DXMesh *iface)
832 {
833 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
834
835 TRACE("iface %p.\n", iface);
836
837 return IDirect3DIndexBuffer9_Unlock(mesh->index_buffer);
838 }
839
840 /* FIXME: This looks just wrong, we never check *attrib_table_size before
841 * copying the data. */
842 static HRESULT WINAPI d3dx9_mesh_GetAttributeTable(ID3DXMesh *iface,
843 D3DXATTRIBUTERANGE *attrib_table, DWORD *attrib_table_size)
844 {
845 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
846
847 TRACE("iface %p, attrib_table %p, attrib_table_size %p.\n",
848 iface, attrib_table, attrib_table_size);
849
850 if (attrib_table_size)
851 *attrib_table_size = mesh->attrib_table_size;
852
853 if (attrib_table)
854 memcpy(attrib_table, mesh->attrib_table, mesh->attrib_table_size * sizeof(*attrib_table));
855
856 return D3D_OK;
857 }
858
859 struct edge_face
860 {
861 struct list entry;
862 DWORD v2;
863 DWORD face;
864 };
865
866 struct edge_face_map
867 {
868 struct list *lists;
869 struct edge_face *entries;
870 };
871
872 /* Builds up a map of which face a new edge belongs to. That way the adjacency
873 * of another edge can be looked up. An edge has an adjacent face if there
874 * is an edge going in the opposite direction in the map. For example if the
875 * edge (v1, v2) belongs to face 4, and there is a mapping (v2, v1)->7, then
876 * face 4 and 7 are adjacent.
877 *
878 * Each edge might have been replaced with another edge, or none at all. There
879 * is at most one edge to face mapping, i.e. an edge can only belong to one
880 * face.
881 */
882 static HRESULT init_edge_face_map(struct edge_face_map *edge_face_map, const DWORD *index_buffer,
883 const DWORD *point_reps, DWORD num_faces)
884 {
885 DWORD face, edge;
886 DWORD i;
887
888 edge_face_map->lists = HeapAlloc(GetProcessHeap(), 0, 3 * num_faces * sizeof(*edge_face_map->lists));
889 if (!edge_face_map->lists) return E_OUTOFMEMORY;
890
891 edge_face_map->entries = HeapAlloc(GetProcessHeap(), 0, 3 * num_faces * sizeof(*edge_face_map->entries));
892 if (!edge_face_map->entries) return E_OUTOFMEMORY;
893
894
895 /* Initialize all lists */
896 for (i = 0; i < 3 * num_faces; i++)
897 {
898 list_init(&edge_face_map->lists[i]);
899 }
900 /* Build edge face mapping */
901 for (face = 0; face < num_faces; face++)
902 {
903 for (edge = 0; edge < 3; edge++)
904 {
905 DWORD v1 = index_buffer[3*face + edge];
906 DWORD v2 = index_buffer[3*face + (edge+1)%3];
907 DWORD new_v1 = point_reps[v1]; /* What v1 has been replaced with */
908 DWORD new_v2 = point_reps[v2];
909
910 if (v1 != v2) /* Only map non-collapsed edges */
911 {
912 i = 3*face + edge;
913 edge_face_map->entries[i].v2 = new_v2;
914 edge_face_map->entries[i].face = face;
915 list_add_head(&edge_face_map->lists[new_v1], &edge_face_map->entries[i].entry);
916 }
917 }
918 }
919
920 return D3D_OK;
921 }
922
923 static DWORD find_adjacent_face(struct edge_face_map *edge_face_map, DWORD vertex1, DWORD vertex2, DWORD num_faces)
924 {
925 struct edge_face *edge_face_ptr;
926
927 LIST_FOR_EACH_ENTRY(edge_face_ptr, &edge_face_map->lists[vertex2], struct edge_face, entry)
928 {
929 if (edge_face_ptr->v2 == vertex1)
930 return edge_face_ptr->face;
931 }
932
933 return -1;
934 }
935
936 static DWORD *generate_identity_point_reps(DWORD num_vertices)
937 {
938 DWORD *id_point_reps;
939 DWORD i;
940
941 id_point_reps = HeapAlloc(GetProcessHeap(), 0, num_vertices * sizeof(*id_point_reps));
942 if (!id_point_reps)
943 return NULL;
944
945 for (i = 0; i < num_vertices; i++)
946 {
947 id_point_reps[i] = i;
948 }
949
950 return id_point_reps;
951 }
952
953 static HRESULT WINAPI d3dx9_mesh_ConvertPointRepsToAdjacency(ID3DXMesh *iface,
954 const DWORD *point_reps, DWORD *adjacency)
955 {
956 HRESULT hr;
957 DWORD num_faces = iface->lpVtbl->GetNumFaces(iface);
958 DWORD num_vertices = iface->lpVtbl->GetNumVertices(iface);
959 DWORD options = iface->lpVtbl->GetOptions(iface);
960 BOOL indices_are_16_bit = !(options & D3DXMESH_32BIT);
961 DWORD *ib = NULL;
962 void *ib_ptr = NULL;
963 DWORD face;
964 DWORD edge;
965 struct edge_face_map edge_face_map = {0};
966 const DWORD *point_reps_ptr = NULL;
967 DWORD *id_point_reps = NULL;
968
969 TRACE("iface %p, point_reps %p, adjacency %p.\n", iface, point_reps, adjacency);
970
971 if (!adjacency) return D3DERR_INVALIDCALL;
972
973 if (!point_reps) /* Identity point reps */
974 {
975 id_point_reps = generate_identity_point_reps(num_vertices);
976 if (!id_point_reps)
977 {
978 hr = E_OUTOFMEMORY;
979 goto cleanup;
980 }
981
982 point_reps_ptr = id_point_reps;
983 }
984 else
985 {
986 point_reps_ptr = point_reps;
987 }
988
989 hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, &ib_ptr);
990 if (FAILED(hr)) goto cleanup;
991
992 if (indices_are_16_bit)
993 {
994 /* Widen 16 bit to 32 bit */
995 DWORD i;
996 WORD *ib_16bit = ib_ptr;
997 ib = HeapAlloc(GetProcessHeap(), 0, 3 * num_faces * sizeof(DWORD));
998 if (!ib)
999 {
1000 hr = E_OUTOFMEMORY;
1001 goto cleanup;
1002 }
1003 for (i = 0; i < 3 * num_faces; i++)
1004 {
1005 ib[i] = ib_16bit[i];
1006 }
1007 }
1008 else
1009 {
1010 ib = ib_ptr;
1011 }
1012
1013 hr = init_edge_face_map(&edge_face_map, ib, point_reps_ptr, num_faces);
1014 if (FAILED(hr)) goto cleanup;
1015
1016 /* Create adjacency */
1017 for (face = 0; face < num_faces; face++)
1018 {
1019 for (edge = 0; edge < 3; edge++)
1020 {
1021 DWORD v1 = ib[3*face + edge];
1022 DWORD v2 = ib[3*face + (edge+1)%3];
1023 DWORD new_v1 = point_reps_ptr[v1];
1024 DWORD new_v2 = point_reps_ptr[v2];
1025 DWORD adj_face;
1026
1027 adj_face = find_adjacent_face(&edge_face_map, new_v1, new_v2, num_faces);
1028 adjacency[3*face + edge] = adj_face;
1029 }
1030 }
1031
1032 hr = D3D_OK;
1033 cleanup:
1034 HeapFree(GetProcessHeap(), 0, id_point_reps);
1035 if (indices_are_16_bit) HeapFree(GetProcessHeap(), 0, ib);
1036 HeapFree(GetProcessHeap(), 0, edge_face_map.lists);
1037 HeapFree(GetProcessHeap(), 0, edge_face_map.entries);
1038 if(ib_ptr) iface->lpVtbl->UnlockIndexBuffer(iface);
1039 return hr;
1040 }
1041
1042 /* ConvertAdjacencyToPointReps helper function.
1043 *
1044 * Goes around the edges of each face and replaces the vertices in any adjacent
1045 * face's edge with its own vertices(if its vertices have a lower index). This
1046 * way as few as possible low index vertices are shared among the faces. The
1047 * re-ordered index buffer is stored in new_indices.
1048 *
1049 * The vertices in a point representation must be ordered sequentially, e.g.
1050 * index 5 holds the index of the vertex that replaces vertex 5, i.e. if
1051 * vertex 5 is replaced by vertex 3 then index 5 would contain 3. If no vertex
1052 * replaces it, then it contains the same number as the index itself, e.g.
1053 * index 5 would contain 5. */
1054 static HRESULT propagate_face_vertices(const DWORD *adjacency, DWORD *point_reps,
1055 const DWORD *indices, DWORD *new_indices, DWORD face, DWORD numfaces)
1056 {
1057 const unsigned int VERTS_PER_FACE = 3;
1058 DWORD edge, opp_edge;
1059 DWORD face_base = VERTS_PER_FACE * face;
1060
1061 for (edge = 0; edge < VERTS_PER_FACE; edge++)
1062 {
1063 DWORD adj_face = adjacency[face_base + edge];
1064 DWORD adj_face_base;
1065 DWORD i;
1066 if (adj_face == -1) /* No adjacent face. */
1067 continue;
1068 else if (adj_face >= numfaces)
1069 {
1070 /* This throws exception on Windows */
1071 WARN("Index out of bounds. Got %d expected less than %d.\n",
1072 adj_face, numfaces);
1073 return D3DERR_INVALIDCALL;
1074 }
1075 adj_face_base = 3 * adj_face;
1076
1077 /* Find opposite edge in adjacent face. */
1078 for (opp_edge = 0; opp_edge < VERTS_PER_FACE; opp_edge++)
1079 {
1080 DWORD opp_edge_index = adj_face_base + opp_edge;
1081 if (adjacency[opp_edge_index] == face)
1082 break; /* Found opposite edge. */
1083 }
1084
1085 /* Replaces vertices in opposite edge with vertices from current edge. */
1086 for (i = 0; i < 2; i++)
1087 {
1088 DWORD from = face_base + (edge + (1 - i)) % VERTS_PER_FACE;
1089 DWORD to = adj_face_base + (opp_edge + i) % VERTS_PER_FACE;
1090
1091 /* Propagate lowest index. */
1092 if (new_indices[to] > new_indices[from])
1093 {
1094 new_indices[to] = new_indices[from];
1095 point_reps[indices[to]] = new_indices[from];
1096 }
1097 }
1098 }
1099
1100 return D3D_OK;
1101 }
1102
1103 static HRESULT WINAPI d3dx9_mesh_ConvertAdjacencyToPointReps(ID3DXMesh *iface,
1104 const DWORD *adjacency, DWORD *point_reps)
1105 {
1106 struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
1107 HRESULT hr;
1108 DWORD face;
1109 DWORD i;
1110 DWORD *indices = NULL;
1111 WORD *indices_16bit = NULL;
1112 DWORD *new_indices = NULL;
1113 const unsigned int VERTS_PER_FACE = 3;
1114
1115 TRACE("iface %p, adjacency %p, point_reps %p.\n", iface, adjacency, point_reps);
1116
1117 if (!adjacency)
1118 {
1119 WARN("NULL adjacency.\n");
1120 hr = D3DERR_INVALIDCALL;
1121 goto cleanup;
1122 }
1123
1124 if (!point_reps)
1125 {
1126 WARN("NULL point_reps.\n");
1127 hr = D3DERR_INVALIDCALL;
1128 goto cleanup;
1129 }
1130
1131 /* Should never happen as CreateMesh does not allow meshes with 0 faces */
1132 if (This->numfaces == 0)
1133 {
1134 ERR("Number of faces was zero.\n");
1135 hr = D3DERR_INVALIDCALL;
1136 goto cleanup;
1137 }
1138
1139 new_indices = HeapAlloc(GetProcessHeap(), 0, VERTS_PER_FACE * This->numfaces * sizeof(*indices));
1140 if (!new_indices)
1141 {
1142 hr = E_OUTOFMEMORY;
1143 goto cleanup;
1144 }
1145
1146 if (This->options & D3DXMESH_32BIT)
1147 {
1148 hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, (void**)&indices);
1149 if (FAILED(hr)) goto cleanup;
1150 memcpy(new_indices, indices, VERTS_PER_FACE * This->numfaces * sizeof(*indices));
1151 }
1152 else
1153 {
1154 /* Make a widening copy of indices_16bit into indices and new_indices
1155 * in order to re-use the helper function */
1156 hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, (void**)&indices_16bit);
1157 if (FAILED(hr)) goto cleanup;
1158 indices = HeapAlloc(GetProcessHeap(), 0, VERTS_PER_FACE * This->numfaces * sizeof(*indices));
1159 if (!indices)
1160 {
1161 hr = E_OUTOFMEMORY;
1162 goto cleanup;
1163 }
1164 for (i = 0; i < VERTS_PER_FACE * This->numfaces; i++)
1165 {
1166 new_indices[i] = indices_16bit[i];
1167 indices[i] = indices_16bit[i];
1168 }
1169 }
1170
1171 /* Vertices are ordered sequentially in the point representation. */
1172 for (i = 0; i < This->numvertices; i++)
1173 {
1174 point_reps[i] = i;
1175 }
1176
1177 /* Propagate vertices with low indices so as few vertices as possible
1178 * are used in the mesh.
1179 */
1180 for (face = 0; face < This->numfaces; face++)
1181 {
1182 hr = propagate_face_vertices(adjacency, point_reps, indices, new_indices, face, This->numfaces);
1183 if (FAILED(hr)) goto cleanup;
1184 }
1185 /* Go in opposite direction to catch all face orderings */
1186 for (face = 0; face < This->numfaces; face++)
1187 {
1188 hr = propagate_face_vertices(adjacency, point_reps,
1189 indices, new_indices,
1190 (This->numfaces - 1) - face, This->numfaces);
1191 if (FAILED(hr)) goto cleanup;
1192 }
1193
1194 hr = D3D_OK;
1195 cleanup:
1196 if (This->options & D3DXMESH_32BIT)
1197 {
1198 if (indices) iface->lpVtbl->UnlockIndexBuffer(iface);
1199 }
1200 else
1201 {
1202 if (indices_16bit) iface->lpVtbl->UnlockIndexBuffer(iface);
1203 HeapFree(GetProcessHeap(), 0, indices);
1204 }
1205 HeapFree(GetProcessHeap(), 0, new_indices);
1206 return hr;
1207 }
1208
1209 struct vertex_metadata {
1210 float key;
1211 DWORD vertex_index;
1212 DWORD first_shared_index;
1213 };
1214
1215 static int compare_vertex_keys(const void *a, const void *b)
1216 {
1217 const struct vertex_metadata *left = a;
1218 const struct vertex_metadata *right = b;
1219 if (left->key == right->key)
1220 return 0;
1221 return left->key < right->key ? -1 : 1;
1222 }
1223
1224 static HRESULT WINAPI d3dx9_mesh_GenerateAdjacency(ID3DXMesh *iface, float epsilon, DWORD *adjacency)
1225 {
1226 struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
1227 HRESULT hr;
1228 BYTE *vertices = NULL;
1229 const DWORD *indices = NULL;
1230 DWORD vertex_size;
1231 DWORD buffer_size;
1232 /* sort the vertices by (x + y + z) to quickly find coincident vertices */
1233 struct vertex_metadata *sorted_vertices;
1234 /* shared_indices links together identical indices in the index buffer so
1235 * that adjacency checks can be limited to faces sharing a vertex */
1236 DWORD *shared_indices = NULL;
1237 const FLOAT epsilon_sq = epsilon * epsilon;
1238 DWORD i;
1239
1240 TRACE("iface %p, epsilon %.8e, adjacency %p.\n", iface, epsilon, adjacency);
1241
1242 if (!adjacency)
1243 return D3DERR_INVALIDCALL;
1244
1245 buffer_size = This->numfaces * 3 * sizeof(*shared_indices) + This->numvertices * sizeof(*sorted_vertices);
1246 if (!(This->options & D3DXMESH_32BIT))
1247 buffer_size += This->numfaces * 3 * sizeof(*indices);
1248 shared_indices = HeapAlloc(GetProcessHeap(), 0, buffer_size);
1249 if (!shared_indices)
1250 return E_OUTOFMEMORY;
1251 sorted_vertices = (struct vertex_metadata*)(shared_indices + This->numfaces * 3);
1252
1253 hr = iface->lpVtbl->LockVertexBuffer(iface, D3DLOCK_READONLY, (void**)&vertices);
1254 if (FAILED(hr)) goto cleanup;
1255 hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, (void**)&indices);
1256 if (FAILED(hr)) goto cleanup;
1257
1258 if (!(This->options & D3DXMESH_32BIT)) {
1259 const WORD *word_indices = (const WORD*)indices;
1260 DWORD *dword_indices = (DWORD*)(sorted_vertices + This->numvertices);
1261 indices = dword_indices;
1262 for (i = 0; i < This->numfaces * 3; i++)
1263 *dword_indices++ = *word_indices++;
1264 }
1265
1266 vertex_size = iface->lpVtbl->GetNumBytesPerVertex(iface);
1267 for (i = 0; i < This->numvertices; i++) {
1268 D3DXVECTOR3 *vertex = (D3DXVECTOR3*)(vertices + vertex_size * i);
1269 sorted_vertices[i].first_shared_index = -1;
1270 sorted_vertices[i].key = vertex->x + vertex->y + vertex->z;
1271 sorted_vertices[i].vertex_index = i;
1272 }
1273 for (i = 0; i < This->numfaces * 3; i++) {
1274 DWORD *first_shared_index = &sorted_vertices[indices[i]].first_shared_index;
1275 shared_indices[i] = *first_shared_index;
1276 *first_shared_index = i;
1277 adjacency[i] = -1;
1278 }
1279 qsort(sorted_vertices, This->numvertices, sizeof(*sorted_vertices), compare_vertex_keys);
1280
1281 for (i = 0; i < This->numvertices; i++) {
1282 struct vertex_metadata *sorted_vertex_a = &sorted_vertices[i];
1283 D3DXVECTOR3 *vertex_a = (D3DXVECTOR3*)(vertices + sorted_vertex_a->vertex_index * vertex_size);
1284 DWORD shared_index_a = sorted_vertex_a->first_shared_index;
1285
1286 while (shared_index_a != -1) {
1287 DWORD j = i;
1288 DWORD shared_index_b = shared_indices[shared_index_a];
1289 struct vertex_metadata *sorted_vertex_b = sorted_vertex_a;
1290
1291 while (TRUE) {
1292 while (shared_index_b != -1) {
1293 /* faces are adjacent if they have another coincident vertex */
1294 DWORD base_a = (shared_index_a / 3) * 3;
1295 DWORD base_b = (shared_index_b / 3) * 3;
1296 BOOL adjacent = FALSE;
1297 int k;
1298
1299 for (k = 0; k < 3; k++) {
1300 if (adjacency[base_b + k] == shared_index_a / 3) {
1301 adjacent = TRUE;
1302 break;
1303 }
1304 }
1305 if (!adjacent) {
1306 for (k = 1; k <= 2; k++) {
1307 DWORD vertex_index_a = base_a + (shared_index_a + k) % 3;
1308 DWORD vertex_index_b = base_b + (shared_index_b + (3 - k)) % 3;
1309 adjacent = indices[vertex_index_a] == indices[vertex_index_b];
1310 if (!adjacent && epsilon >= 0.0f) {
1311 D3DXVECTOR3 delta = {0.0f, 0.0f, 0.0f};
1312 FLOAT length_sq;
1313
1314 D3DXVec3Subtract(&delta,
1315 (D3DXVECTOR3*)(vertices + indices[vertex_index_a] * vertex_size),
1316 (D3DXVECTOR3*)(vertices + indices[vertex_index_b] * vertex_size));
1317 length_sq = D3DXVec3LengthSq(&delta);
1318 adjacent = epsilon == 0.0f ? length_sq == 0.0f : length_sq < epsilon_sq;
1319 }
1320 if (adjacent) {
1321 DWORD adj_a = base_a + 2 - (vertex_index_a + shared_index_a + 1) % 3;
1322 DWORD adj_b = base_b + 2 - (vertex_index_b + shared_index_b + 1) % 3;
1323 if (adjacency[adj_a] == -1 && adjacency[adj_b] == -1) {
1324 adjacency[adj_a] = base_b / 3;
1325 adjacency[adj_b] = base_a / 3;
1326 break;
1327 }
1328 }
1329 }
1330 }
1331
1332 shared_index_b = shared_indices[shared_index_b];
1333 }
1334 while (++j < This->numvertices) {
1335 D3DXVECTOR3 *vertex_b;
1336
1337 sorted_vertex_b++;
1338 if (sorted_vertex_b->key - sorted_vertex_a->key > epsilon * 3.0f) {
1339 /* no more coincident vertices to try */
1340 j = This->numvertices;
1341 break;
1342 }
1343 /* check for coincidence */
1344 vertex_b = (D3DXVECTOR3*)(vertices + sorted_vertex_b->vertex_index * vertex_size);
1345 if (fabsf(vertex_a->x - vertex_b->x) <= epsilon &&
1346 fabsf(vertex_a->y - vertex_b->y) <= epsilon &&
1347 fabsf(vertex_a->z - vertex_b->z) <= epsilon)
1348 {
1349 break;
1350 }
1351 }
1352 if (j >= This->numvertices)
1353 break;
1354 shared_index_b = sorted_vertex_b->first_shared_index;
1355 }
1356
1357 sorted_vertex_a->first_shared_index = shared_indices[sorted_vertex_a->first_shared_index];
1358 shared_index_a = sorted_vertex_a->first_shared_index;
1359 }
1360 }
1361
1362 hr = D3D_OK;
1363 cleanup:
1364 if (indices) iface->lpVtbl->UnlockIndexBuffer(iface);
1365 if (vertices) iface->lpVtbl->UnlockVertexBuffer(iface);
1366 HeapFree(GetProcessHeap(), 0, shared_indices);
1367 return hr;
1368 }
1369
1370 static HRESULT WINAPI d3dx9_mesh_UpdateSemantics(ID3DXMesh *iface, D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE])
1371 {
1372 struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
1373 HRESULT hr;
1374 UINT vertex_declaration_size;
1375 int i;
1376
1377 TRACE("iface %p, declaration %p.\n", iface, declaration);
1378
1379 if (!declaration)
1380 {
1381 WARN("Invalid declaration. Can't use NULL declaration.\n");
1382 return D3DERR_INVALIDCALL;
1383 }
1384
1385 /* New declaration must be same size as original */
1386 vertex_declaration_size = D3DXGetDeclVertexSize(declaration, declaration[0].Stream);
1387 if (vertex_declaration_size != This->vertex_declaration_size)
1388 {
1389 WARN("Invalid declaration. New vertex size does not match the original vertex size.\n");
1390 return D3DERR_INVALIDCALL;
1391 }
1392
1393 /* New declaration must not contain non-zero Stream value */
1394 for (i = 0; declaration[i].Stream != 0xff; i++)
1395 {
1396 if (declaration[i].Stream != 0)
1397 {
1398 WARN("Invalid declaration. New declaration contains non-zero Stream value.\n");
1399 return D3DERR_INVALIDCALL;
1400 }
1401 }
1402
1403 This->num_elem = i + 1;
1404 copy_declaration(This->cached_declaration, declaration, This->num_elem);
1405
1406 if (This->vertex_declaration)
1407 IDirect3DVertexDeclaration9_Release(This->vertex_declaration);
1408
1409 /* An application can pass an invalid declaration to UpdateSemantics and
1410 * still expect D3D_OK (see tests). If the declaration is invalid, then
1411 * subsequent calls to DrawSubset will fail. This is handled by setting the
1412 * vertex declaration to NULL.
1413 * GetDeclaration, GetNumBytesPerVertex must, however, use the new
1414 * invalid declaration. This is handled by them using the cached vertex
1415 * declaration instead of the actual vertex declaration.
1416 */
1417 hr = IDirect3DDevice9_CreateVertexDeclaration(This->device,
1418 declaration,
1419 &This->vertex_declaration);
1420 if (FAILED(hr))
1421 {
1422 WARN("Using invalid declaration. Calls to DrawSubset will fail.\n");
1423 This->vertex_declaration = NULL;
1424 }
1425
1426 return D3D_OK;
1427 }
1428
1429 static HRESULT WINAPI d3dx9_mesh_LockAttributeBuffer(ID3DXMesh *iface, DWORD flags, DWORD **data)
1430 {
1431 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
1432
1433 TRACE("iface %p, flags %#x, data %p.\n", iface, flags, data);
1434
1435 InterlockedIncrement(&mesh->attrib_buffer_lock_count);
1436
1437 if (!(flags & D3DLOCK_READONLY))
1438 {
1439 D3DXATTRIBUTERANGE *attrib_table = mesh->attrib_table;
1440 mesh->attrib_table_size = 0;
1441 mesh->attrib_table = NULL;
1442 HeapFree(GetProcessHeap(), 0, attrib_table);
1443 }
1444
1445 *data = mesh->attrib_buffer;
1446
1447 return D3D_OK;
1448 }
1449
1450 static HRESULT WINAPI d3dx9_mesh_UnlockAttributeBuffer(ID3DXMesh *iface)
1451 {
1452 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
1453 int lock_count;
1454
1455 TRACE("iface %p.\n", iface);
1456
1457 lock_count = InterlockedDecrement(&mesh->attrib_buffer_lock_count);
1458 if (lock_count < 0)
1459 {
1460 InterlockedIncrement(&mesh->attrib_buffer_lock_count);
1461 return D3DERR_INVALIDCALL;
1462 }
1463
1464 return D3D_OK;
1465 }
1466
1467 static HRESULT WINAPI d3dx9_mesh_Optimize(ID3DXMesh *iface, DWORD flags, const DWORD *adjacency_in,
1468 DWORD *adjacency_out, DWORD *face_remap, ID3DXBuffer **vertex_remap, ID3DXMesh **opt_mesh)
1469 {
1470 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
1471 HRESULT hr;
1472 D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE] = { D3DDECL_END() };
1473 ID3DXMesh *optimized_mesh;
1474
1475 TRACE("iface %p, flags %#x, adjacency_in %p, adjacency_out %p, face_remap %p, vertex_remap %p, opt_mesh %p.\n",
1476 iface, flags, adjacency_in, adjacency_out, face_remap, vertex_remap, opt_mesh);
1477
1478 if (!opt_mesh)
1479 return D3DERR_INVALIDCALL;
1480
1481 hr = iface->lpVtbl->GetDeclaration(iface, declaration);
1482 if (FAILED(hr)) return hr;
1483
1484 if (FAILED(hr = iface->lpVtbl->CloneMesh(iface, mesh->options, declaration, mesh->device, &optimized_mesh)))
1485 return hr;
1486
1487 hr = optimized_mesh->lpVtbl->OptimizeInplace(optimized_mesh, flags, adjacency_in, adjacency_out, face_remap, vertex_remap);
1488 if (SUCCEEDED(hr))
1489 *opt_mesh = optimized_mesh;
1490 else
1491 IUnknown_Release(optimized_mesh);
1492 return hr;
1493 }
1494
1495 /* Creates a vertex_remap that removes unused vertices.
1496 * Indices are updated according to the vertex_remap. */
1497 static HRESULT compact_mesh(struct d3dx9_mesh *This, DWORD *indices,
1498 DWORD *new_num_vertices, ID3DXBuffer **vertex_remap)
1499 {
1500 HRESULT hr;
1501 DWORD *vertex_remap_ptr;
1502 DWORD num_used_vertices;
1503 DWORD i;
1504
1505 hr = D3DXCreateBuffer(This->numvertices * sizeof(DWORD), vertex_remap);
1506 if (FAILED(hr)) return hr;
1507 vertex_remap_ptr = ID3DXBuffer_GetBufferPointer(*vertex_remap);
1508
1509 for (i = 0; i < This->numfaces * 3; i++)
1510 vertex_remap_ptr[indices[i]] = 1;
1511
1512 /* create old->new vertex mapping */
1513 num_used_vertices = 0;
1514 for (i = 0; i < This->numvertices; i++) {
1515 if (vertex_remap_ptr[i])
1516 vertex_remap_ptr[i] = num_used_vertices++;
1517 else
1518 vertex_remap_ptr[i] = -1;
1519 }
1520 /* convert indices */
1521 for (i = 0; i < This->numfaces * 3; i++)
1522 indices[i] = vertex_remap_ptr[indices[i]];
1523
1524 /* create new->old vertex mapping */
1525 num_used_vertices = 0;
1526 for (i = 0; i < This->numvertices; i++) {
1527 if (vertex_remap_ptr[i] != -1)
1528 vertex_remap_ptr[num_used_vertices++] = i;
1529 }
1530 for (i = num_used_vertices; i < This->numvertices; i++)
1531 vertex_remap_ptr[i] = -1;
1532
1533 *new_num_vertices = num_used_vertices;
1534
1535 return D3D_OK;
1536 }
1537
1538 /* count the number of unique attribute values in a sorted attribute buffer */
1539 static DWORD count_attributes(const DWORD *attrib_buffer, DWORD numfaces)
1540 {
1541 DWORD last_attribute = attrib_buffer[0];
1542 DWORD attrib_table_size = 1;
1543 DWORD i;
1544 for (i = 1; i < numfaces; i++) {
1545 if (attrib_buffer[i] != last_attribute) {
1546 last_attribute = attrib_buffer[i];
1547 attrib_table_size++;
1548 }
1549 }
1550 return attrib_table_size;
1551 }
1552
1553 static void fill_attribute_table(DWORD *attrib_buffer, DWORD numfaces, void *indices,
1554 BOOL is_32bit_indices, D3DXATTRIBUTERANGE *attrib_table)
1555 {
1556 DWORD attrib_table_size = 0;
1557 DWORD last_attribute = attrib_buffer[0];
1558 DWORD min_vertex, max_vertex;
1559 DWORD i;
1560
1561 attrib_table[0].AttribId = last_attribute;
1562 attrib_table[0].FaceStart = 0;
1563 min_vertex = (DWORD)-1;
1564 max_vertex = 0;
1565 for (i = 0; i < numfaces; i++) {
1566 DWORD j;
1567
1568 if (attrib_buffer[i] != last_attribute) {
1569 last_attribute = attrib_buffer[i];
1570 attrib_table[attrib_table_size].FaceCount = i - attrib_table[attrib_table_size].FaceStart;
1571 attrib_table[attrib_table_size].VertexStart = min_vertex;
1572 attrib_table[attrib_table_size].VertexCount = max_vertex - min_vertex + 1;
1573 attrib_table_size++;
1574 attrib_table[attrib_table_size].AttribId = attrib_buffer[i];
1575 attrib_table[attrib_table_size].FaceStart = i;
1576 min_vertex = (DWORD)-1;
1577 max_vertex = 0;
1578 }
1579 for (j = 0; j < 3; j++) {
1580 DWORD vertex_index = is_32bit_indices ? ((DWORD*)indices)[i * 3 + j] : ((WORD*)indices)[i * 3 + j];
1581 if (vertex_index < min_vertex)
1582 min_vertex = vertex_index;
1583 if (vertex_index > max_vertex)
1584 max_vertex = vertex_index;
1585 }
1586 }
1587 attrib_table[attrib_table_size].FaceCount = i - attrib_table[attrib_table_size].FaceStart;
1588 attrib_table[attrib_table_size].VertexStart = min_vertex;
1589 attrib_table[attrib_table_size].VertexCount = max_vertex - min_vertex + 1;
1590 attrib_table_size++;
1591 }
1592
1593 static int attrib_entry_compare(const DWORD **a, const DWORD **b)
1594 {
1595 const DWORD *ptr_a = *a;
1596 const DWORD *ptr_b = *b;
1597 int delta = *ptr_a - *ptr_b;
1598
1599 if (delta)
1600 return delta;
1601
1602 delta = ptr_a - ptr_b; /* for stable sort */
1603 return delta;
1604 }
1605
1606 /* Create face_remap, a new attribute buffer for attribute sort optimization. */
1607 static HRESULT remap_faces_for_attrsort(struct d3dx9_mesh *This, const DWORD *indices,
1608 DWORD *attrib_buffer, DWORD **sorted_attrib_buffer, DWORD **face_remap)
1609 {
1610 DWORD **sorted_attrib_ptr_buffer = NULL;
1611 DWORD i;
1612
1613 sorted_attrib_ptr_buffer = HeapAlloc(GetProcessHeap(), 0, This->numfaces * sizeof(*sorted_attrib_ptr_buffer));
1614 if (!sorted_attrib_ptr_buffer)
1615 return E_OUTOFMEMORY;
1616
1617 *face_remap = HeapAlloc(GetProcessHeap(), 0, This->numfaces * sizeof(**face_remap));
1618 if (!*face_remap)
1619 {
1620 HeapFree(GetProcessHeap(), 0, sorted_attrib_ptr_buffer);
1621 return E_OUTOFMEMORY;
1622 }
1623
1624 for (i = 0; i < This->numfaces; i++)
1625 sorted_attrib_ptr_buffer[i] = &attrib_buffer[i];
1626 qsort(sorted_attrib_ptr_buffer, This->numfaces, sizeof(*sorted_attrib_ptr_buffer),
1627 (int(*)(const void *, const void *))attrib_entry_compare);
1628
1629 for (i = 0; i < This->numfaces; i++)
1630 {
1631 DWORD old_face = sorted_attrib_ptr_buffer[i] - attrib_buffer;
1632 (*face_remap)[old_face] = i;
1633 }
1634
1635 /* overwrite sorted_attrib_ptr_buffer with the values themselves */
1636 *sorted_attrib_buffer = (DWORD*)sorted_attrib_ptr_buffer;
1637 for (i = 0; i < This->numfaces; i++)
1638 (*sorted_attrib_buffer)[(*face_remap)[i]] = attrib_buffer[i];
1639
1640 return D3D_OK;
1641 }
1642
1643 static HRESULT WINAPI d3dx9_mesh_OptimizeInplace(ID3DXMesh *iface, DWORD flags, const DWORD *adjacency_in,
1644 DWORD *adjacency_out, DWORD *face_remap_out, ID3DXBuffer **vertex_remap_out)
1645 {
1646 struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
1647 void *indices = NULL;
1648 DWORD *attrib_buffer = NULL;
1649 HRESULT hr;
1650 ID3DXBuffer *vertex_remap = NULL;
1651 DWORD *face_remap = NULL; /* old -> new mapping */
1652 DWORD *dword_indices = NULL;
1653 DWORD new_num_vertices = 0;
1654 DWORD new_num_alloc_vertices = 0;
1655 IDirect3DVertexBuffer9 *vertex_buffer = NULL;
1656 DWORD *sorted_attrib_buffer = NULL;
1657 DWORD i;
1658
1659 TRACE("iface %p, flags %#x, adjacency_in %p, adjacency_out %p, face_remap_out %p, vertex_remap_out %p.\n",
1660 iface, flags, adjacency_in, adjacency_out, face_remap_out, vertex_remap_out);
1661
1662 if (!flags)
1663 return D3DERR_INVALIDCALL;
1664 if (!adjacency_in && (flags & (D3DXMESHOPT_VERTEXCACHE | D3DXMESHOPT_STRIPREORDER)))
1665 return D3DERR_INVALIDCALL;
1666 if ((flags & (D3DXMESHOPT_VERTEXCACHE | D3DXMESHOPT_STRIPREORDER)) == (D3DXMESHOPT_VERTEXCACHE | D3DXMESHOPT_STRIPREORDER))
1667 return D3DERR_INVALIDCALL;
1668
1669 if (flags & (D3DXMESHOPT_VERTEXCACHE | D3DXMESHOPT_STRIPREORDER))
1670 {
1671 if (flags & D3DXMESHOPT_VERTEXCACHE)
1672 FIXME("D3DXMESHOPT_VERTEXCACHE not implemented.\n");
1673 if (flags & D3DXMESHOPT_STRIPREORDER)
1674 FIXME("D3DXMESHOPT_STRIPREORDER not implemented.\n");
1675 return E_NOTIMPL;
1676 }
1677
1678 hr = iface->lpVtbl->LockIndexBuffer(iface, 0, &indices);
1679 if (FAILED(hr)) goto cleanup;
1680
1681 dword_indices = HeapAlloc(GetProcessHeap(), 0, This->numfaces * 3 * sizeof(DWORD));
1682 if (!dword_indices) return E_OUTOFMEMORY;
1683 if (This->options & D3DXMESH_32BIT) {
1684 memcpy(dword_indices, indices, This->numfaces * 3 * sizeof(DWORD));
1685 } else {
1686 WORD *word_indices = indices;
1687 for (i = 0; i < This->numfaces * 3; i++)
1688 dword_indices[i] = *word_indices++;
1689 }
1690
1691 if ((flags & (D3DXMESHOPT_COMPACT | D3DXMESHOPT_IGNOREVERTS | D3DXMESHOPT_ATTRSORT)) == D3DXMESHOPT_COMPACT)
1692 {
1693 new_num_alloc_vertices = This->numvertices;
1694 hr = compact_mesh(This, dword_indices, &new_num_vertices, &vertex_remap);
1695 if (FAILED(hr)) goto cleanup;
1696 } else if (flags & D3DXMESHOPT_ATTRSORT) {
1697 if (!(flags & D3DXMESHOPT_IGNOREVERTS))
1698 {
1699 FIXME("D3DXMESHOPT_ATTRSORT vertex reordering not implemented.\n");
1700 hr = E_NOTIMPL;
1701 goto cleanup;
1702 }
1703
1704 hr = iface->lpVtbl->LockAttributeBuffer(iface, 0, &attrib_buffer);
1705 if (FAILED(hr)) goto cleanup;
1706
1707 hr = remap_faces_for_attrsort(This, dword_indices, attrib_buffer, &sorted_attrib_buffer, &face_remap);
1708 if (FAILED(hr)) goto cleanup;
1709 }
1710
1711 if (vertex_remap)
1712 {
1713 /* reorder the vertices using vertex_remap */
1714 D3DVERTEXBUFFER_DESC vertex_desc;
1715 DWORD *vertex_remap_ptr = ID3DXBuffer_GetBufferPointer(vertex_remap);
1716 DWORD vertex_size = iface->lpVtbl->GetNumBytesPerVertex(iface);
1717 BYTE *orig_vertices;
1718 BYTE *new_vertices;
1719
1720 hr = IDirect3DVertexBuffer9_GetDesc(This->vertex_buffer, &vertex_desc);
1721 if (FAILED(hr)) goto cleanup;
1722
1723 hr = IDirect3DDevice9_CreateVertexBuffer(This->device, new_num_alloc_vertices * vertex_size,
1724 vertex_desc.Usage, This->fvf, vertex_desc.Pool, &vertex_buffer, NULL);
1725 if (FAILED(hr)) goto cleanup;
1726
1727 hr = IDirect3DVertexBuffer9_Lock(This->vertex_buffer, 0, 0, (void**)&orig_vertices, D3DLOCK_READONLY);
1728 if (FAILED(hr)) goto cleanup;
1729
1730 hr = IDirect3DVertexBuffer9_Lock(vertex_buffer, 0, 0, (void**)&new_vertices, 0);
1731 if (FAILED(hr)) {
1732 IDirect3DVertexBuffer9_Unlock(This->vertex_buffer);
1733 goto cleanup;
1734 }
1735
1736 for (i = 0; i < new_num_vertices; i++)
1737 memcpy(new_vertices + i * vertex_size, orig_vertices + vertex_remap_ptr[i] * vertex_size, vertex_size);
1738
1739 IDirect3DVertexBuffer9_Unlock(This->vertex_buffer);
1740 IDirect3DVertexBuffer9_Unlock(vertex_buffer);
1741 } else if (vertex_remap_out) {
1742 DWORD *vertex_remap_ptr;
1743
1744 hr = D3DXCreateBuffer(This->numvertices * sizeof(DWORD), &vertex_remap);
1745 if (FAILED(hr)) goto cleanup;
1746 vertex_remap_ptr = ID3DXBuffer_GetBufferPointer(vertex_remap);
1747 for (i = 0; i < This->numvertices; i++)
1748 *vertex_remap_ptr++ = i;
1749 }
1750
1751 if (flags & D3DXMESHOPT_ATTRSORT)
1752 {
1753 D3DXATTRIBUTERANGE *attrib_table;
1754 DWORD attrib_table_size;
1755
1756 attrib_table_size = count_attributes(sorted_attrib_buffer, This->numfaces);
1757 attrib_table = HeapAlloc(GetProcessHeap(), 0, attrib_table_size * sizeof(*attrib_table));
1758 if (!attrib_table) {
1759 hr = E_OUTOFMEMORY;
1760 goto cleanup;
1761 }
1762
1763 memcpy(attrib_buffer, sorted_attrib_buffer, This->numfaces * sizeof(*attrib_buffer));
1764
1765 /* reorder the indices using face_remap */
1766 if (This->options & D3DXMESH_32BIT) {
1767 for (i = 0; i < This->numfaces; i++)
1768 memcpy((DWORD*)indices + face_remap[i] * 3, dword_indices + i * 3, 3 * sizeof(DWORD));
1769 } else {
1770 WORD *word_indices = indices;
1771 for (i = 0; i < This->numfaces; i++) {
1772 DWORD new_pos = face_remap[i] * 3;
1773 DWORD old_pos = i * 3;
1774 word_indices[new_pos++] = dword_indices[old_pos++];
1775 word_indices[new_pos++] = dword_indices[old_pos++];
1776 word_indices[new_pos] = dword_indices[old_pos];
1777 }
1778 }
1779
1780 fill_attribute_table(attrib_buffer, This->numfaces, indices,
1781 This->options & D3DXMESH_32BIT, attrib_table);
1782
1783 HeapFree(GetProcessHeap(), 0, This->attrib_table);
1784 This->attrib_table = attrib_table;
1785 This->attrib_table_size = attrib_table_size;
1786 } else {
1787 if (This->options & D3DXMESH_32BIT) {
1788 memcpy(indices, dword_indices, This->numfaces * 3 * sizeof(DWORD));
1789 } else {
1790 WORD *word_indices = indices;
1791 for (i = 0; i < This->numfaces * 3; i++)
1792 *word_indices++ = dword_indices[i];
1793 }
1794 }
1795
1796 if (adjacency_out) {
1797 if (face_remap) {
1798 for (i = 0; i < This->numfaces; i++) {
1799 DWORD old_pos = i * 3;
1800 DWORD new_pos = face_remap[i] * 3;
1801 adjacency_out[new_pos++] = face_remap[adjacency_in[old_pos++]];
1802 adjacency_out[new_pos++] = face_remap[adjacency_in[old_pos++]];
1803 adjacency_out[new_pos++] = face_remap[adjacency_in[old_pos++]];
1804 }
1805 } else {
1806 memcpy(adjacency_out, adjacency_in, This->numfaces * 3 * sizeof(*adjacency_out));
1807 }
1808 }
1809 if (face_remap_out) {
1810 if (face_remap) {
1811 for (i = 0; i < This->numfaces; i++)
1812 face_remap_out[face_remap[i]] = i;
1813 } else {
1814 for (i = 0; i < This->numfaces; i++)
1815 face_remap_out[i] = i;
1816 }
1817 }
1818 if (vertex_remap_out)
1819 *vertex_remap_out = vertex_remap;
1820 vertex_remap = NULL;
1821
1822 if (vertex_buffer) {
1823 IDirect3DVertexBuffer9_Release(This->vertex_buffer);
1824 This->vertex_buffer = vertex_buffer;
1825 vertex_buffer = NULL;
1826 This->numvertices = new_num_vertices;
1827 }
1828
1829 hr = D3D_OK;
1830 cleanup:
1831 HeapFree(GetProcessHeap(), 0, sorted_attrib_buffer);
1832 HeapFree(GetProcessHeap(), 0, face_remap);
1833 HeapFree(GetProcessHeap(), 0, dword_indices);
1834 if (vertex_remap) ID3DXBuffer_Release(vertex_remap);
1835 if (vertex_buffer) IDirect3DVertexBuffer9_Release(vertex_buffer);
1836 if (attrib_buffer) iface->lpVtbl->UnlockAttributeBuffer(iface);
1837 if (indices) iface->lpVtbl->UnlockIndexBuffer(iface);
1838 return hr;
1839 }
1840
1841 static HRESULT WINAPI d3dx9_mesh_SetAttributeTable(ID3DXMesh *iface,
1842 const D3DXATTRIBUTERANGE *attrib_table, DWORD attrib_table_size)
1843 {
1844 struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
1845 D3DXATTRIBUTERANGE *new_table = NULL;
1846
1847 TRACE("iface %p, attrib_table %p, attrib_table_size %u.\n", iface, attrib_table, attrib_table_size);
1848
1849 if (attrib_table_size) {
1850 size_t size = attrib_table_size * sizeof(*attrib_table);
1851
1852 new_table = HeapAlloc(GetProcessHeap(), 0, size);
1853 if (!new_table)
1854 return E_OUTOFMEMORY;
1855
1856 CopyMemory(new_table, attrib_table, size);
1857 } else if (attrib_table) {
1858 return D3DERR_INVALIDCALL;
1859 }
1860 HeapFree(GetProcessHeap(), 0, mesh->attrib_table);
1861 mesh->attrib_table = new_table;
1862 mesh->attrib_table_size = attrib_table_size;
1863
1864 return D3D_OK;
1865 }
1866
1867 static const struct ID3DXMeshVtbl D3DXMesh_Vtbl =
1868 {
1869 d3dx9_mesh_QueryInterface,
1870 d3dx9_mesh_AddRef,
1871 d3dx9_mesh_Release,
1872 d3dx9_mesh_DrawSubset,
1873 d3dx9_mesh_GetNumFaces,
1874 d3dx9_mesh_GetNumVertices,
1875 d3dx9_mesh_GetFVF,
1876 d3dx9_mesh_GetDeclaration,
1877 d3dx9_mesh_GetNumBytesPerVertex,
1878 d3dx9_mesh_GetOptions,
1879 d3dx9_mesh_GetDevice,
1880 d3dx9_mesh_CloneMeshFVF,
1881 d3dx9_mesh_CloneMesh,
1882 d3dx9_mesh_GetVertexBuffer,
1883 d3dx9_mesh_GetIndexBuffer,
1884 d3dx9_mesh_LockVertexBuffer,
1885 d3dx9_mesh_UnlockVertexBuffer,
1886 d3dx9_mesh_LockIndexBuffer,
1887 d3dx9_mesh_UnlockIndexBuffer,
1888 d3dx9_mesh_GetAttributeTable,
1889 d3dx9_mesh_ConvertPointRepsToAdjacency,
1890 d3dx9_mesh_ConvertAdjacencyToPointReps,
1891 d3dx9_mesh_GenerateAdjacency,
1892 d3dx9_mesh_UpdateSemantics,
1893 d3dx9_mesh_LockAttributeBuffer,
1894 d3dx9_mesh_UnlockAttributeBuffer,
1895 d3dx9_mesh_Optimize,
1896 d3dx9_mesh_OptimizeInplace,
1897 d3dx9_mesh_SetAttributeTable,
1898 };
1899
1900
1901 /* Algorithm taken from the article: An Efficient and Robust Ray-Box Intersection Algorithm
1902 Amy Williams University of Utah
1903 Steve Barrus University of Utah
1904 R. Keith Morley University of Utah
1905 Peter Shirley University of Utah
1906
1907 International Conference on Computer Graphics and Interactive Techniques archive
1908 ACM SIGGRAPH 2005 Courses
1909 Los Angeles, California
1910
1911 This algorithm is free of patents or of copyrights, as confirmed by Peter Shirley himself.
1912
1913 Algorithm: Consider the box as the intersection of three slabs. Clip the ray
1914 against each slab, if there's anything left of the ray after we're
1915 done we've got an intersection of the ray with the box. */
1916 BOOL WINAPI D3DXBoxBoundProbe(const D3DXVECTOR3 *pmin, const D3DXVECTOR3 *pmax,
1917 const D3DXVECTOR3 *prayposition, const D3DXVECTOR3 *praydirection)
1918 {
1919 FLOAT div, tmin, tmax, tymin, tymax, tzmin, tzmax;
1920
1921 div = 1.0f / praydirection->x;
1922 if ( div >= 0.0f )
1923 {
1924 tmin = ( pmin->x - prayposition->x ) * div;
1925 tmax = ( pmax->x - prayposition->x ) * div;
1926 }
1927 else
1928 {
1929 tmin = ( pmax->x - prayposition->x ) * div;
1930 tmax = ( pmin->x - prayposition->x ) * div;
1931 }
1932
1933 if ( tmax < 0.0f ) return FALSE;
1934
1935 div = 1.0f / praydirection->y;
1936 if ( div >= 0.0f )
1937 {
1938 tymin = ( pmin->y - prayposition->y ) * div;
1939 tymax = ( pmax->y - prayposition->y ) * div;
1940 }
1941 else
1942 {
1943 tymin = ( pmax->y - prayposition->y ) * div;
1944 tymax = ( pmin->y - prayposition->y ) * div;
1945 }
1946
1947 if ( ( tymax < 0.0f ) || ( tmin > tymax ) || ( tymin > tmax ) ) return FALSE;
1948
1949 if ( tymin > tmin ) tmin = tymin;
1950 if ( tymax < tmax ) tmax = tymax;
1951
1952 div = 1.0f / praydirection->z;
1953 if ( div >= 0.0f )
1954 {
1955 tzmin = ( pmin->z - prayposition->z ) * div;
1956 tzmax = ( pmax->z - prayposition->z ) * div;
1957 }
1958 else
1959 {
1960 tzmin = ( pmax->z - prayposition->z ) * div;
1961 tzmax = ( pmin->z - prayposition->z ) * div;
1962 }
1963
1964 if ( (tzmax < 0.0f ) || ( tmin > tzmax ) || ( tzmin > tmax ) ) return FALSE;
1965
1966 return TRUE;
1967 }
1968
1969 HRESULT WINAPI D3DXComputeBoundingBox(const D3DXVECTOR3 *pfirstposition,
1970 DWORD numvertices, DWORD dwstride, D3DXVECTOR3 *pmin, D3DXVECTOR3 *pmax)
1971 {
1972 D3DXVECTOR3 vec;
1973 unsigned int i;
1974
1975 if( !pfirstposition || !pmin || !pmax ) return D3DERR_INVALIDCALL;
1976
1977 *pmin = *pfirstposition;
1978 *pmax = *pmin;
1979
1980 for(i=0; i<numvertices; i++)
1981 {
1982 vec = *( (const D3DXVECTOR3*)((const char*)pfirstposition + dwstride * i) );
1983
1984 if ( vec.x < pmin->x ) pmin->x = vec.x;
1985 if ( vec.x > pmax->x ) pmax->x = vec.x;
1986
1987 if ( vec.y < pmin->y ) pmin->y = vec.y;
1988 if ( vec.y > pmax->y ) pmax->y = vec.y;
1989
1990 if ( vec.z < pmin->z ) pmin->z = vec.z;
1991 if ( vec.z > pmax->z ) pmax->z = vec.z;
1992 }
1993
1994 return D3D_OK;
1995 }
1996
1997 HRESULT WINAPI D3DXComputeBoundingSphere(const D3DXVECTOR3 *pfirstposition,
1998 DWORD numvertices, DWORD dwstride, D3DXVECTOR3 *pcenter, float *pradius)
1999 {
2000 D3DXVECTOR3 temp;
2001 FLOAT d;
2002 unsigned int i;
2003
2004 if( !pfirstposition || !pcenter || !pradius ) return D3DERR_INVALIDCALL;
2005
2006 temp.x = 0.0f;
2007 temp.y = 0.0f;
2008 temp.z = 0.0f;
2009 *pradius = 0.0f;
2010
2011 for(i=0; i<numvertices; i++)
2012 D3DXVec3Add(&temp, &temp, (const D3DXVECTOR3*)((const char*)pfirstposition + dwstride * i));
2013
2014 D3DXVec3Scale(pcenter, &temp, 1.0f / numvertices);
2015
2016 for(i=0; i<numvertices; i++)
2017 {
2018 d = D3DXVec3Length(D3DXVec3Subtract(&temp, (const D3DXVECTOR3*)((const char*)pfirstposition + dwstride * i), pcenter));
2019 if ( d > *pradius ) *pradius = d;
2020 }
2021 return D3D_OK;
2022 }
2023
2024 static void append_decl_element(D3DVERTEXELEMENT9 *declaration, UINT *idx, UINT *offset,
2025 D3DDECLTYPE type, D3DDECLUSAGE usage, UINT usage_idx)
2026 {
2027 declaration[*idx].Stream = 0;
2028 declaration[*idx].Offset = *offset;
2029 declaration[*idx].Type = type;
2030 declaration[*idx].Method = D3DDECLMETHOD_DEFAULT;
2031 declaration[*idx].Usage = usage;
2032 declaration[*idx].UsageIndex = usage_idx;
2033
2034 *offset += d3dx_decltype_size[type];
2035 ++(*idx);
2036 }
2037
2038 /*************************************************************************
2039 * D3DXDeclaratorFromFVF
2040 */
2041 HRESULT WINAPI D3DXDeclaratorFromFVF(DWORD fvf, D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE])
2042 {
2043 static const D3DVERTEXELEMENT9 end_element = D3DDECL_END();
2044 DWORD tex_count = (fvf & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
2045 unsigned int offset = 0;
2046 unsigned int idx = 0;
2047 unsigned int i;
2048
2049 TRACE("fvf %#x, declaration %p.\n", fvf, declaration);
2050
2051 if (fvf & (D3DFVF_RESERVED0 | D3DFVF_RESERVED2)) return D3DERR_INVALIDCALL;
2052
2053 if (fvf & D3DFVF_POSITION_MASK)
2054 {
2055 BOOL has_blend = (fvf & D3DFVF_XYZB5) >= D3DFVF_XYZB1;
2056 DWORD blend_count = 1 + (((fvf & D3DFVF_XYZB5) - D3DFVF_XYZB1) >> 1);
2057 BOOL has_blend_idx = (fvf & D3DFVF_LASTBETA_D3DCOLOR) || (fvf & D3DFVF_LASTBETA_UBYTE4);
2058
2059 if (has_blend_idx) --blend_count;
2060
2061 if ((fvf & D3DFVF_POSITION_MASK) == D3DFVF_XYZW
2062 || (has_blend && blend_count > 4))
2063 return D3DERR_INVALIDCALL;
2064
2065 if ((fvf & D3DFVF_POSITION_MASK) == D3DFVF_XYZRHW)
2066 append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT4, D3DDECLUSAGE_POSITIONT, 0);
2067 else
2068 append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT3, D3DDECLUSAGE_POSITION, 0);
2069
2070 if (has_blend)
2071 {
2072 switch (blend_count)
2073 {
2074 case 0:
2075 break;
2076 case 1:
2077 append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT1, D3DDECLUSAGE_BLENDWEIGHT, 0);
2078 break;
2079 case 2:
2080 append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT2, D3DDECLUSAGE_BLENDWEIGHT, 0);
2081 break;
2082 case 3:
2083 append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT3, D3DDECLUSAGE_BLENDWEIGHT, 0);
2084 break;
2085 case 4:
2086 append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT4, D3DDECLUSAGE_BLENDWEIGHT, 0);
2087 break;
2088 default:
2089 ERR("Invalid blend count %u.\n", blend_count);
2090 break;
2091 }
2092
2093 if (has_blend_idx)
2094 {
2095 if (fvf & D3DFVF_LASTBETA_UBYTE4)
2096 append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_UBYTE4, D3DDECLUSAGE_BLENDINDICES, 0);
2097 else if (fvf & D3DFVF_LASTBETA_D3DCOLOR)
2098 append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_D3DCOLOR, D3DDECLUSAGE_BLENDINDICES, 0);
2099 }
2100 }
2101 }
2102
2103 if (fvf & D3DFVF_NORMAL)
2104 append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT3, D3DDECLUSAGE_NORMAL, 0);
2105 if (fvf & D3DFVF_PSIZE)
2106 append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT1, D3DDECLUSAGE_PSIZE, 0);
2107 if (fvf & D3DFVF_DIFFUSE)
2108 append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_D3DCOLOR, D3DDECLUSAGE_COLOR, 0);
2109 if (fvf & D3DFVF_SPECULAR)
2110 append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_D3DCOLOR, D3DDECLUSAGE_COLOR, 1);
2111
2112 for (i = 0; i < tex_count; ++i)
2113 {
2114 switch ((fvf >> (16 + 2 * i)) & 0x03)
2115 {
2116 case D3DFVF_TEXTUREFORMAT1:
2117 append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT1, D3DDECLUSAGE_TEXCOORD, i);
2118 break;
2119 case D3DFVF_TEXTUREFORMAT2:
2120 append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT2, D3DDECLUSAGE_TEXCOORD, i);
2121 break;
2122 case D3DFVF_TEXTUREFORMAT3:
2123 append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT3, D3DDECLUSAGE_TEXCOORD, i);
2124 break;
2125 case D3DFVF_TEXTUREFORMAT4:
2126 append_decl_element(declaration, &idx, &offset, D3DDECLTYPE_FLOAT4, D3DDECLUSAGE_TEXCOORD, i);
2127 break;
2128 }
2129 }
2130
2131 declaration[idx] = end_element;
2132
2133 return D3D_OK;
2134 }
2135
2136 /*************************************************************************
2137 * D3DXFVFFromDeclarator
2138 */
2139 HRESULT WINAPI D3DXFVFFromDeclarator(const D3DVERTEXELEMENT9 *declaration, DWORD *fvf)
2140 {
2141 unsigned int i = 0, texture, offset;
2142
2143 TRACE("(%p, %p)\n", declaration, fvf);
2144
2145 *fvf = 0;
2146 if (declaration[0].Type == D3DDECLTYPE_FLOAT3 && declaration[0].Usage == D3DDECLUSAGE_POSITION)
2147 {
2148 if ((declaration[1].Type == D3DDECLTYPE_FLOAT4 && declaration[1].Usage == D3DDECLUSAGE_BLENDWEIGHT &&
2149 declaration[1].UsageIndex == 0) &&
2150 (declaration[2].Type == D3DDECLTYPE_FLOAT1 && declaration[2].Usage == D3DDECLUSAGE_BLENDINDICES &&
2151 declaration[2].UsageIndex == 0))
2152 {
2153 return D3DERR_INVALIDCALL;
2154 }
2155 else if ((declaration[1].Type == D3DDECLTYPE_UBYTE4 || declaration[1].Type == D3DDECLTYPE_D3DCOLOR) &&
2156 declaration[1].Usage == D3DDECLUSAGE_BLENDINDICES && declaration[1].UsageIndex == 0)
2157 {
2158 if (declaration[1].Type == D3DDECLTYPE_UBYTE4)
2159 {
2160 *fvf |= D3DFVF_XYZB1 | D3DFVF_LASTBETA_UBYTE4;
2161 }
2162 else
2163 {
2164 *fvf |= D3DFVF_XYZB1 | D3DFVF_LASTBETA_D3DCOLOR;
2165 }
2166 i = 2;
2167 }
2168 else if (declaration[1].Type <= D3DDECLTYPE_FLOAT4 && declaration[1].Usage == D3DDECLUSAGE_BLENDWEIGHT &&
2169 declaration[1].UsageIndex == 0)
2170 {
2171 if ((declaration[2].Type == D3DDECLTYPE_UBYTE4 || declaration[2].Type == D3DDECLTYPE_D3DCOLOR) &&
2172 declaration[2].Usage == D3DDECLUSAGE_BLENDINDICES && declaration[2].UsageIndex == 0)
2173 {
2174 if (declaration[2].Type == D3DDECLTYPE_UBYTE4)
2175 {
2176 *fvf |= D3DFVF_LASTBETA_UBYTE4;
2177 }
2178 else
2179 {
2180 *fvf |= D3DFVF_LASTBETA_D3DCOLOR;
2181 }
2182 switch (declaration[1].Type)
2183 {
2184 case D3DDECLTYPE_FLOAT1: *fvf |= D3DFVF_XYZB2; break;
2185 case D3DDECLTYPE_FLOAT2: *fvf |= D3DFVF_XYZB3; break;
2186 case D3DDECLTYPE_FLOAT3: *fvf |= D3DFVF_XYZB4; break;
2187 case D3DDECLTYPE_FLOAT4: *fvf |= D3DFVF_XYZB5; break;
2188 }
2189 i = 3;
2190 }
2191 else
2192 {
2193 switch (declaration[1].Type)
2194 {
2195 case D3DDECLTYPE_FLOAT1: *fvf |= D3DFVF_XYZB1; break;
2196 case D3DDECLTYPE_FLOAT2: *fvf |= D3DFVF_XYZB2; break;
2197 case D3DDECLTYPE_FLOAT3: *fvf |= D3DFVF_XYZB3; break;
2198 case D3DDECLTYPE_FLOAT4: *fvf |= D3DFVF_XYZB4; break;
2199 }
2200 i = 2;
2201 }
2202 }
2203 else
2204 {
2205 *fvf |= D3DFVF_XYZ;
2206 i = 1;
2207 }
2208 }
2209 else if (declaration[0].Type == D3DDECLTYPE_FLOAT4 && declaration[0].Usage == D3DDECLUSAGE_POSITIONT &&
2210 declaration[0].UsageIndex == 0)
2211 {
2212 *fvf |= D3DFVF_XYZRHW;
2213 i = 1;
2214 }
2215
2216 if (declaration[i].Type == D3DDECLTYPE_FLOAT3 && declaration[i].Usage == D3DDECLUSAGE_NORMAL)
2217 {
2218 *fvf |= D3DFVF_NORMAL;
2219 i++;
2220 }
2221 if (declaration[i].Type == D3DDECLTYPE_FLOAT1 && declaration[i].Usage == D3DDECLUSAGE_PSIZE &&
2222 declaration[i].UsageIndex == 0)
2223 {
2224 *fvf |= D3DFVF_PSIZE;
2225 i++;
2226 }
2227 if (declaration[i].Type == D3DDECLTYPE_D3DCOLOR && declaration[i].Usage == D3DDECLUSAGE_COLOR &&
2228 declaration[i].UsageIndex == 0)
2229 {
2230 *fvf |= D3DFVF_DIFFUSE;
2231 i++;
2232 }
2233 if (declaration[i].Type == D3DDECLTYPE_D3DCOLOR && declaration[i].Usage == D3DDECLUSAGE_COLOR &&
2234 declaration[i].UsageIndex == 1)
2235 {
2236 *fvf |= D3DFVF_SPECULAR;
2237 i++;
2238 }
2239
2240 for (texture = 0; texture < D3DDP_MAXTEXCOORD; i++, texture++)
2241 {
2242 if (declaration[i].Stream == 0xFF)
2243 {
2244 break;
2245 }
2246 else if (declaration[i].Type == D3DDECLTYPE_FLOAT1 && declaration[i].Usage == D3DDECLUSAGE_TEXCOORD &&
2247 declaration[i].UsageIndex == texture)
2248 {
2249 *fvf |= D3DFVF_TEXCOORDSIZE1(declaration[i].UsageIndex);
2250 }
2251 else if (declaration[i].Type == D3DDECLTYPE_FLOAT2 && declaration[i].Usage == D3DDECLUSAGE_TEXCOORD &&
2252 declaration[i].UsageIndex == texture)
2253 {
2254 *fvf |= D3DFVF_TEXCOORDSIZE2(declaration[i].UsageIndex);
2255 }
2256 else if (declaration[i].Type == D3DDECLTYPE_FLOAT3 && declaration[i].Usage == D3DDECLUSAGE_TEXCOORD &&
2257 declaration[i].UsageIndex == texture)
2258 {
2259 *fvf |= D3DFVF_TEXCOORDSIZE3(declaration[i].UsageIndex);
2260 }
2261 else if (declaration[i].Type == D3DDECLTYPE_FLOAT4 && declaration[i].Usage == D3DDECLUSAGE_TEXCOORD &&
2262 declaration[i].UsageIndex == texture)
2263 {
2264 *fvf |= D3DFVF_TEXCOORDSIZE4(declaration[i].UsageIndex);
2265 }
2266 else
2267 {
2268 return D3DERR_INVALIDCALL;
2269 }
2270 }
2271
2272 *fvf |= (texture << D3DFVF_TEXCOUNT_SHIFT);
2273
2274 for (offset = 0, i = 0; declaration[i].Stream != 0xFF;
2275 offset += d3dx_decltype_size[declaration[i].Type], i++)
2276 {
2277 if (declaration[i].Offset != offset)
2278 {
2279 return D3DERR_INVALIDCALL;
2280 }
2281 }
2282
2283 return D3D_OK;
2284 }
2285
2286 /*************************************************************************
2287 * D3DXGetFVFVertexSize
2288 */
2289 static UINT Get_TexCoord_Size_From_FVF(DWORD FVF, int tex_num)
2290 {
2291 return (((((FVF) >> (16 + (2 * (tex_num)))) + 1) & 0x03) + 1);
2292 }
2293
2294 UINT WINAPI D3DXGetFVFVertexSize(DWORD FVF)
2295 {
2296 DWORD size = 0;
2297 UINT i;
2298 UINT numTextures = (FVF & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
2299
2300 if (FVF & D3DFVF_NORMAL) size += sizeof(D3DXVECTOR3);
2301 if (FVF & D3DFVF_DIFFUSE) size += sizeof(DWORD);
2302 if (FVF & D3DFVF_SPECULAR) size += sizeof(DWORD);
2303 if (FVF & D3DFVF_PSIZE) size += sizeof(DWORD);
2304
2305 switch (FVF & D3DFVF_POSITION_MASK)
2306 {
2307 case D3DFVF_XYZ: size += sizeof(D3DXVECTOR3); break;
2308 case D3DFVF_XYZRHW: size += 4 * sizeof(FLOAT); break;
2309 case D3DFVF_XYZB1: size += 4 * sizeof(FLOAT); break;
2310 case D3DFVF_XYZB2: size += 5 * sizeof(FLOAT); break;
2311 case D3DFVF_XYZB3: size += 6 * sizeof(FLOAT); break;
2312 case D3DFVF_XYZB4: size += 7 * sizeof(FLOAT); break;
2313 case D3DFVF_XYZB5: size += 8 * sizeof(FLOAT); break;
2314 case D3DFVF_XYZW: size += 4 * sizeof(FLOAT); break;
2315 }
2316
2317 for (i = 0; i < numTextures; i++)
2318 {
2319 size += Get_TexCoord_Size_From_FVF(FVF, i) * sizeof(FLOAT);
2320 }
2321
2322 return size;
2323 }
2324
2325 /*************************************************************************
2326 * D3DXGetDeclVertexSize
2327 */
2328 UINT WINAPI D3DXGetDeclVertexSize(const D3DVERTEXELEMENT9 *decl, DWORD stream_idx)
2329 {
2330 const D3DVERTEXELEMENT9 *element;
2331 UINT size = 0;
2332
2333 TRACE("decl %p, stream_idx %u\n", decl, stream_idx);
2334
2335 if (!decl) return 0;
2336
2337 for (element = decl; element->Stream != 0xff; ++element)
2338 {
2339 UINT type_size;
2340
2341 if (element->Stream != stream_idx) continue;
2342
2343 if (element->Type >= sizeof(d3dx_decltype_size) / sizeof(*d3dx_decltype_size))
2344 {
2345 FIXME("Unhandled element type %#x, size will be incorrect.\n", element->Type);
2346 continue;
2347 }
2348
2349 type_size = d3dx_decltype_size[element->Type];
2350 if (element->Offset + type_size > size) size = element->Offset + type_size;
2351 }
2352
2353 return size;
2354 }
2355
2356 /*************************************************************************
2357 * D3DXGetDeclLength
2358 */
2359 UINT WINAPI D3DXGetDeclLength(const D3DVERTEXELEMENT9 *decl)
2360 {
2361 const D3DVERTEXELEMENT9 *element;
2362
2363 TRACE("decl %p\n", decl);
2364
2365 /* null decl results in exception on Windows XP */
2366
2367 for (element = decl; element->Stream != 0xff; ++element);
2368
2369 return element - decl;
2370 }
2371
2372 BOOL WINAPI D3DXIntersectTri(const D3DXVECTOR3 *p0, const D3DXVECTOR3 *p1, const D3DXVECTOR3 *p2,
2373 const D3DXVECTOR3 *praypos, const D3DXVECTOR3 *praydir, float *pu, float *pv, float *pdist)
2374 {
2375 D3DXMATRIX m;
2376 D3DXVECTOR4 vec;
2377
2378 TRACE("p0 %p, p1 %p, p2 %p, praypos %p, praydir %p, pu %p, pv %p, pdist %p.\n",
2379 p0, p1, p2, praypos, praydir, pu, pv, pdist);
2380
2381 m.u.m[0][0] = p1->x - p0->x;
2382 m.u.m[1][0] = p2->x - p0->x;
2383 m.u.m[2][0] = -praydir->x;
2384 m.u.m[3][0] = 0.0f;
2385 m.u.m[0][1] = p1->y - p0->y;
2386 m.u.m[1][1] = p2->y - p0->y;
2387 m.u.m[2][1] = -praydir->y;
2388 m.u.m[3][1] = 0.0f;
2389 m.u.m[0][2] = p1->z - p0->z;
2390 m.u.m[1][2] = p2->z - p0->z;
2391 m.u.m[2][2] = -praydir->z;
2392 m.u.m[3][2] = 0.0f;
2393 m.u.m[0][3] = 0.0f;
2394 m.u.m[1][3] = 0.0f;
2395 m.u.m[2][3] = 0.0f;
2396 m.u.m[3][3] = 1.0f;
2397
2398 vec.x = praypos->x - p0->x;
2399 vec.y = praypos->y - p0->y;
2400 vec.z = praypos->z - p0->z;
2401 vec.w = 0.0f;
2402
2403 if ( D3DXMatrixInverse(&m, NULL, &m) )
2404 {
2405 D3DXVec4Transform(&vec, &vec, &m);
2406 if ( (vec.x >= 0.0f) && (vec.y >= 0.0f) && (vec.x + vec.y <= 1.0f) && (vec.z >= 0.0f) )
2407 {
2408 if (pu) *pu = vec.x;
2409 if (pv) *pv = vec.y;
2410 if (pdist) *pdist = fabsf( vec.z );
2411 return TRUE;
2412 }
2413 }
2414
2415 return FALSE;
2416 }
2417
2418 BOOL WINAPI D3DXSphereBoundProbe(const D3DXVECTOR3 *pcenter, float radius,
2419 const D3DXVECTOR3 *prayposition, const D3DXVECTOR3 *praydirection)
2420 {
2421 D3DXVECTOR3 difference;
2422 FLOAT a, b, c, d;
2423
2424 a = D3DXVec3LengthSq(praydirection);
2425 if (!D3DXVec3Subtract(&difference, prayposition, pcenter)) return FALSE;
2426 b = D3DXVec3Dot(&difference, praydirection);
2427 c = D3DXVec3LengthSq(&difference) - radius * radius;
2428 d = b * b - a * c;
2429
2430 if ( ( d <= 0.0f ) || ( sqrt(d) <= b ) ) return FALSE;
2431 return TRUE;
2432 }
2433
2434 /*************************************************************************
2435 * D3DXCreateMesh
2436 */
2437 HRESULT WINAPI D3DXCreateMesh(DWORD numfaces, DWORD numvertices, DWORD options,
2438 const D3DVERTEXELEMENT9 *declaration, struct IDirect3DDevice9 *device, struct ID3DXMesh **mesh)
2439 {
2440 HRESULT hr;
2441 DWORD fvf;
2442 IDirect3DVertexDeclaration9 *vertex_declaration;
2443 UINT vertex_declaration_size;
2444 UINT num_elem;
2445 IDirect3DVertexBuffer9 *vertex_buffer;
2446 IDirect3DIndexBuffer9 *index_buffer;
2447 DWORD *attrib_buffer;
2448 struct d3dx9_mesh *object;
2449 DWORD index_usage = 0;
2450 D3DPOOL index_pool = D3DPOOL_DEFAULT;
2451 D3DFORMAT index_format = D3DFMT_INDEX16;
2452 DWORD vertex_usage = 0;
2453 D3DPOOL vertex_pool = D3DPOOL_DEFAULT;
2454 int i;
2455
2456 TRACE("numfaces %u, numvertices %u, options %#x, declaration %p, device %p, mesh %p.\n",
2457 numfaces, numvertices, options, declaration, device, mesh);
2458
2459 if (numfaces == 0 || numvertices == 0 || declaration == NULL || device == NULL || mesh == NULL ||
2460 /* D3DXMESH_VB_SHARE is for cloning, and D3DXMESH_USEHWONLY is for ConvertToBlendedMesh */
2461 (options & (D3DXMESH_VB_SHARE | D3DXMESH_USEHWONLY | 0xfffe0000)))
2462 {
2463 return D3DERR_INVALIDCALL;
2464 }
2465 for (i = 0; declaration[i].Stream != 0xff; i++)
2466 if (declaration[i].Stream != 0)
2467 return D3DERR_INVALIDCALL;
2468 num_elem = i + 1;
2469
2470 if (options & D3DXMESH_32BIT)
2471 index_format = D3DFMT_INDEX32;
2472
2473 if (options & D3DXMESH_DONOTCLIP) {
2474 index_usage |= D3DUSAGE_DONOTCLIP;
2475 vertex_usage |= D3DUSAGE_DONOTCLIP;
2476 }
2477 if (options & D3DXMESH_POINTS) {
2478 index_usage |= D3DUSAGE_POINTS;
2479 vertex_usage |= D3DUSAGE_POINTS;
2480 }
2481 if (options & D3DXMESH_RTPATCHES) {
2482 index_usage |= D3DUSAGE_RTPATCHES;
2483 vertex_usage |= D3DUSAGE_RTPATCHES;
2484 }
2485 if (options & D3DXMESH_NPATCHES) {
2486 index_usage |= D3DUSAGE_NPATCHES;
2487 vertex_usage |= D3DUSAGE_NPATCHES;
2488 }
2489
2490 if (options & D3DXMESH_VB_SYSTEMMEM)
2491 vertex_pool = D3DPOOL_SYSTEMMEM;
2492 else if (options & D3DXMESH_VB_MANAGED)
2493 vertex_pool = D3DPOOL_MANAGED;
2494
2495 if (options & D3DXMESH_VB_WRITEONLY)
2496 vertex_usage |= D3DUSAGE_WRITEONLY;
2497 if (options & D3DXMESH_VB_DYNAMIC)
2498 vertex_usage |= D3DUSAGE_DYNAMIC;
2499 if (options & D3DXMESH_VB_SOFTWAREPROCESSING)
2500 vertex_usage |= D3DUSAGE_SOFTWAREPROCESSING;
2501
2502 if (options & D3DXMESH_IB_SYSTEMMEM)
2503 index_pool = D3DPOOL_SYSTEMMEM;
2504 else if (options & D3DXMESH_IB_MANAGED)
2505 index_pool = D3DPOOL_MANAGED;
2506
2507 if (options & D3DXMESH_IB_WRITEONLY)
2508 index_usage |= D3DUSAGE_WRITEONLY;
2509 if (options & D3DXMESH_IB_DYNAMIC)
2510 index_usage |= D3DUSAGE_DYNAMIC;
2511 if (options & D3DXMESH_IB_SOFTWAREPROCESSING)
2512 index_usage |= D3DUSAGE_SOFTWAREPROCESSING;
2513
2514 hr = D3DXFVFFromDeclarator(declaration, &fvf);
2515 if (hr != D3D_OK)
2516 {
2517 fvf = 0;
2518 }
2519
2520 /* Create vertex declaration */
2521 hr = IDirect3DDevice9_CreateVertexDeclaration(device,
2522 declaration,
2523 &vertex_declaration);
2524 if (FAILED(hr))
2525 {
2526 WARN("Unexpected return value %x from IDirect3DDevice9_CreateVertexDeclaration.\n",hr);
2527 return hr;
2528 }
2529 vertex_declaration_size = D3DXGetDeclVertexSize(declaration, declaration[0].Stream);
2530
2531 /* Create vertex buffer */
2532 hr = IDirect3DDevice9_CreateVertexBuffer(device,
2533 numvertices * vertex_declaration_size,
2534 vertex_usage,
2535 fvf,
2536 vertex_pool,
2537 &vertex_buffer,
2538 NULL);
2539 if (FAILED(hr))
2540 {
2541 WARN("Unexpected return value %x from IDirect3DDevice9_CreateVertexBuffer.\n",hr);
2542 IDirect3DVertexDeclaration9_Release(vertex_declaration);
2543 return hr;
2544 }
2545
2546 /* Create index buffer */
2547 hr = IDirect3DDevice9_CreateIndexBuffer(device,
2548 numfaces * 3 * ((index_format == D3DFMT_INDEX16) ? 2 : 4),
2549 index_usage,
2550 index_format,
2551 index_pool,
2552 &index_buffer,
2553 NULL);
2554 if (FAILED(hr))
2555 {
2556 WARN("Unexpected return value %x from IDirect3DDevice9_CreateVertexBuffer.\n",hr);
2557 IDirect3DVertexBuffer9_Release(vertex_buffer);
2558 IDirect3DVertexDeclaration9_Release(vertex_declaration);
2559 return hr;
2560 }
2561
2562 attrib_buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, numfaces * sizeof(*attrib_buffer));
2563 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2564 if (object == NULL || attrib_buffer == NULL)
2565 {
2566 HeapFree(GetProcessHeap(), 0, object);
2567 HeapFree(GetProcessHeap(), 0, attrib_buffer);
2568 IDirect3DIndexBuffer9_Release(index_buffer);
2569 IDirect3DVertexBuffer9_Release(vertex_buffer);
2570 IDirect3DVertexDeclaration9_Release(vertex_declaration);
2571 *mesh = NULL;
2572 return E_OUTOFMEMORY;
2573 }
2574 object->ID3DXMesh_iface.lpVtbl = &D3DXMesh_Vtbl;
2575 object->ref = 1;
2576
2577 object->numfaces = numfaces;
2578 object->numvertices = numvertices;
2579 object->options = options;
2580 object->fvf = fvf;
2581 object->device = device;
2582 IDirect3DDevice9_AddRef(device);
2583
2584 copy_declaration(object->cached_declaration, declaration, num_elem);
2585 object->vertex_declaration = vertex_declaration;
2586 object->vertex_declaration_size = vertex_declaration_size;
2587 object->num_elem = num_elem;
2588 object->vertex_buffer = vertex_buffer;
2589 object->index_buffer = index_buffer;
2590 object->attrib_buffer = attrib_buffer;
2591
2592 *mesh = &object->ID3DXMesh_iface;
2593
2594 return D3D_OK;
2595 }
2596
2597 /*************************************************************************
2598 * D3DXCreateMeshFVF
2599 */
2600 HRESULT WINAPI D3DXCreateMeshFVF(DWORD numfaces, DWORD numvertices, DWORD options,
2601 DWORD fvf, struct IDirect3DDevice9 *device, struct ID3DXMesh **mesh)
2602 {
2603 HRESULT hr;
2604 D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE];
2605
2606 TRACE("(%u, %u, %u, %u, %p, %p)\n", numfaces, numvertices, options, fvf, device, mesh);
2607
2608 hr = D3DXDeclaratorFromFVF(fvf, declaration);
2609 if (FAILED(hr)) return hr;
2610
2611 return D3DXCreateMesh(numfaces, numvertices, options, declaration, device, mesh);
2612 }
2613
2614
2615 struct mesh_data {
2616 DWORD num_vertices;
2617 DWORD num_poly_faces;
2618 DWORD num_tri_faces;
2619 D3DXVECTOR3 *vertices;
2620 DWORD *num_tri_per_face;
2621 DWORD *indices;
2622
2623 DWORD fvf;
2624
2625 /* optional mesh data */
2626
2627 DWORD num_normals;
2628 D3DXVECTOR3 *normals;
2629 DWORD *normal_indices;
2630
2631 D3DXVECTOR2 *tex_coords;
2632
2633 DWORD *vertex_colors;
2634
2635 DWORD num_materials;
2636 D3DXMATERIAL *materials;
2637 DWORD *material_indices;
2638
2639 struct ID3DXSkinInfo *skin_info;
2640 DWORD nb_bones;
2641 };
2642
2643 static HRESULT parse_texture_filename(ID3DXFileData *filedata, char **filename_out)
2644 {
2645 HRESULT hr;
2646 SIZE_T data_size;
2647 BYTE *data;
2648 char *filename_in;
2649 char *filename = NULL;
2650
2651 /* template TextureFilename {
2652 * STRING filename;
2653 * }
2654 */
2655
2656 HeapFree(GetProcessHeap(), 0, *filename_out);
2657 *filename_out = NULL;
2658
2659 hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void**)&data);
2660 if (FAILED(hr)) return hr;
2661
2662 /* FIXME: String must be retrieved directly instead of through a pointer once ID3DXFILE is fixed */
2663 if (data_size < sizeof(filename_in))
2664 {
2665 WARN("truncated data (%lu bytes)\n", data_size);
2666 filedata->lpVtbl->Unlock(filedata);
2667 return E_FAIL;
2668 }
2669 filename_in = *(char **)data;
2670
2671 filename = HeapAlloc(GetProcessHeap(), 0, strlen(filename_in) + 1);
2672 if (!filename) {
2673 filedata->lpVtbl->Unlock(filedata);
2674 return E_OUTOFMEMORY;
2675 }
2676
2677 strcpy(filename, filename_in);
2678 *filename_out = filename;
2679
2680 filedata->lpVtbl->Unlock(filedata);
2681
2682 return D3D_OK;
2683 }
2684
2685 static HRESULT parse_material(ID3DXFileData *filedata, D3DXMATERIAL *material)
2686 {
2687 HRESULT hr;
2688 SIZE_T data_size;
2689 const BYTE *data;
2690 GUID type;
2691 ID3DXFileData *child;
2692 SIZE_T i, nb_children;
2693
2694 material->pTextureFilename = NULL;
2695
2696 hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void**)&data);
2697 if (FAILED(hr)) return hr;
2698
2699 /*
2700 * template ColorRGBA {
2701 * FLOAT red;
2702 * FLOAT green;
2703 * FLOAT blue;
2704 * FLOAT alpha;
2705 * }
2706 * template ColorRGB {
2707 * FLOAT red;
2708 * FLOAT green;
2709 * FLOAT blue;
2710 * }
2711 * template Material {
2712 * ColorRGBA faceColor;
2713 * FLOAT power;
2714 * ColorRGB specularColor;
2715 * ColorRGB emissiveColor;
2716 * [ ... ]
2717 * }
2718 */
2719 if (data_size != sizeof(FLOAT) * 11) {
2720 WARN("incorrect data size (%ld bytes)\n", data_size);
2721 filedata->lpVtbl->Unlock(filedata);
2722 return E_FAIL;
2723 }
2724
2725 memcpy(&material->MatD3D.Diffuse, data, sizeof(D3DCOLORVALUE));
2726 data += sizeof(D3DCOLORVALUE);
2727 material->MatD3D.Power = *(FLOAT*)data;
2728 data += sizeof(FLOAT);
2729 memcpy(&material->MatD3D.Specular, data, sizeof(FLOAT) * 3);
2730 material->MatD3D.Specular.a = 1.0f;
2731 data += 3 * sizeof(FLOAT);
2732 memcpy(&material->MatD3D.Emissive, data, sizeof(FLOAT) * 3);
2733 material->MatD3D.Emissive.a = 1.0f;
2734 material->MatD3D.Ambient.r = 0.0f;
2735 material->MatD3D.Ambient.g = 0.0f;
2736 material->MatD3D.Ambient.b = 0.0f;
2737 material->MatD3D.Ambient.a = 1.0f;
2738
2739 filedata->lpVtbl->Unlock(filedata);
2740
2741 hr = filedata->lpVtbl->GetChildren(filedata, &nb_children);
2742 if (FAILED(hr))
2743 return hr;
2744
2745 for (i = 0; i < nb_children; i++)
2746 {
2747 hr = filedata->lpVtbl->GetChild(filedata, i, &child);
2748 if (FAILED(hr))
2749 return hr;
2750 hr = child->lpVtbl->GetType(child, &type);
2751 if (FAILED(hr))
2752 goto err;
2753
2754 if (IsEqualGUID(&type, &TID_D3DRMTextureFilename)) {
2755 hr = parse_texture_filename(child, &material->pTextureFilename);
2756 if (FAILED(hr))
2757 goto err;
2758 }
2759 IUnknown_Release(child);
2760 }
2761 return D3D_OK;
2762
2763 err:
2764 IUnknown_Release(child);
2765 return hr;
2766 }
2767
2768 static void destroy_materials(struct mesh_data *mesh)
2769 {
2770 DWORD i;
2771 for (i = 0; i < mesh->num_materials; i++)
2772 HeapFree(GetProcessHeap(), 0, mesh->materials[i].pTextureFilename);
2773 HeapFree(GetProcessHeap(), 0, mesh->materials);
2774 HeapFree(GetProcessHeap(), 0, mesh->material_indices);
2775 mesh->num_materials = 0;
2776 mesh->materials = NULL;
2777 mesh->material_indices = NULL;
2778 }
2779
2780 static HRESULT parse_material_list(ID3DXFileData *filedata, struct mesh_data *mesh)
2781 {
2782 HRESULT hr;
2783 SIZE_T data_size;
2784 const DWORD *data, *in_ptr;
2785 GUID type;
2786 ID3DXFileData *child = NULL;
2787 DWORD num_materials;
2788 DWORD i;
2789 SIZE_T nb_children;
2790
2791 destroy_materials(mesh);
2792
2793 hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void**)&data);
2794 if (FAILED(hr)) return hr;
2795
2796 /* template MeshMaterialList {
2797 * DWORD nMaterials;
2798 * DWORD nFaceIndexes;
2799 * array DWORD faceIndexes[nFaceIndexes];
2800 * [ Material ]
2801 * }
2802 */
2803
2804 in_ptr = data;
2805 hr = E_FAIL;
2806
2807 if (data_size < sizeof(DWORD)) {
2808 WARN("truncated data (%ld bytes)\n", data_size);
2809 goto end;
2810 }
2811 num_materials = *in_ptr++;
2812 if (!num_materials) {
2813 hr = D3D_OK;
2814 goto end;
2815 }
2816
2817 if (data_size < 2 * sizeof(DWORD)) {
2818 WARN("truncated data (%ld bytes)\n", data_size);
2819 goto end;
2820 }
2821 if (*in_ptr++ != mesh->num_poly_faces) {
2822 WARN("number of material face indices (%u) doesn't match number of faces (%u)\n",
2823 *(in_ptr - 1), mesh->num_poly_faces);
2824 goto end;
2825 }
2826 if (data_size < 2 * sizeof(DWORD) + mesh->num_poly_faces * sizeof(DWORD)) {
2827 WARN("truncated data (%ld bytes)\n", data_size);
2828 goto end;
2829 }
2830 for (i = 0; i < mesh->num_poly_faces; i++) {
2831 if (*in_ptr++ >= num_materials) {
2832 WARN("face %u: reference to undefined material %u (only %u materials)\n",
2833 i, *(in_ptr - 1), num_materials);
2834 goto end;
2835 }
2836 }
2837
2838 mesh->materials = HeapAlloc(GetProcessHeap(), 0, num_materials * sizeof(*mesh->materials));
2839 mesh->material_indices = HeapAlloc(GetProcessHeap(), 0, mesh->num_poly_faces * sizeof(*mesh->material_indices));
2840 if (!mesh->materials || !mesh->material_indices) {
2841 hr = E_OUTOFMEMORY;
2842 goto end;
2843 }
2844 memcpy(mesh->material_indices, data + 2, mesh->num_poly_faces * sizeof(DWORD));
2845
2846 hr = filedata->lpVtbl->GetChildren(filedata, &nb_children);
2847 if (FAILED(hr))
2848 goto end;
2849
2850 for (i = 0; i < nb_children; i++)
2851 {
2852 hr = filedata->lpVtbl->GetChild(filedata, i, &child);
2853 if (FAILED(hr))
2854 goto end;
2855 hr = child->lpVtbl->GetType(child, &type);
2856 if (FAILED(hr))
2857 goto end;
2858
2859 if (IsEqualGUID(&type, &TID_D3DRMMaterial)) {
2860 if (mesh->num_materials >= num_materials) {
2861 WARN("more materials defined than declared\n");
2862 hr = E_FAIL;
2863 goto end;
2864 }
2865 hr = parse_material(child, &mesh->materials[mesh->num_materials++]);
2866 if (FAILED(hr))
2867 goto end;
2868 }
2869
2870 IUnknown_Release(child);
2871 child = NULL;
2872 }
2873 if (num_materials != mesh->num_materials) {
2874 WARN("only %u of %u materials defined\n", num_materials, mesh->num_materials);
2875 hr = E_FAIL;
2876 }
2877
2878 end:
2879 if (child)
2880 IUnknown_Release(child);
2881 filedata->lpVtbl->Unlock(filedata);
2882 return hr;
2883 }
2884
2885 static HRESULT parse_texture_coords(ID3DXFileData *filedata, struct mesh_data *mesh)
2886 {
2887 HRESULT hr;
2888 SIZE_T data_size;
2889 const BYTE *data;
2890
2891 HeapFree(GetProcessHeap(), 0, mesh->tex_coords);
2892 mesh->tex_coords = NULL;
2893
2894 hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void**)&data);
2895 if (FAILED(hr)) return hr;
2896
2897 /* template Coords2d {
2898 * FLOAT u;
2899 * FLOAT v;
2900 * }
2901 * template MeshTextureCoords {
2902 * DWORD nTextureCoords;
2903 * array Coords2d textureCoords[nTextureCoords];
2904 * }
2905 */
2906
2907 hr = E_FAIL;
2908
2909 if (data_size < sizeof(DWORD)) {
2910 WARN("truncated data (%ld bytes)\n", data_size);
2911 goto end;
2912 }
2913 if (*(DWORD*)data != mesh->num_vertices) {
2914 WARN("number of texture coordinates (%u) doesn't match number of vertices (%u)\n",
2915 *(DWORD*)data, mesh->num_vertices);
2916 goto end;
2917 }
2918 data += sizeof(DWORD);
2919 if (data_size < sizeof(DWORD) + mesh->num_vertices * sizeof(*mesh->tex_coords)) {
2920 WARN("truncated data (%ld bytes)\n", data_size);
2921 goto end;
2922 }
2923
2924 mesh->tex_coords = HeapAlloc(GetProcessHeap(), 0, mesh->num_vertices * sizeof(*mesh->tex_coords));
2925 if (!mesh->tex_coords) {
2926 hr = E_OUTOFMEMORY;
2927 goto end;
2928 }
2929 memcpy(mesh->tex_coords, data, mesh->num_vertices * sizeof(*mesh->tex_coords));
2930
2931 mesh->fvf |= D3DFVF_TEX1;
2932
2933 hr = D3D_OK;
2934
2935 end:
2936 filedata->lpVtbl->Unlock(filedata);
2937 return hr;
2938 }
2939
2940 static HRESULT parse_vertex_colors(ID3DXFileData *filedata, struct mesh_data *mesh)
2941 {
2942 HRESULT hr;
2943 SIZE_T data_size;
2944 const BYTE *data;
2945 DWORD num_colors;
2946 DWORD i;
2947
2948 HeapFree(GetProcessHeap(), 0, mesh->vertex_colors);
2949 mesh->vertex_colors = NULL;
2950
2951 hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void**)&data);
2952 if (FAILED(hr)) return hr;
2953
2954 /* template IndexedColor {
2955 * DWORD index;
2956 * ColorRGBA indexColor;
2957 * }
2958 * template MeshVertexColors {
2959 * DWORD nVertexColors;
2960 * array IndexedColor vertexColors[nVertexColors];
2961 * }
2962 */
2963
2964 hr = E_FAIL;
2965
2966 if (data_size < sizeof(DWORD)) {
2967 WARN("truncated data (%ld bytes)\n", data_size);
2968 goto end;
2969 }
2970 num_colors = *(DWORD*)data;
2971 data += sizeof(DWORD);
2972 if (data_size < sizeof(DWORD) + num_colors * (sizeof(DWORD) + sizeof(D3DCOLORVALUE))) {
2973 WARN("truncated data (%ld bytes)\n", data_size);
2974 goto end;
2975 }
2976
2977 mesh->vertex_colors = HeapAlloc(GetProcessHeap(), 0, mesh->num_vertices * sizeof(DWORD));
2978 if (!mesh->vertex_colors) {
2979 hr = E_OUTOFMEMORY;
2980 goto end;
2981 }
2982
2983 for (i = 0; i < mesh->num_vertices; i++)
2984 mesh->vertex_colors[i] = D3DCOLOR_ARGB(0, 0xff, 0xff, 0xff);
2985 for (i = 0; i < num_colors; i++)
2986 {
2987 D3DCOLORVALUE color;
2988 DWORD index = *(DWORD*)data;
2989 data += sizeof(DWORD);
2990 if (index >= mesh->num_vertices) {
2991 WARN("vertex color %u references undefined vertex %u (only %u vertices)\n",
2992 i, index, mesh->num_vertices);
2993 goto end;
2994 }
2995 memcpy(&color, data, sizeof(color));
2996 data += sizeof(color);
2997 color.r = min(1.0f, max(0.0f, color.r));
2998 color.g = min(1.0f, max(0.0f, color.g));
2999 color.b = min(1.0f, max(0.0f, color.b));
3000 color.a = min(1.0f, max(0.0f, color.a));
3001 mesh->vertex_colors[index] = D3DCOLOR_ARGB((BYTE)(color.a * 255.0f + 0.5f),
3002 (BYTE)(color.r * 255.0f + 0.5f),
3003 (BYTE)(color.g * 255.0f + 0.5f),
3004 (BYTE)(color.b * 255.0f + 0.5f));
3005 }
3006
3007 mesh->fvf |= D3DFVF_DIFFUSE;
3008
3009 hr = D3D_OK;
3010
3011 end:
3012 filedata->lpVtbl->Unlock(filedata);
3013 return hr;
3014 }
3015
3016 static HRESULT parse_normals(ID3DXFileData *filedata, struct mesh_data *mesh)
3017 {
3018 HRESULT hr;
3019 SIZE_T data_size;
3020 const BYTE *data;
3021 DWORD *index_out_ptr;
3022 DWORD i;
3023 DWORD num_face_indices = mesh->num_poly_faces * 2 + mesh->num_tri_faces;
3024
3025 HeapFree(GetProcessHeap(), 0, mesh->normals);
3026 mesh->num_normals = 0;
3027 mesh->normals = NULL;
3028 mesh->normal_indices = NULL;
3029 mesh->fvf |= D3DFVF_NORMAL;
3030
3031 hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void**)&data);
3032 if (FAILED(hr)) return hr;
3033
3034 /* template Vector {
3035 * FLOAT x;
3036 * FLOAT y;
3037 * FLOAT z;
3038 * }
3039 * template MeshFace {
3040 * DWORD nFaceVertexIndices;
3041 * array DWORD faceVertexIndices[nFaceVertexIndices];
3042 * }
3043 * template MeshNormals {
3044 * DWORD nNormals;
3045 * array Vector normals[nNormals];
3046 * DWORD nFaceNormals;
3047 * array MeshFace faceNormals[nFaceNormals];
3048 * }
3049 */
3050
3051 hr = E_FAIL;
3052
3053 if (data_size < sizeof(DWORD) * 2) {
3054 WARN("truncated data (%ld bytes)\n", data_size);
3055 goto end;
3056 }
3057 mesh->num_normals = *(DWORD*)data;
3058 data += sizeof(DWORD);
3059 if (data_size < sizeof(DWORD) * 2 + mesh->num_normals * sizeof(D3DXVECTOR3) +
3060 num_face_indices * sizeof(DWORD)) {
3061 WARN("truncated data (%ld bytes)\n", data_size);
3062 goto end;
3063 }
3064
3065 mesh->normals = HeapAlloc(GetProcessHeap(), 0, mesh->num_normals * sizeof(D3DXVECTOR3));
3066 mesh->normal_indices = HeapAlloc(GetProcessHeap(), 0, num_face_indices * sizeof(DWORD));
3067 if (!mesh->normals || !mesh->normal_indices) {
3068 hr = E_OUTOFMEMORY;
3069 goto end;
3070 }
3071
3072 memcpy(mesh->normals, data, mesh->num_normals * sizeof(D3DXVECTOR3));
3073 data += mesh->num_normals * sizeof(D3DXVECTOR3);
3074 for (i = 0; i < mesh->num_normals; i++)
3075 D3DXVec3Normalize(&mesh->normals[i], &mesh->normals[i]);
3076
3077 if (*(DWORD*)data != mesh->num_poly_faces) {
3078 WARN("number of face normals (%u) doesn't match number of faces (%u)\n",
3079 *(DWORD*)data, mesh->num_poly_faces);
3080 goto end;
3081 }
3082 data += sizeof(DWORD);
3083 index_out_ptr = mesh->normal_indices;
3084 for (i = 0; i < mesh->num_poly_faces; i++)
3085 {
3086 DWORD j;
3087 DWORD count = *(DWORD*)data;
3088 if (count != mesh->num_tri_per_face[i] + 2) {
3089 WARN("face %u: number of normals (%u) doesn't match number of vertices (%u)\n",
3090 i, count, mesh->num_tri_per_face[i] + 2);
3091 goto end;
3092 }
3093 data += sizeof(DWORD);
3094
3095 for (j = 0; j < count; j++) {
3096 DWORD normal_index = *(DWORD*)data;
3097 if (normal_index >= mesh->num_normals) {
3098 WARN("face %u, normal index %u: reference to undefined normal %u (only %u normals)\n",
3099 i, j, normal_index, mesh->num_normals);
3100 goto end;
3101 }
3102 *index_out_ptr++ = normal_index;
3103 data += sizeof(DWORD);
3104 }
3105 }
3106
3107 hr = D3D_OK;
3108
3109 end:
3110 filedata->lpVtbl->Unlock(filedata);
3111 return hr;
3112 }
3113
3114 static HRESULT parse_skin_mesh_info(ID3DXFileData *filedata, struct mesh_data *mesh_data, DWORD index)
3115 {
3116 HRESULT hr;
3117 SIZE_T data_size;
3118 const BYTE *data;
3119
3120 TRACE("(%p, %p, %u)\n", filedata, mesh_data, index);
3121
3122 hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void**)&data);
3123 if (FAILED(hr)) return hr;
3124
3125 hr = E_FAIL;
3126
3127 if (!mesh_data->skin_info) {
3128 if (data_size < sizeof(WORD) * 3) {
3129 WARN("truncated data (%ld bytes)\n", data_size);
3130 goto end;
3131 }
3132 /* Skip nMaxSkinWeightsPerVertex and nMaxSkinWeightsPerFace */
3133 data += 2 * sizeof(WORD);
3134 mesh_data->nb_bones = *(WORD*)data;
3135 hr = D3DXCreateSkinInfoFVF(mesh_data->num_vertices, mesh_data->fvf, mesh_data->nb_bones, &mesh_data->skin_info);
3136 } else {
3137 const char *name;
3138 DWORD nb_influences;
3139
3140 /* FIXME: String must be retrieved directly instead of through a pointer once ID3DXFILE is fixed */
3141 name = *(const char**)data;
3142 data += sizeof(char*);
3143
3144 nb_influences = *(DWORD*)data;
3145 data += sizeof(DWORD);
3146
3147 if (data_size < (sizeof(char*) + sizeof(DWORD) + nb_influences * (sizeof(DWORD) + sizeof(FLOAT)) + 16 * sizeof(FLOAT))) {
3148 WARN("truncated data (%ld bytes)\n", data_size);
3149 goto end;
3150 }
3151
3152 hr = mesh_data->skin_info->lpVtbl->SetBoneName(mesh_data->skin_info, index, name);
3153 if (SUCCEEDED(hr))
3154 hr = mesh_data->skin_info->lpVtbl->SetBoneInfluence(mesh_data->skin_info, index, nb_influences,
3155 (const DWORD*)data, (const FLOAT*)(data + nb_influences * sizeof(DWORD)));
3156 if (SUCCEEDED(hr))
3157 hr = mesh_data->skin_info->lpVtbl->SetBoneOffsetMatrix(mesh_data->skin_info, index,
3158 (const D3DMATRIX*)(data + nb_influences * (sizeof(DWORD) + sizeof(FLOAT))));
3159 }
3160
3161 end:
3162 filedata->lpVtbl->Unlock(filedata);
3163 return hr;
3164 }
3165
3166 /* for provide_flags parameters */
3167 #define PROVIDE_MATERIALS 0x1
3168 #define PROVIDE_SKININFO 0x2
3169 #define PROVIDE_ADJACENCY 0x4
3170
3171 static HRESULT parse_mesh(ID3DXFileData *filedata, struct mesh_data *mesh_data, DWORD provide_flags)
3172 {
3173 HRESULT hr;
3174 SIZE_T data_size;
3175 const BYTE *data, *in_ptr;
3176 DWORD *index_out_ptr;
3177 GUID type;
3178 ID3DXFileData *child = NULL;
3179 DWORD i;
3180 SIZE_T nb_children;
3181 DWORD nb_skin_weights_info = 0;
3182
3183 /*
3184 * template Mesh {
3185 * DWORD nVertices;
3186 * array Vector vertices[nVertices];
3187 * DWORD nFaces;
3188 * array MeshFace faces[nFaces];
3189 * [ ... ]
3190 * }
3191 */
3192
3193 hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void**)&data);
3194 if (FAILED(hr)) return hr;
3195
3196 in_ptr = data;
3197 hr = E_FAIL;
3198
3199 if (data_size < sizeof(DWORD) * 2) {
3200 WARN("truncated data (%ld bytes)\n", data_size);
3201 goto end;
3202 }
3203 mesh_data->num_vertices = *(DWORD*)in_ptr;
3204 if (data_size < sizeof(DWORD) * 2 + mesh_data->num_vertices * sizeof(D3DXVECTOR3)) {
3205 WARN("truncated data (%ld bytes)\n", data_size);
3206 goto end;
3207 }
3208 in_ptr += sizeof(DWORD) + mesh_data->num_vertices * sizeof(D3DXVECTOR3);
3209
3210 mesh_data->num_poly_faces = *(DWORD*)in_ptr;
3211 in_ptr += sizeof(DWORD);
3212
3213 mesh_data->num_tri_faces = 0;
3214 for (i = 0; i < mesh_data->num_poly_faces; i++)
3215 {
3216 DWORD num_poly_vertices;
3217 DWORD j;
3218
3219 if (data_size - (in_ptr - data) < sizeof(DWORD)) {
3220 WARN("truncated data (%ld bytes)\n", data_size);
3221 goto end;
3222 }
3223 num_poly_vertices = *(DWORD*)in_ptr;
3224 in_ptr += sizeof(DWORD);
3225 if (data_size - (in_ptr - data) < num_poly_vertices * sizeof(DWORD)) {
3226 WARN("truncated data (%ld bytes)\n", data_size);
3227 goto end;
3228 }
3229 if (num_poly_vertices < 3) {
3230 WARN("face %u has only %u vertices\n", i, num_poly_vertices);
3231 goto end;
3232 }
3233 for (j = 0; j < num_poly_vertices; j++) {
3234 if (*(DWORD*)in_ptr >= mesh_data->num_vertices) {
3235 WARN("face %u, index %u: undefined vertex %u (only %u vertices)\n",
3236 i, j, *(DWORD*)in_ptr, mesh_data->num_vertices);
3237 goto end;
3238 }
3239 in_ptr += sizeof(DWORD);
3240 }
3241 mesh_data->num_tri_faces += num_poly_vertices - 2;
3242 }
3243
3244 mesh_data->fvf = D3DFVF_XYZ;
3245
3246 mesh_data->vertices = HeapAlloc(GetProcessHeap(), 0,
3247 mesh_data->num_vertices * sizeof(*mesh_data->vertices));
3248 mesh_data->num_tri_per_face = HeapAlloc(GetProcessHeap(), 0,
3249 mesh_data->num_poly_faces * sizeof(*mesh_data->num_tri_per_face));
3250 mesh_data->indices = HeapAlloc(GetProcessHeap(), 0,
3251 (mesh_data->num_tri_faces + mesh_data->num_poly_faces * 2) * sizeof(*mesh_data->indices));
3252 if (!mesh_data->vertices || !mesh_data->num_tri_per_face || !mesh_data->indices) {
3253 hr = E_OUTOFMEMORY;
3254 goto end;
3255 }
3256
3257 in_ptr = data + sizeof(DWORD);
3258 memcpy(mesh_data->vertices, in_ptr, mesh_data->num_vertices * sizeof(D3DXVECTOR3));
3259 in_ptr += mesh_data->num_vertices * sizeof(D3DXVECTOR3) + sizeof(DWORD);
3260
3261 index_out_ptr = mesh_data->indices;
3262 for (i = 0; i < mesh_data->num_poly_faces; i++)
3263 {
3264 DWORD count;
3265
3266 count = *(DWORD*)in_ptr;
3267 in_ptr += sizeof(DWORD);
3268 mesh_data->num_tri_per_face[i] = count - 2;
3269
3270 while (count--) {
3271 *index_out_ptr++ = *(DWORD*)in_ptr;
3272 in_ptr += sizeof(DWORD);
3273 }
3274 }
3275
3276 hr = filedata->lpVtbl->GetChildren(filedata, &nb_children);
3277 if (FAILED(hr))
3278 goto end;
3279
3280 for (i = 0; i < nb_children; i++)
3281 {
3282 hr = filedata->lpVtbl->GetChild(filedata, i, &child);
3283 if (FAILED(hr))
3284 goto end;
3285 hr = child->lpVtbl->GetType(child, &type);
3286 if (FAILED(hr))
3287 goto end;
3288
3289 if (IsEqualGUID(&type, &TID_D3DRMMeshNormals)) {
3290 hr = parse_normals(child, mesh_data);
3291 } else if (IsEqualGUID(&type, &TID_D3DRMMeshVertexColors)) {
3292 hr = parse_vertex_colors(child, mesh_data);
3293 } else if (IsEqualGUID(&type, &TID_D3DRMMeshTextureCoords)) {
3294 hr = parse_texture_coords(child, mesh_data);
3295 } else if (IsEqualGUID(&type, &TID_D3DRMMeshMaterialList) &&
3296 (provide_flags & PROVIDE_MATERIALS))
3297 {
3298 hr = parse_material_list(child, mesh_data);
3299 } else if (provide_flags & PROVIDE_SKININFO) {
3300 if (IsEqualGUID(&type, &DXFILEOBJ_XSkinMeshHeader)) {
3301 if (mesh_data->skin_info) {
3302 WARN("Skin mesh header already encountered\n");
3303 hr = E_FAIL;
3304 goto end;
3305 }
3306 hr = parse_skin_mesh_info(child, mesh_data, 0);
3307 if (FAILED(hr))
3308 goto end;
3309 } else if (IsEqualGUID(&type, &DXFILEOBJ_SkinWeights)) {
3310 if (!mesh_data->skin_info) {
3311 WARN("Skin weights found but skin mesh header not encountered yet\n");
3312 hr = E_FAIL;
3313 goto end;
3314 }
3315 hr = parse_skin_mesh_info(child, mesh_data, nb_skin_weights_info);
3316 if (FAILED(hr))
3317 goto end;
3318 nb_skin_weights_info++;
3319 }
3320 }
3321 if (FAILED(hr))
3322 goto end;
3323
3324 IUnknown_Release(child);
3325 child = NULL;
3326 }
3327
3328 if (mesh_data->skin_info && (nb_skin_weights_info != mesh_data->nb_bones)) {
3329 WARN("Mismatch between nb skin weights info %u encountered and nb bones %u from skin mesh header\n",
3330 nb_skin_weights_info, mesh_data->nb_bones);
3331 hr = E_FAIL;
3332 goto end;
3333 }
3334
3335 hr = D3D_OK;
3336
3337 end:
3338 if (child)
3339 IUnknown_Release(child);
3340 filedata->lpVtbl->Unlock(filedata);
3341 return hr;
3342 }
3343
3344 static HRESULT generate_effects(ID3DXBuffer *materials, DWORD num_materials,
3345 ID3DXBuffer **effects)
3346 {
3347 HRESULT hr;
3348 D3DXEFFECTINSTANCE *effect_ptr;
3349 BYTE *out_ptr;
3350 const D3DXMATERIAL *material_ptr = ID3DXBuffer_GetBufferPointer(materials);
3351 static const struct {
3352 const char *param_name;
3353 DWORD name_size;
3354 DWORD num_bytes;
3355 DWORD value_offset;
3356 } material_effects[] = {
3357 #define EFFECT_TABLE_ENTRY(str, field) \
3358 {str, sizeof(str), sizeof(material_ptr->MatD3D.field), offsetof(D3DXMATERIAL, MatD3D.field)}
3359 EFFECT_TABLE_ENTRY("Diffuse", Diffuse),
3360 EFFECT_TABLE_ENTRY("Power", Power),
3361 EFFECT_TABLE_ENTRY("Specular", Specular),
3362 EFFECT_TABLE_ENTRY("Emissive", Emissive),
3363 EFFECT_TABLE_ENTRY("Ambient", Ambient),
3364 #undef EFFECT_TABLE_ENTRY
3365 };
3366 static const char texture_paramname[] = "Texture0@Name";
3367 DWORD buffer_size;
3368 DWORD i;
3369
3370 /* effects buffer layout:
3371 *
3372 * D3DXEFFECTINSTANCE effects[num_materials];
3373 * for (effect in effects)
3374 * {
3375 * D3DXEFFECTDEFAULT defaults[effect.NumDefaults];
3376 * for (default in defaults)
3377 * {
3378 * *default.pParamName;
3379 * *default.pValue;
3380 * }
3381 * }
3382 */
3383 buffer_size = sizeof(D3DXEFFECTINSTANCE);
3384 buffer_size += sizeof(D3DXEFFECTDEFAULT) * ARRAY_SIZE(material_effects);
3385 for (i = 0; i < ARRAY_SIZE(material_effects); i++) {
3386 buffer_size += material_effects[i].name_size;
3387 buffer_size += material_effects[i].num_bytes;
3388 }
3389 buffer_size *= num_materials;
3390 for (i = 0; i < num_materials; i++) {
3391 if (material_ptr[i].pTextureFilename) {
3392 buffer_size += sizeof(D3DXEFFECTDEFAULT);
3393 buffer_size += sizeof(texture_paramname);
3394 buffer_size += strlen(material_ptr[i].pTextureFilename) + 1;
3395 }
3396 }
3397
3398 hr = D3DXCreateBuffer(buffer_size, effects);
3399 if (FAILED(hr)) return hr;
3400 effect_ptr = ID3DXBuffer_GetBufferPointer(*effects);
3401 out_ptr = (BYTE*)(effect_ptr + num_materials);
3402
3403 for (i = 0; i < num_materials; i++)
3404 {
3405 DWORD j;
3406 D3DXEFFECTDEFAULT *defaults = (D3DXEFFECTDEFAULT*)out_ptr;
3407
3408 effect_ptr->pDefaults = defaults;
3409 effect_ptr->NumDefaults = material_ptr->pTextureFilename ? 6 : 5;
3410 out_ptr = (BYTE*)(effect_ptr->pDefaults + effect_ptr->NumDefaults);
3411
3412 for (j = 0; j < ARRAY_SIZE(material_effects); j++)
3413 {
3414 defaults->pParamName = (char *)out_ptr;
3415 strcpy(defaults->pParamName, material_effects[j].param_name);
3416 defaults->pValue = defaults->pParamName + material_effects[j].name_size;
3417 defaults->Type = D3DXEDT_FLOATS;
3418 defaults->NumBytes = material_effects[j].num_bytes;
3419 memcpy(defaults->pValue, (BYTE*)material_ptr + material_effects[j].value_offset, defaults->NumBytes);
3420 out_ptr = (BYTE*)defaults->pValue + defaults->NumBytes;
3421 defaults++;
3422 }
3423
3424 if (material_ptr->pTextureFilename)
3425 {
3426 defaults->pParamName = (char *)out_ptr;
3427 strcpy(defaults->pParamName, texture_paramname);
3428 defaults->pValue = defaults->pParamName + sizeof(texture_paramname);
3429 defaults->Type = D3DXEDT_STRING;
3430 defaults->NumBytes = strlen(material_ptr->pTextureFilename) + 1;
3431 strcpy(defaults->pValue, material_ptr->pTextureFilename);
3432 out_ptr = (BYTE*)defaults->pValue + defaults->NumBytes;
3433 }
3434 material_ptr++;
3435 effect_ptr++;
3436 }
3437 assert(out_ptr - (BYTE*)ID3DXBuffer_GetBufferPointer(*effects) == buffer_size);
3438
3439 return D3D_OK;
3440 }
3441
3442 HRESULT WINAPI D3DXLoadSkinMeshFromXof(struct ID3DXFileData *filedata, DWORD options,
3443 struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency_out, struct ID3DXBuffer **materials_out,
3444 struct ID3DXBuffer **effects_out, DWORD *num_materials_out, struct ID3DXSkinInfo **skin_info_out,
3445 struct ID3DXMesh **mesh_out)
3446 {
3447 HRESULT hr;
3448 DWORD *index_in_ptr;
3449 struct mesh_data mesh_data;
3450 DWORD total_vertices;
3451 ID3DXMesh *d3dxmesh = NULL;
3452 ID3DXBuffer *adjacency = NULL;
3453 ID3DXBuffer *materials = NULL;
3454 ID3DXBuffer *effects = NULL;
3455 struct vertex_duplication {
3456 DWORD normal_index;
3457 struct list entry;
3458 } *duplications = NULL;
3459 DWORD i;
3460 void *vertices = NULL;
3461 void *indices = NULL;
3462 BYTE *out_ptr;
3463 DWORD provide_flags = 0;
3464
3465 TRACE("(%p, %x, %p, %p, %p, %p, %p, %p, %p)\n", filedata, options, device, adjacency_out, materials_out,
3466 effects_out, num_materials_out, skin_info_out, mesh_out);
3467
3468 ZeroMemory(&mesh_data, sizeof(mesh_data));
3469
3470 if (num_materials_out || materials_out || effects_out)
3471 provide_flags |= PROVIDE_MATERIALS;
3472 if (skin_info_out)
3473 provide_flags |= PROVIDE_SKININFO;
3474
3475 hr = parse_mesh(filedata, &mesh_data, provide_flags);
3476 if (FAILED(hr)) goto cleanup;
3477
3478 total_vertices = mesh_data.num_vertices;
3479 if (mesh_data.fvf & D3DFVF_NORMAL) {
3480 /* duplicate vertices with multiple normals */
3481 DWORD num_face_indices = mesh_data.num_poly_faces * 2 + mesh_data.num_tri_faces;
3482 duplications = HeapAlloc(GetProcessHeap(), 0, (mesh_data.num_vertices + num_face_indices) * sizeof(*duplications));
3483 if (!duplications) {
3484 hr = E_OUTOFMEMORY;
3485 goto cleanup;
3486 }
3487 for (i = 0; i < total_vertices; i++)
3488 {
3489 duplications[i].normal_index = -1;
3490 list_init(&duplications[i].entry);
3491 }
3492 for (i = 0; i < num_face_indices; i++) {
3493 DWORD vertex_index = mesh_data.indices[i];
3494 DWORD normal_index = mesh_data.normal_indices[i];
3495 struct vertex_duplication *dup_ptr = &duplications[vertex_index];
3496
3497 if (dup_ptr->normal_index == -1) {
3498 dup_ptr->normal_index = normal_index;
3499 } else {
3500 D3DXVECTOR3 *new_normal = &mesh_data.normals[normal_index];
3501 struct list *dup_list = &dup_ptr->entry;
3502 while (TRUE) {
3503 D3DXVECTOR3 *cur_normal = &mesh_data.normals[dup_ptr->normal_index];
3504 if (new_normal->x == cur_normal->x &&
3505 new_normal->y == cur_normal->y &&
3506 new_normal->z == cur_normal->z)
3507 {
3508 mesh_data.indices[i] = dup_ptr - duplications;
3509 break;
3510 } else if (!list_next(dup_list, &dup_ptr->entry)) {
3511 dup_ptr = &duplications[total_vertices++];
3512 dup_ptr->normal_index = normal_index;
3513 list_add_tail(dup_list, &dup_ptr->entry);
3514 mesh_data.indices[i] = dup_ptr - duplications;
3515 break;
3516 } else {
3517 dup_ptr = LIST_ENTRY(list_next(dup_list, &dup_ptr->entry),
3518 struct vertex_duplication, entry);
3519 }
3520 }
3521 }
3522 }
3523 }
3524
3525 hr = D3DXCreateMeshFVF(mesh_data.num_tri_faces, total_vertices, options, mesh_data.fvf, device, &d3dxmesh);
3526 if (FAILED(hr)) goto cleanup;
3527
3528 hr = d3dxmesh->lpVtbl->LockVertexBuffer(d3dxmesh, 0, &vertices);
3529 if (FAILED(hr)) goto cleanup;
3530
3531 out_ptr = vertices;
3532 for (i = 0; i < mesh_data.num_vertices; i++) {
3533 *(D3DXVECTOR3*)out_ptr = mesh_data.vertices[i];
3534 out_ptr += sizeof(D3DXVECTOR3);
3535 if (mesh_data.fvf & D3DFVF_NORMAL) {
3536 if (duplications[i].normal_index == -1)
3537 ZeroMemory(out_ptr, sizeof(D3DXVECTOR3));
3538 else
3539 *(D3DXVECTOR3*)out_ptr = mesh_data.normals[duplications[i].normal_index];
3540 out_ptr += sizeof(D3DXVECTOR3);
3541 }
3542 if (mesh_data.fvf & D3DFVF_DIFFUSE) {
3543 *(DWORD*)out_ptr = mesh_data.vertex_colors[i];
3544 out_ptr += sizeof(DWORD);
3545 }
3546 if (mesh_data.fvf & D3DFVF_TEX1) {
3547 *(D3DXVECTOR2*)out_ptr = mesh_data.tex_coords[i];
3548 out_ptr += sizeof(D3DXVECTOR2);
3549 }
3550 }
3551 if (mesh_data.fvf & D3DFVF_NORMAL) {
3552 DWORD vertex_size = D3DXGetFVFVertexSize(mesh_data.fvf);
3553 out_ptr = vertices;
3554 for (i = 0; i < mesh_data.num_vertices; i++) {
3555 struct vertex_duplication *dup_ptr;
3556 LIST_FOR_EACH_ENTRY(dup_ptr, &duplications[i].entry, struct vertex_duplication, entry)
3557 {
3558 int j = dup_ptr - duplications;
3559 BYTE *dest_vertex = (BYTE*)vertices + j * vertex_size;
3560
3561 memcpy(dest_vertex, out_ptr, vertex_size);
3562 dest_vertex += sizeof(D3DXVECTOR3);
3563 *(D3DXVECTOR3*)dest_vertex = mesh_data.normals[dup_ptr->normal_index];
3564 }
3565 out_ptr += vertex_size;
3566 }
3567 }
3568 d3dxmesh->lpVtbl->UnlockVertexBuffer(d3dxmesh);
3569
3570 hr = d3dxmesh->lpVtbl->LockIndexBuffer(d3dxmesh, 0, &indices);
3571 if (FAILED(hr)) goto cleanup;
3572
3573 index_in_ptr = mesh_data.indices;
3574 #define FILL_INDEX_BUFFER(indices_var) \
3575 for (i = 0; i < mesh_data.num_poly_faces; i++) \
3576 { \
3577 DWORD count = mesh_data.num_tri_per_face[i]; \
3578 WORD first_index = *index_in_ptr++; \
3579 while (count--) { \
3580 *indices_var++ = first_index; \
3581 *indices_var++ = *index_in_ptr; \
3582 index_in_ptr++; \
3583 *indices_var++ = *index_in_ptr; \
3584 } \
3585 index_in_ptr++; \
3586 }
3587 if (options & D3DXMESH_32BIT) {
3588 DWORD *dword_indices = indices;
3589 FILL_INDEX_BUFFER(dword_indices)
3590 } else {
3591 WORD *word_indices = indices;
3592 FILL_INDEX_BUFFER(word_indices)
3593 }
3594 #undef FILL_INDEX_BUFFER
3595 d3dxmesh->lpVtbl->UnlockIndexBuffer(d3dxmesh);
3596
3597 if (mesh_data.material_indices) {
3598 DWORD *attrib_buffer = NULL;
3599 hr = d3dxmesh->lpVtbl->LockAttributeBuffer(d3dxmesh, 0, &attrib_buffer);
3600 if (FAILED(hr)) goto cleanup;
3601 for (i = 0; i < mesh_data.num_poly_faces; i++)
3602 {
3603 DWORD count = mesh_data.num_tri_per_face[i];
3604 while (count--)
3605 *attrib_buffer++ = mesh_data.material_indices[i];
3606 }
3607 d3dxmesh->lpVtbl->UnlockAttributeBuffer(d3dxmesh);
3608
3609 hr = d3dxmesh->lpVtbl->OptimizeInplace(d3dxmesh,
3610 D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_IGNOREVERTS | D3DXMESHOPT_DONOTSPLIT,
3611 NULL, NULL, NULL, NULL);
3612 if (FAILED(hr)) goto cleanup;
3613 }
3614
3615 if (mesh_data.num_materials && (materials_out || effects_out)) {
3616 DWORD buffer_size = mesh_data.num_materials * sizeof(D3DXMATERIAL);
3617 char *strings_out_ptr;
3618 D3DXMATERIAL *materials_ptr;
3619
3620 for (i = 0; i < mesh_data.num_materials; i++) {
3621 if (mesh_data.materials[i].pTextureFilename)
3622 buffer_size += strlen(mesh_data.materials[i].pTextureFilename) + 1;
3623 }
3624
3625 hr = D3DXCreateBuffer(buffer_size, &materials);
3626 if (FAILED(hr)) goto cleanup;
3627
3628 materials_ptr = ID3DXBuffer_GetBufferPointer(materials);
3629 memcpy(materials_ptr, mesh_data.materials, mesh_data.num_materials * sizeof(D3DXMATERIAL));
3630 strings_out_ptr = (char*)(materials_ptr + mesh_data.num_materials);
3631 for (i = 0; i < mesh_data.num_materials; i++) {
3632 if (materials_ptr[i].pTextureFilename) {
3633 strcpy(strings_out_ptr, mesh_data.materials[i].pTextureFilename);
3634 materials_ptr[i].pTextureFilename = strings_out_ptr;
3635 strings_out_ptr += strlen(mesh_data.materials[i].pTextureFilename) + 1;
3636 }
3637 }
3638 }
3639
3640 if (mesh_data.num_materials && effects_out) {
3641 hr = generate_effects(materials, mesh_data.num_materials, &effects);
3642 if (FAILED(hr)) goto cleanup;
3643
3644 if (!materials_out) {
3645 ID3DXBuffer_Release(materials);
3646 materials = NULL;
3647 }
3648 }
3649
3650 if (adjacency_out) {
3651 hr = D3DXCreateBuffer(mesh_data.num_tri_faces * 3 * sizeof(DWORD), &adjacency);
3652 if (FAILED(hr)) goto cleanup;
3653 hr = d3dxmesh->lpVtbl->GenerateAdjacency(d3dxmesh, 0.0f, ID3DXBuffer_GetBufferPointer(adjacency));
3654 if (FAILED(hr)) goto cleanup;
3655 }
3656
3657 *mesh_out = d3dxmesh;
3658 if (adjacency_out) *adjacency_out = adjacency;
3659 if (num_materials_out) *num_materials_out = mesh_data.num_materials;
3660 if (materials_out) *materials_out = materials;
3661 if (effects_out) *effects_out = effects;
3662 if (skin_info_out) *skin_info_out = mesh_data.skin_info;
3663
3664 hr = D3D_OK;
3665 cleanup:
3666 if (FAILED(hr)) {
3667 if (d3dxmesh) IUnknown_Release(d3dxmesh);
3668 if (adjacency) ID3DXBuffer_Release(adjacency);
3669 if (materials) ID3DXBuffer_Release(materials);
3670 if (effects) ID3DXBuffer_Release(effects);
3671 if (mesh_data.skin_info) mesh_data.skin_info->lpVtbl->Release(mesh_data.skin_info);
3672 if (skin_info_out) *skin_info_out = NULL;
3673 }
3674 HeapFree(GetProcessHeap(), 0, mesh_data.vertices);
3675 HeapFree(GetProcessHeap(), 0, mesh_data.num_tri_per_face);
3676 HeapFree(GetProcessHeap(), 0, mesh_data.indices);
3677 HeapFree(GetProcessHeap(), 0, mesh_data.normals);
3678 HeapFree(GetProcessHeap(), 0, mesh_data.normal_indices);
3679 destroy_materials(&mesh_data);
3680 HeapFree(GetProcessHeap(), 0, mesh_data.tex_coords);
3681 HeapFree(GetProcessHeap(), 0, mesh_data.vertex_colors);
3682 HeapFree(GetProcessHeap(), 0, duplications);
3683 return hr;
3684 }
3685
3686 HRESULT WINAPI D3DXLoadMeshHierarchyFromXA(const char *filename, DWORD options, struct IDirect3DDevice9 *device,
3687 struct ID3DXAllocateHierarchy *alloc_hier, struct ID3DXLoadUserData *load_user_data,
3688 D3DXFRAME **frame_hierarchy, struct ID3DXAnimationController **anim_controller)
3689 {
3690 WCHAR *filenameW;
3691 HRESULT hr;
3692 int len;
3693
3694 TRACE("filename %s, options %#x, device %p, alloc_hier %p, "
3695 "load_user_data %p, frame_hierarchy %p, anim_controller %p.\n",
3696 debugstr_a(filename), options, device, alloc_hier,
3697 load_user_data, frame_hierarchy, anim_controller);
3698
3699 if (!filename)
3700 return D3DERR_INVALIDCALL;
3701
3702 len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
3703 filenameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3704 if (!filenameW) return E_OUTOFMEMORY;
3705 MultiByteToWideChar(CP_ACP, 0, filename, -1, filenameW, len);
3706
3707 hr = D3DXLoadMeshHierarchyFromXW(filenameW, options, device,
3708 alloc_hier, load_user_data, frame_hierarchy, anim_controller);
3709 HeapFree(GetProcessHeap(), 0, filenameW);
3710
3711 return hr;
3712 }
3713
3714 HRESULT WINAPI D3DXLoadMeshHierarchyFromXW(const WCHAR *filename, DWORD options, struct IDirect3DDevice9 *device,
3715 struct ID3DXAllocateHierarchy *alloc_hier, struct ID3DXLoadUserData *load_user_data,
3716 D3DXFRAME **frame_hierarchy, struct ID3DXAnimationController **anim_controller)
3717 {
3718 void *buffer;
3719 HRESULT hr;
3720 DWORD size;
3721
3722 TRACE("filename %s, options %#x, device %p, alloc_hier %p, "
3723 "load_user_data %p, frame_hierarchy %p, anim_controller %p.\n",
3724 debugstr_w(filename), options, device, alloc_hier,
3725 load_user_data, frame_hierarchy, anim_controller);
3726
3727 if (!filename)
3728 return D3DERR_INVALIDCALL;
3729
3730 hr = map_view_of_file(filename, &buffer, &size);
3731 if (FAILED(hr))
3732 return D3DXERR_INVALIDDATA;
3733
3734 hr = D3DXLoadMeshHierarchyFromXInMemory(buffer, size, options, device,
3735 alloc_hier, load_user_data, frame_hierarchy, anim_controller);
3736
3737 UnmapViewOfFile(buffer);
3738
3739 return hr;
3740 }
3741
3742 static HRESULT filedata_get_name(ID3DXFileData *filedata, char **name)
3743 {
3744 HRESULT hr;
3745 SIZE_T name_len;
3746
3747 hr = filedata->lpVtbl->GetName(filedata, NULL, &name_len);
3748 if (FAILED(hr)) return hr;
3749
3750 if (!name_len)
3751 name_len++;
3752 *name = HeapAlloc(GetProcessHeap(), 0, name_len);
3753 if (!*name) return E_OUTOFMEMORY;
3754
3755 hr = filedata->lpVtbl->GetName(filedata, *name, &name_len);
3756 if (FAILED(hr))
3757 HeapFree(GetProcessHeap(), 0, *name);
3758 else if (!name_len)
3759 (*name)[0] = 0;
3760
3761 return hr;
3762 }
3763
3764 static HRESULT load_mesh_container(struct ID3DXFileData *filedata, DWORD options, struct IDirect3DDevice9 *device,
3765 struct ID3DXAllocateHierarchy *alloc_hier, D3DXMESHCONTAINER **mesh_container)
3766 {
3767 HRESULT hr;
3768 ID3DXBuffer *adjacency = NULL;
3769 ID3DXBuffer *materials = NULL;
3770 ID3DXBuffer *effects = NULL;
3771 ID3DXSkinInfo *skin_info = NULL;
3772 D3DXMESHDATA mesh_data;
3773 DWORD num_materials = 0;
3774 char *name = NULL;
3775
3776 mesh_data.Type = D3DXMESHTYPE_MESH;
3777 mesh_data.u.pMesh = NULL;
3778
3779 hr = D3DXLoadSkinMeshFromXof(filedata, options, device,
3780 &adjacency, &materials, &effects, &num_materials,
3781 &skin_info, &mesh_data.u.pMesh);
3782 if (FAILED(hr)) return hr;
3783
3784 hr = filedata_get_name(filedata, &name);
3785 if (FAILED(hr)) goto cleanup;
3786
3787 hr = alloc_hier->lpVtbl->CreateMeshContainer(alloc_hier, name, &mesh_data,
3788 materials ? ID3DXBuffer_GetBufferPointer(materials) : NULL,
3789 effects ? ID3DXBuffer_GetBufferPointer(effects) : NULL,
3790 num_materials,
3791 adjacency ? ID3DXBuffer_GetBufferPointer(adjacency) : NULL,
3792 skin_info, mesh_container);
3793
3794 cleanup:
3795 if (materials) ID3DXBuffer_Release(materials);
3796 if (effects) ID3DXBuffer_Release(effects);
3797 if (adjacency) ID3DXBuffer_Release(adjacency);
3798 if (skin_info) IUnknown_Release(skin_info);
3799 if (mesh_data.u.pMesh) IUnknown_Release(mesh_data.u.pMesh);
3800 HeapFree(GetProcessHeap(), 0, name);
3801 return hr;
3802 }
3803
3804 static HRESULT parse_transform_matrix(ID3DXFileData *filedata, D3DXMATRIX *transform)
3805 {
3806 HRESULT hr;
3807 SIZE_T data_size;
3808 const BYTE *data;
3809
3810 /* template Matrix4x4 {
3811 * array FLOAT matrix[16];
3812 * }
3813 * template FrameTransformMatrix {
3814 * Matrix4x4 frameMatrix;
3815 * }
3816 */
3817
3818 hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void**)&data);
3819 if (FAILED(hr)) return hr;
3820
3821 if (data_size != sizeof(D3DXMATRIX)) {
3822 WARN("incorrect data size (%ld bytes)\n", data_size);
3823 filedata->lpVtbl->Unlock(filedata);
3824 return E_FAIL;
3825 }
3826
3827 memcpy(transform, data, sizeof(D3DXMATRIX));
3828
3829 filedata->lpVtbl->Unlock(filedata);
3830 return D3D_OK;
3831 }
3832
3833 static HRESULT load_frame(struct ID3DXFileData *filedata, DWORD options, struct IDirect3DDevice9 *device,
3834 struct ID3DXAllocateHierarchy *alloc_hier, D3DXFRAME **frame_out)
3835 {
3836 HRESULT hr;
3837 GUID type;
3838 ID3DXFileData *child;
3839 char *name = NULL;
3840 D3DXFRAME *frame = NULL;
3841 D3DXMESHCONTAINER **next_container;
3842 D3DXFRAME **next_child;
3843 SIZE_T i, nb_children;
3844
3845 hr = filedata_get_name(filedata, &name);
3846 if (FAILED(hr)) return hr;
3847
3848 hr = alloc_hier->lpVtbl->CreateFrame(alloc_hier, name, frame_out);
3849 HeapFree(GetProcessHeap(), 0, name);
3850 if (FAILED(hr)) return E_FAIL;
3851
3852 frame = *frame_out;
3853 D3DXMatrixIdentity(&frame->TransformationMatrix);
3854 next_child = &frame->pFrameFirstChild;
3855 next_container = &frame->pMeshContainer;
3856
3857 hr = filedata->lpVtbl->GetChildren(filedata, &nb_children);
3858 if (FAILED(hr))
3859 return hr;
3860
3861 for (i = 0; i < nb_children; i++)
3862 {
3863 hr = filedata->lpVtbl->GetChild(filedata, i, &child);
3864 if (FAILED(hr))
3865 return hr;
3866 hr = child->lpVtbl->GetType(child, &type);
3867 if (FAILED(hr))
3868 goto err;
3869
3870 if (IsEqualGUID(&type, &TID_D3DRMMesh)) {
3871 hr = load_mesh_container(child, options, device, alloc_hier, next_container);
3872 if (SUCCEEDED(hr))
3873 next_container = &(*next_container)->pNextMeshContainer;
3874 } else if (IsEqualGUID(&type, &TID_D3DRMFrameTransformMatrix)) {
3875 hr = parse_transform_matrix(child, &frame->TransformationMatrix);
3876 } else if (IsEqualGUID(&type, &TID_D3DRMFrame)) {
3877 hr = load_frame(child, options, device, alloc_hier, next_child);
3878 if (SUCCEEDED(hr))
3879 next_child = &(*next_child)->pFrameSibling;
3880 }
3881 if (FAILED(hr))
3882 goto err;
3883
3884 IUnknown_Release(child);
3885 }
3886 return D3D_OK;
3887
3888 err:
3889 IUnknown_Release(child);
3890 return hr;
3891 }
3892
3893 HRESULT WINAPI D3DXLoadMeshHierarchyFromXInMemory(const void *memory, DWORD memory_size, DWORD options,
3894 struct IDirect3DDevice9 *device, struct ID3DXAllocateHierarchy *alloc_hier,
3895 struct ID3DXLoadUserData *load_user_data, D3DXFRAME **frame_hierarchy,
3896 struct ID3DXAnimationController **anim_controller)
3897 {
3898 HRESULT hr;
3899 ID3DXFile *d3dxfile = NULL;
3900 ID3DXFileEnumObject *enumobj = NULL;
3901 ID3DXFileData *filedata = NULL;
3902 D3DXF_FILELOADMEMORY source;
3903 D3DXFRAME *first_frame = NULL;
3904 D3DXFRAME **next_frame = &first_frame;
3905 SIZE_T i, nb_children;
3906 GUID guid;
3907
3908 TRACE("(%p, %u, %x, %p, %p, %p, %p, %p)\n", memory, memory_size, options,
3909 device, alloc_hier, load_user_data, frame_hierarchy, anim_controller);
3910
3911 if (!memory || !memory_size || !device || !frame_hierarchy || !alloc_hier)
3912 return D3DERR_INVALIDCALL;
3913 if (load_user_data)
3914 {
3915 FIXME("Loading user data not implemented.\n");
3916 return E_NOTIMPL;
3917 }
3918
3919 hr = D3DXFileCreate(&d3dxfile);
3920 if (FAILED(hr)) goto cleanup;
3921
3922 hr = d3dxfile->lpVtbl->RegisterTemplates(d3dxfile, D3DRM_XTEMPLATES, D3DRM_XTEMPLATE_BYTES);
3923 if (FAILED(hr)) goto cleanup;
3924
3925 source.lpMemory = (void*)memory;
3926 source.dSize = memory_size;
3927 hr = d3dxfile->lpVtbl->CreateEnumObject(d3dxfile, &source, D3DXF_FILELOAD_FROMMEMORY, &enumobj);
3928 if (FAILED(hr)) goto cleanup;
3929
3930 hr = enumobj->lpVtbl->GetChildren(enumobj, &nb_children);
3931 if (FAILED(hr))
3932 goto cleanup;
3933
3934 for (i = 0; i < nb_children; i++)
3935 {
3936 hr = enumobj->lpVtbl->GetChild(enumobj, i, &filedata);
3937 if (FAILED(hr))
3938 goto cleanup;
3939
3940 hr = filedata->lpVtbl->GetType(filedata, &guid);
3941 if (SUCCEEDED(hr)) {
3942 if (IsEqualGUID(&guid, &TID_D3DRMMesh)) {
3943 hr = alloc_hier->lpVtbl->CreateFrame(alloc_hier, NULL, next_frame);
3944 if (FAILED(hr)) {
3945 hr = E_FAIL;
3946 goto cleanup;
3947 }
3948
3949 D3DXMatrixIdentity(&(*next_frame)->TransformationMatrix);
3950
3951 hr = load_mesh_container(filedata, options, device, alloc_hier, &(*next_frame)->pMeshContainer);
3952 if (FAILED(hr)) goto cleanup;
3953 } else if (IsEqualGUID(&guid, &TID_D3DRMFrame)) {
3954 hr = load_frame(filedata, options, device, alloc_hier, next_frame);
3955 if (FAILED(hr)) goto cleanup;
3956 }
3957 while (*next_frame)
3958 next_frame = &(*next_frame)->pFrameSibling;
3959 }
3960
3961 filedata->lpVtbl->Release(filedata);
3962 filedata = NULL;
3963 if (FAILED(hr))
3964 goto cleanup;
3965 }
3966
3967 if (!first_frame) {
3968 hr = E_FAIL;
3969 } else if (first_frame->pFrameSibling) {
3970 D3DXFRAME *root_frame = NULL;
3971 hr = alloc_hier->lpVtbl->CreateFrame(alloc_hier, NULL, &root_frame);
3972 if (FAILED(hr)) {
3973 hr = E_FAIL;
3974 goto cleanup;
3975 }
3976 D3DXMatrixIdentity(&root_frame->TransformationMatrix);
3977 root_frame->pFrameFirstChild = first_frame;
3978 *frame_hierarchy = root_frame;
3979 hr = D3D_OK;
3980 } else {
3981 *frame_hierarchy = first_frame;
3982 hr = D3D_OK;
3983 }
3984
3985 if (anim_controller)
3986 {
3987 *anim_controller = NULL;
3988 FIXME("Animation controller creation not implemented.\n");
3989 }
3990
3991 cleanup:
3992 if (FAILED(hr) && first_frame) D3DXFrameDestroy(first_frame, alloc_hier);
3993 if (filedata) filedata->lpVtbl->Release(filedata);
3994 if (enumobj) enumobj->lpVtbl->Release(enumobj);
3995 if (d3dxfile) d3dxfile->lpVtbl->Release(d3dxfile);
3996 return hr;
3997 }
3998
3999 HRESULT WINAPI D3DXCleanMesh(D3DXCLEANTYPE clean_type, ID3DXMesh *mesh_in, const DWORD *adjacency_in,
4000 ID3DXMesh **mesh_out, DWORD *adjacency_out, ID3DXBuffer **errors_and_warnings)
4001 {
4002 FIXME("(%u, %p, %p, %p, %p, %p)\n", clean_type, mesh_in, adjacency_in, mesh_out, adjacency_out, errors_and_warnings);
4003
4004 return E_NOTIMPL;
4005 }
4006
4007 HRESULT WINAPI D3DXFrameDestroy(D3DXFRAME *frame, ID3DXAllocateHierarchy *alloc_hier)
4008 {
4009 HRESULT hr;
4010 BOOL last = FALSE;
4011
4012 TRACE("(%p, %p)\n", frame, alloc_hier);
4013
4014 if (!frame || !alloc_hier)
4015 return D3DERR_INVALIDCALL;
4016
4017 while (!last) {
4018 D3DXMESHCONTAINER *container;
4019 D3DXFRAME *current_frame;
4020
4021 if (frame->pFrameSibling) {
4022 current_frame = frame->pFrameSibling;
4023 frame->pFrameSibling = current_frame->pFrameSibling;
4024 current_frame->pFrameSibling = NULL;
4025 } else {
4026 current_frame = frame;
4027 last = TRUE;
4028 }
4029
4030 if (current_frame->pFrameFirstChild) {
4031 hr = D3DXFrameDestroy(current_frame->pFrameFirstChild, alloc_hier);
4032 if (FAILED(hr)) return hr;
4033 current_frame->pFrameFirstChild = NULL;
4034 }
4035
4036 container = current_frame->pMeshContainer;
4037 while (container) {
4038 D3DXMESHCONTAINER *next_container = container->pNextMeshContainer;
4039 hr = alloc_hier->lpVtbl->DestroyMeshContainer(alloc_hier, container);
4040 if (FAILED(hr)) return hr;
4041 container = next_container;
4042 }
4043 hr = alloc_hier->lpVtbl->DestroyFrame(alloc_hier, current_frame);
4044 if (FAILED(hr)) return hr;
4045 }
4046 return D3D_OK;
4047 }
4048
4049 HRESULT WINAPI D3DXLoadMeshFromXA(const char *filename, DWORD options, struct IDirect3DDevice9 *device,
4050 struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances,
4051 DWORD *num_materials, struct ID3DXMesh **mesh)
4052 {
4053 WCHAR *filenameW;
4054 HRESULT hr;
4055 int len;
4056
4057 TRACE("filename %s, options %#x, device %p, adjacency %p, materials %p, "
4058 "effect_instances %p, num_materials %p, mesh %p.\n",
4059 debugstr_a(filename), options, device, adjacency, materials,
4060 effect_instances, num_materials, mesh);
4061
4062 if (!filename)
4063 return D3DERR_INVALIDCALL;
4064
4065 len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
4066 filenameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
4067 if (!filenameW) return E_OUTOFMEMORY;
4068 MultiByteToWideChar(CP_ACP, 0, filename, -1, filenameW, len);
4069
4070 hr = D3DXLoadMeshFromXW(filenameW, options, device, adjacency, materials,
4071 effect_instances, num_materials, mesh);
4072 HeapFree(GetProcessHeap(), 0, filenameW);
4073
4074 return hr;
4075 }
4076
4077 HRESULT WINAPI D3DXLoadMeshFromXW(const WCHAR *filename, DWORD options, struct IDirect3DDevice9 *device,
4078 struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials, struct ID3DXBuffer **effect_instances,
4079 DWORD *num_materials, struct ID3DXMesh **mesh)
4080 {
4081 void *buffer;
4082 HRESULT hr;
4083 DWORD size;
4084
4085 TRACE("filename %s, options %#x, device %p, adjacency %p, materials %p, "
4086 "effect_instances %p, num_materials %p, mesh %p.\n",
4087 debugstr_w(filename), options, device, adjacency, materials,
4088 effect_instances, num_materials, mesh);
4089
4090 if (!filename)
4091 return D3DERR_INVALIDCALL;
4092
4093 hr = map_view_of_file(filename, &buffer, &size);
4094 if (FAILED(hr))
4095 return D3DXERR_INVALIDDATA;
4096
4097 hr = D3DXLoadMeshFromXInMemory(buffer, size, options, device, adjacency,
4098 materials, effect_instances, num_materials, mesh);
4099
4100 UnmapViewOfFile(buffer);
4101
4102 return hr;
4103 }
4104
4105 HRESULT WINAPI D3DXLoadMeshFromXResource(HMODULE module, const char *name, const char *type, DWORD options,
4106 struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency, struct ID3DXBuffer **materials,
4107 struct ID3DXBuffer **effect_instances, DWORD *num_materials, struct ID3DXMesh **mesh)
4108 {
4109 HRESULT hr;
4110 HRSRC resinfo;
4111 void *buffer;
4112 DWORD size;
4113
4114 TRACE("module %p, name %s, type %s, options %#x, device %p, adjacency %p, "
4115 "materials %p, effect_instances %p, num_materials %p, mesh %p.\n",
4116 module, debugstr_a(name), debugstr_a(type), options, device, adjacency,
4117 materials, effect_instances, num_materials, mesh);
4118
4119 resinfo = FindResourceA(module, name, type);
4120 if (!resinfo) return D3DXERR_INVALIDDATA;
4121
4122 hr = load_resource_into_memory(module, resinfo, &buffer, &size);
4123 if (FAILED(hr)) return D3DXERR_INVALIDDATA;
4124
4125 return D3DXLoadMeshFromXInMemory(buffer, size, options, device, adjacency,
4126 materials, effect_instances, num_materials, mesh);
4127 }
4128
4129 struct mesh_container
4130 {
4131 struct list entry;
4132 ID3DXMesh *mesh;
4133 ID3DXBuffer *adjacency;
4134 ID3DXBuffer *materials;
4135 ID3DXBuffer *effects;
4136 DWORD num_materials;
4137 D3DXMATRIX transform;
4138 };
4139
4140 static HRESULT parse_frame(struct ID3DXFileData *filedata, DWORD options, struct IDirect3DDevice9 *device,
4141 const D3DXMATRIX *parent_transform, struct list *container_list, DWORD provide_flags)
4142 {
4143 HRESULT hr;
4144 D3DXMATRIX transform = *parent_transform;
4145 ID3DXFileData *child;
4146 GUID type;
4147 SIZE_T i, nb_children;
4148
4149 hr = filedata->lpVtbl->GetChildren(filedata, &nb_children);
4150 if (FAILED(hr))
4151 return hr;
4152
4153 for (i = 0; i < nb_children; i++)
4154 {
4155 hr = filedata->lpVtbl->GetChild(filedata, i, &child);
4156 if (FAILED(hr))
4157 return hr;
4158 hr = child->lpVtbl->GetType(child, &type);
4159 if (FAILED(hr))
4160 goto err;
4161
4162 if (IsEqualGUID(&type, &TID_D3DRMMesh)) {
4163 struct mesh_container *container = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*container));
4164 if (!container)
4165 {
4166 hr = E_OUTOFMEMORY;
4167 goto err;
4168 }
4169 list_add_tail(container_list, &container->entry);
4170 container->transform = transform;
4171
4172 hr = D3DXLoadSkinMeshFromXof(child, options, device,
4173 (provide_flags & PROVIDE_ADJACENCY) ? &container->adjacency : NULL,
4174 (provide_flags & PROVIDE_MATERIALS) ? &container->materials : NULL,
4175 NULL, &container->num_materials, NULL, &container->mesh);
4176 } else if (IsEqualGUID(&type, &TID_D3DRMFrameTransformMatrix)) {
4177 D3DXMATRIX new_transform;
4178 hr = parse_transform_matrix(child, &new_transform);
4179 D3DXMatrixMultiply(&transform, &transform, &new_transform);
4180 } else if (IsEqualGUID(&type, &TID_D3DRMFrame)) {
4181 hr = parse_frame(child, options, device, &transform, container_list, provide_flags);
4182 }
4183 if (FAILED(hr))
4184 goto err;
4185
4186 IUnknown_Release(child);
4187 }
4188 return D3D_OK;
4189
4190 err:
4191 IUnknown_Release(child);
4192 return hr;
4193 }
4194
4195 HRESULT WINAPI D3DXLoadMeshFromXInMemory(const void *memory, DWORD memory_size, DWORD options,
4196 struct IDirect3DDevice9 *device, struct ID3DXBuffer **adjacency_out, struct ID3DXBuffer **materials_out,
4197 struct ID3DXBuffer **effects_out, DWORD *num_materials_out, struct ID3DXMesh **mesh_out)
4198 {
4199 HRESULT hr;
4200 ID3DXFile *d3dxfile = NULL;
4201 ID3DXFileEnumObject *enumobj = NULL;
4202 ID3DXFileData *filedata = NULL;
4203 D3DXF_FILELOADMEMORY source;
4204 ID3DXBuffer *materials = NULL;
4205 ID3DXBuffer *effects = NULL;
4206 ID3DXBuffer *adjacency = NULL;
4207 struct list container_list = LIST_INIT(container_list);
4208 struct mesh_container *container_ptr, *next_container_ptr;
4209 DWORD num_materials;
4210 DWORD num_faces, num_vertices;
4211 D3DXMATRIX identity;
4212 DWORD provide_flags = 0;
4213 DWORD fvf;
4214 ID3DXMesh *concat_mesh = NULL;
4215 D3DVERTEXELEMENT9 concat_decl[MAX_FVF_DECL_SIZE];
4216 BYTE *concat_vertices = NULL;
4217 void *concat_indices = NULL;
4218 DWORD index_offset;
4219 DWORD concat_vertex_size;
4220 SIZE_T i, nb_children;
4221 GUID guid;
4222
4223 TRACE("(%p, %u, %x, %p, %p, %p, %p, %p, %p)\n", memory, memory_size, options,
4224 device, adjacency_out, materials_out, effects_out, num_materials_out, mesh_out);
4225
4226 if (!memory || !memory_size || !device || !mesh_out)
4227 return D3DERR_INVALIDCALL;
4228
4229 hr = D3DXFileCreate(&d3dxfile);
4230 if (FAILED(hr)) goto cleanup;
4231
4232 hr = d3dxfile->lpVtbl->RegisterTemplates(d3dxfile, D3DRM_XTEMPLATES, D3DRM_XTEMPLATE_BYTES);
4233 if (FAILED(hr)) goto cleanup;
4234
4235 source.lpMemory = (void*)memory;
4236 source.dSize = memory_size;
4237 hr = d3dxfile->lpVtbl->CreateEnumObject(d3dxfile, &source, D3DXF_FILELOAD_FROMMEMORY, &enumobj);
4238 if (FAILED(hr)) goto cleanup;
4239
4240 D3DXMatrixIdentity(&identity);
4241 if (adjacency_out) provide_flags |= PROVIDE_ADJACENCY;
4242 if (materials_out || effects_out) provide_flags |= PROVIDE_MATERIALS;
4243
4244 hr = enumobj->lpVtbl->GetChildren(enumobj, &nb_children);
4245 if (FAILED(hr))
4246 goto cleanup;
4247
4248 for (i = 0; i < nb_children; i++)
4249 {
4250 hr = enumobj->lpVtbl->GetChild(enumobj, i, &filedata);
4251 if (FAILED(hr))
4252 goto cleanup;
4253
4254 hr = filedata->lpVtbl->GetType(filedata, &guid);
4255 if (SUCCEEDED(hr)) {
4256 if (IsEqualGUID(&guid, &TID_D3DRMMesh)) {
4257 container_ptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*container_ptr));
4258 if (!container_ptr) {
4259 hr = E_OUTOFMEMORY;
4260 goto cleanup;
4261 }
4262 list_add_tail(&container_list, &container_ptr->entry);
4263 D3DXMatrixIdentity(&container_ptr->transform);
4264
4265 hr = D3DXLoadSkinMeshFromXof(filedata, options, device,
4266 (provide_flags & PROVIDE_ADJACENCY) ? &container_ptr->adjacency : NULL,
4267 (provide_flags & PROVIDE_MATERIALS) ? &container_ptr->materials : NULL,
4268 NULL, &container_ptr->num_materials, NULL, &container_ptr->mesh);
4269 } else if (IsEqualGUID(&guid, &TID_D3DRMFrame)) {
4270 hr = parse_frame(filedata, options, device, &identity, &container_list, provide_flags);
4271 }
4272 if (FAILED(hr)) goto cleanup;
4273 }
4274 filedata->lpVtbl->Release(filedata);
4275 filedata = NULL;
4276 if (FAILED(hr))
4277 goto cleanup;
4278 }
4279
4280 enumobj->lpVtbl->Release(enumobj);
4281 enumobj = NULL;
4282 d3dxfile->lpVtbl->Release(d3dxfile);
4283 d3dxfile = NULL;
4284
4285 if (list_empty(&container_list)) {
4286 hr = E_FAIL;
4287 goto cleanup;
4288 }
4289
4290 fvf = D3DFVF_XYZ;
4291 num_faces = 0;
4292 num_vertices = 0;
4293 num_materials = 0;
4294 LIST_FOR_EACH_ENTRY(container_ptr, &container_list, struct mesh_container, entry)
4295 {
4296 ID3DXMesh *mesh = container_ptr->mesh;
4297 fvf |= mesh->lpVtbl->GetFVF(mesh);
4298 num_faces += mesh->lpVtbl->GetNumFaces(mesh);
4299 num_vertices += mesh->lpVtbl->GetNumVertices(mesh);
4300 num_materials += container_ptr->num_materials;
4301 }
4302
4303 hr = D3DXCreateMeshFVF(num_faces, num_vertices, options, fvf, device, &concat_mesh);
4304 if (FAILED(hr)) goto cleanup;
4305
4306 hr = concat_mesh->lpVtbl->GetDeclaration(concat_mesh, concat_decl);
4307 if (FAILED(hr)) goto cleanup;
4308
4309 concat_vertex_size = D3DXGetDeclVertexSize(concat_decl, 0);
4310
4311 hr = concat_mesh->lpVtbl->LockVertexBuffer(concat_mesh, 0, (void**)&concat_vertices);
4312 if (FAILED(hr)) goto cleanup;
4313
4314 LIST_FOR_EACH_ENTRY(container_ptr, &container_list, struct mesh_container, entry)
4315 {
4316 D3DVERTEXELEMENT9 mesh_decl[MAX_FVF_DECL_SIZE];
4317 ID3DXMesh *mesh = container_ptr->mesh;
4318 DWORD num_mesh_vertices = mesh->lpVtbl->GetNumVertices(mesh);
4319 DWORD mesh_vertex_size;
4320 const BYTE *mesh_vertices;
4321 DWORD i;
4322
4323 hr = mesh->lpVtbl->GetDeclaration(mesh, mesh_decl);
4324 if (FAILED(hr)) goto cleanup;
4325
4326 mesh_vertex_size = D3DXGetDeclVertexSize(mesh_decl, 0);
4327
4328 hr = mesh->lpVtbl->LockVertexBuffer(mesh, D3DLOCK_READONLY, (void**)&mesh_vertices);
4329 if (FAILED(hr)) goto cleanup;
4330
4331 for (i = 0; i < num_mesh_vertices; i++) {
4332 int j;
4333 int k = 1;
4334
4335 D3DXVec3TransformCoord((D3DXVECTOR3*)concat_vertices,
4336 (D3DXVECTOR3*)mesh_vertices,
4337 &container_ptr->transform);
4338 for (j = 1; concat_decl[j].Stream != 0xff; j++)
4339 {
4340 if (concat_decl[j].Usage == mesh_decl[k].Usage &&
4341 concat_decl[j].UsageIndex == mesh_decl[k].UsageIndex)
4342 {
4343 if (concat_decl[j].Usage == D3DDECLUSAGE_NORMAL) {
4344 D3DXVec3TransformCoord((D3DXVECTOR3*)(concat_vertices + concat_decl[j].Offset),
4345 (D3DXVECTOR3*)(mesh_vertices + mesh_decl[k].Offset),
4346 &container_ptr->transform);
4347 } else {
4348 memcpy(concat_vertices + concat_decl[j].Offset,
4349 mesh_vertices + mesh_decl[k].Offset,
4350 d3dx_decltype_size[mesh_decl[k].Type]);
4351 }
4352 k++;
4353 }
4354 }
4355 mesh_vertices += mesh_vertex_size;
4356 concat_vertices += concat_vertex_size;
4357 }
4358
4359 mesh->lpVtbl->UnlockVertexBuffer(mesh);
4360 }
4361
4362 concat_mesh->lpVtbl->UnlockVertexBuffer(concat_mesh);
4363 concat_vertices = NULL;
4364
4365 hr = concat_mesh->lpVtbl->LockIndexBuffer(concat_mesh, 0, &concat_indices);
4366 if (FAILED(hr)) goto cleanup;
4367
4368 index_offset = 0;
4369 LIST_FOR_EACH_ENTRY(container_ptr, &container_list, struct mesh_container, entry)
4370 {
4371 ID3DXMesh *mesh = container_ptr->mesh;
4372 const void *mesh_indices;
4373 DWORD num_mesh_faces = mesh->lpVtbl->GetNumFaces(mesh);
4374 DWORD i;
4375
4376 hr = mesh->lpVtbl->LockIndexBuffer(mesh, D3DLOCK_READONLY, (void**)&mesh_indices);
4377 if (FAILED(hr)) goto cleanup;
4378
4379 if (options & D3DXMESH_32BIT) {
4380 DWORD *dest = concat_indices;
4381 const DWORD *src = mesh_indices;
4382 for (i = 0; i < num_mesh_faces * 3; i++)
4383 *dest++ = index_offset + *src++;
4384 concat_indices = dest;
4385 } else {
4386 WORD *dest = concat_indices;
4387 const WORD *src = mesh_indices;
4388 for (i = 0; i < num_mesh_faces * 3; i++)
4389 *dest++ = index_offset + *src++;
4390 concat_indices = dest;
4391 }
4392 mesh->lpVtbl->UnlockIndexBuffer(mesh);
4393
4394 index_offset += num_mesh_faces * 3;
4395 }
4396
4397 concat_mesh->lpVtbl->UnlockIndexBuffer(concat_mesh);
4398 concat_indices = NULL;
4399
4400 if (num_materials) {
4401 DWORD *concat_attrib_buffer = NULL;
4402 DWORD offset = 0;
4403
4404 hr = concat_mesh->lpVtbl->LockAttributeBuffer(concat_mesh, 0, &concat_attrib_buffer);
4405 if (FAILED(hr)) goto cleanup;
4406
4407 LIST_FOR_EACH_ENTRY(container_ptr, &container_list, struct mesh_container, entry)
4408 {
4409 ID3DXMesh *mesh = container_ptr->mesh;
4410 const DWORD *mesh_attrib_buffer = NULL;
4411 DWORD count = mesh->lpVtbl->GetNumFaces(mesh);
4412
4413 hr = mesh->lpVtbl->LockAttributeBuffer(mesh, D3DLOCK_READONLY, (DWORD**)&mesh_attrib_buffer);
4414 if (FAILED(hr)) {
4415 concat_mesh->lpVtbl->UnlockAttributeBuffer(concat_mesh);
4416 goto cleanup;
4417 }
4418
4419 while (count--)
4420 *concat_attrib_buffer++ = offset + *mesh_attrib_buffer++;
4421
4422 mesh->lpVtbl->UnlockAttributeBuffer(mesh);
4423 offset += container_ptr->num_materials;
4424 }
4425 concat_mesh->lpVtbl->UnlockAttributeBuffer(concat_mesh);
4426 }
4427
4428 if (materials_out || effects_out) {
4429 D3DXMATERIAL *out_ptr;
4430 if (!num_materials) {
4431 /* create default material */
4432 hr = D3DXCreateBuffer(sizeof(D3DXMATERIAL), &materials);
4433 if (FAILED(hr)) goto cleanup;
4434
4435 out_ptr = ID3DXBuffer_GetBufferPointer(materials);
4436 out_ptr->MatD3D.Diffuse.r = 0.5f;
4437 out_ptr->MatD3D.Diffuse.g = 0.5f;
4438 out_ptr->MatD3D.Diffuse.b = 0.5f;
4439 out_ptr->MatD3D.Specular.r = 0.5f;
4440 out_ptr->MatD3D.Specular.g = 0.5f;
4441 out_ptr->MatD3D.Specular.b = 0.5f;
4442 /* D3DXCreateBuffer initializes the rest to zero */
4443 } else {
4444 DWORD buffer_size = num_materials * sizeof(D3DXMATERIAL);
4445 char *strings_out_ptr;
4446
4447 LIST_FOR_EACH_ENTRY(container_ptr, &container_list, struct mesh_container, entry)
4448 {
4449 if (container_ptr->materials) {
4450 DWORD i;
4451 const D3DXMATERIAL *in_ptr = ID3DXBuffer_GetBufferPointer(container_ptr->materials);
4452 for (i = 0; i < container_ptr->num_materials; i++)
4453 {
4454 if (in_ptr->pTextureFilename)
4455 buffer_size += strlen(in_ptr->pTextureFilename) + 1;
4456 in_ptr++;
4457 }
4458 }
4459 }
4460
4461 hr = D3DXCreateBuffer(buffer_size, &materials);
4462 if (FAILED(hr)) goto cleanup;
4463 out_ptr = ID3DXBuffer_GetBufferPointer(materials);
4464 strings_out_ptr = (char*)(out_ptr + num_materials);
4465
4466 LIST_FOR_EACH_ENTRY(container_ptr, &container_list, struct mesh_container, entry)
4467 {
4468 if (container_ptr->materials) {
4469 DWORD i;
4470 const D3DXMATERIAL *in_ptr = ID3DXBuffer_GetBufferPointer(container_ptr->materials);
4471 for (i = 0; i < container_ptr->num_materials; i++)
4472 {
4473 out_ptr->MatD3D = in_ptr->MatD3D;
4474 if (in_ptr->pTextureFilename) {
4475 out_ptr->pTextureFilename = strings_out_ptr;
4476 strcpy(out_ptr->pTextureFilename, in_ptr->pTextureFilename);
4477 strings_out_ptr += strlen(in_ptr->pTextureFilename) + 1;
4478 }
4479 in_ptr++;
4480 out_ptr++;
4481 }
4482 }
4483 }
4484 }
4485 }
4486 if (!num_materials)
4487 num_materials = 1;
4488
4489 if (effects_out) {
4490 generate_effects(materials, num_materials, &effects);
4491 if (!materials_out) {
4492 ID3DXBuffer_Release(materials);
4493 materials = NULL;
4494 }
4495 }
4496
4497 if (adjacency_out) {
4498 if (!list_next(&container_list, list_head(&container_list))) {
4499 container_ptr = LIST_ENTRY(list_head(&container_list), struct mesh_container, entry);
4500 adjacency = container_ptr->adjacency;
4501 container_ptr->adjacency = NULL;
4502 } else {
4503 DWORD offset = 0;
4504 DWORD *out_ptr;
4505
4506 hr = D3DXCreateBuffer(num_faces * 3 * sizeof(DWORD), &adjacency);
4507 if (FAILED(hr)) goto cleanup;
4508
4509 out_ptr = ID3DXBuffer_GetBufferPointer(adjacency);
4510 LIST_FOR_EACH_ENTRY(container_ptr, &container_list, struct mesh_container, entry)
4511 {
4512 DWORD i;
4513 DWORD count = 3 * container_ptr->mesh->lpVtbl->GetNumFaces(container_ptr->mesh);
4514 DWORD *in_ptr = ID3DXBuffer_GetBufferPointer(container_ptr->adjacency);
4515
4516 for (i = 0; i < count; i++)
4517 *out_ptr++ = offset + *in_ptr++;
4518
4519 offset += count;
4520 }
4521 }
4522 }
4523
4524 *mesh_out = concat_mesh;
4525 if (adjacency_out) *adjacency_out = adjacency;
4526 if (materials_out) *materials_out = materials;
4527 if (effects_out) *effects_out = effects;
4528 if (num_materials_out) *num_materials_out = num_materials;
4529
4530 hr = D3D_OK;
4531 cleanup:
4532 if (concat_indices) concat_mesh->lpVtbl->UnlockIndexBuffer(concat_mesh);
4533 if (concat_vertices) concat_mesh->lpVtbl->UnlockVertexBuffer(concat_mesh);
4534 if (filedata) filedata->lpVtbl->Release(filedata);
4535 if (enumobj) enumobj->lpVtbl->Release(enumobj);
4536 if (d3dxfile) d3dxfile->lpVtbl->Release(d3dxfile);
4537 if (FAILED(hr)) {
4538 if (concat_mesh) IUnknown_Release(concat_mesh);
4539 if (materials) ID3DXBuffer_Release(materials);
4540 if (effects) ID3DXBuffer_Release(effects);
4541 if (adjacency) ID3DXBuffer_Release(adjacency);
4542 }
4543 LIST_FOR_EACH_ENTRY_SAFE(container_ptr, next_container_ptr, &container_list, struct mesh_container, entry)
4544 {
4545 if (container_ptr->mesh) IUnknown_Release(container_ptr->mesh);
4546 if (container_ptr->adjacency) ID3DXBuffer_Release(container_ptr->adjacency);
4547 if (container_ptr->materials) ID3DXBuffer_Release(container_ptr->materials);
4548 if (container_ptr->effects) ID3DXBuffer_Release(container_ptr->effects);
4549 HeapFree(GetProcessHeap(), 0, container_ptr);
4550 }
4551 return hr;
4552 }
4553
4554 struct vertex
4555 {
4556 D3DXVECTOR3 position;
4557 D3DXVECTOR3 normal;
4558 };
4559
4560 HRESULT WINAPI D3DXCreatePolygon(struct IDirect3DDevice9 *device, float length, UINT sides,
4561 struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency)
4562 {
4563 HRESULT hr;
4564 ID3DXMesh *polygon;
4565 struct vertex *vertices;
4566 WORD (*faces)[3];
4567 DWORD (*adjacency_buf)[3];
4568 float scale;
4569 unsigned int i;
4570
4571 TRACE("device %p, length %f, sides %u, mesh %p, adjacency %p.\n",
4572 device, length, sides, mesh, adjacency);
4573
4574 if (!device || length < 0.0f || sides < 3 || !mesh)
4575 return D3DERR_INVALIDCALL;
4576
4577 if (FAILED(hr = D3DXCreateMeshFVF(sides, sides + 1, D3DXMESH_MANAGED,
4578 D3DFVF_XYZ | D3DFVF_NORMAL, device, &polygon)))
4579 {
4580 return hr;
4581 }
4582
4583 if (FAILED(hr = polygon->lpVtbl->LockVertexBuffer(polygon, 0, (void **)&vertices)))
4584 {
4585 polygon->lpVtbl->Release(polygon);
4586 return hr;
4587 }
4588
4589 if (FAILED(hr = polygon->lpVtbl->LockIndexBuffer(polygon, 0, (void **)&faces)))
4590 {
4591 polygon->lpVtbl->UnlockVertexBuffer(polygon);
4592 polygon->lpVtbl->Release(polygon);
4593 return hr;
4594 }
4595
4596 scale = 0.5f * length / sinf(D3DX_PI / sides);
4597
4598 vertices[0].position.x = 0.0f;
4599 vertices[0].position.y = 0.0f;
4600 vertices[0].position.z = 0.0f;
4601 vertices[0].normal.x = 0.0f;
4602 vertices[0].normal.y = 0.0f;
4603 vertices[0].normal.z = 1.0f;
4604
4605 for (i = 0; i < sides; ++i)
4606 {
4607 vertices[i + 1].position.x = cosf(2.0f * D3DX_PI * i / sides) * scale;
4608 vertices[i + 1].position.y = sinf(2.0f * D3DX_PI * i / sides) * scale;
4609 vertices[i + 1].position.z = 0.0f;
4610 vertices[i + 1].normal.x = 0.0f;
4611 vertices[i + 1].normal.y = 0.0f;
4612 vertices[i + 1].normal.z = 1.0f;
4613
4614 faces[i][0] = 0;
4615 faces[i][1] = i + 1;
4616 faces[i][2] = i + 2;
4617 }
4618
4619 faces[sides - 1][2] = 1;
4620
4621 polygon->lpVtbl->UnlockVertexBuffer(polygon);
4622 polygon->lpVtbl->UnlockIndexBuffer(polygon);
4623
4624 if (adjacency)
4625 {
4626 if (FAILED(hr = D3DXCreateBuffer(sides * sizeof(DWORD) * 3, adjacency)))
4627 {
4628 polygon->lpVtbl->Release(polygon);
4629 return hr;
4630 }
4631
4632 adjacency_buf = ID3DXBuffer_GetBufferPointer(*adjacency);
4633 for (i = 0; i < sides; ++i)
4634 {
4635 adjacency_buf[i][0] = i - 1;
4636 adjacency_buf[i][1] = ~0U;
4637 adjacency_buf[i][2] = i + 1;
4638 }
4639 adjacency_buf[0][0] = sides - 1;
4640 adjacency_buf[sides - 1][2] = 0;
4641 }
4642
4643 *mesh = polygon;
4644
4645 return D3D_OK;
4646 }
4647
4648 HRESULT WINAPI D3DXCreateBox(struct IDirect3DDevice9 *device, float width, float height,
4649 float depth, struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency)
4650 {
4651 HRESULT hr;
4652 ID3DXMesh *box;
4653 struct vertex *vertices;
4654 WORD (*faces)[3];
4655 DWORD *adjacency_buf;
4656 unsigned int i, face;
4657 static const D3DXVECTOR3 unit_box[] =
4658 {
4659 {-0.5f, -0.5f, -0.5f}, {-0.5f, -0.5f, 0.5f}, {-0.5f, 0.5f, 0.5f}, {-0.5f, 0.5f, -0.5f},
4660 {-0.5f, 0.5f, -0.5f}, {-0.5f, 0.5f, 0.5f}, { 0.5f, 0.5f, 0.5f}, { 0.5f, 0.5f, -0.5f},
4661 { 0.5f, 0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f}, { 0.5f, -0.5f, 0.5f}, { 0.5f, -0.5f, -0.5f},
4662 {-0.5f, -0.5f, 0.5f}, {-0.5f, -0.5f, -0.5f}, { 0.5f, -0.5f, -0.5f}, { 0.5f, -0.5f, 0.5f},
4663 {-0.5f, -0.5f, 0.5f}, { 0.5f, -0.5f, 0.5f}, { 0.5f, 0.5f, 0.5f}, {-0.5f, 0.5f, 0.5f},
4664 {-0.5f, -0.5f, -0.5f}, {-0.5f, 0.5f, -0.5f}, { 0.5f, 0.5f, -0.5f}, { 0.5f, -0.5f, -0.5f}
4665 };
4666 static const D3DXVECTOR3 normals[] =
4667 {
4668 {-1.0f, 0.0f, 0.0f}, { 0.0f, 1.0f, 0.0f}, { 1.0f, 0.0f, 0.0f},
4669 { 0.0f, -1.0f, 0.0f}, { 0.0f, 0.0f, 1.0f}, { 0.0f, 0.0f, -1.0f}
4670 };
4671 static const DWORD adjacency_table[] =
4672 {
4673 6, 9, 1, 2, 10, 0, 1, 9, 3, 4, 10, 2,
4674 3, 8, 5, 7, 11, 4, 0, 11, 7, 5, 8, 6,
4675 7, 4, 9, 2, 0, 8, 1, 3, 11, 5, 6, 10
4676 };
4677
4678 TRACE("device %p, width %f, height %f, depth %f, mesh %p, adjacency %p\n",
4679 device, width, height, depth, mesh, adjacency);
4680
4681 if (!device || width < 0.0f || height < 0.0f || depth < 0.0f || !mesh)
4682 {
4683 return D3DERR_INVALIDCALL;
4684 }
4685
4686 if (FAILED(hr = D3DXCreateMeshFVF(12, 24, D3DXMESH_MANAGED, D3DFVF_XYZ | D3DFVF_NORMAL, device, &box)))
4687 {
4688 return hr;
4689 }
4690
4691 if (FAILED(hr = box->lpVtbl->LockVertexBuffer(box, 0, (void **)&vertices)))
4692 {
4693 box->lpVtbl->Release(box);
4694 return hr;
4695 }
4696
4697 if (FAILED(hr = box->lpVtbl->LockIndexBuffer(box, 0, (void **)&faces)))
4698 {
4699 box->lpVtbl->UnlockVertexBuffer(box);
4700 box->lpVtbl->Release(box);
4701 return hr;
4702 }
4703
4704 for (i = 0; i < 24; i++)
4705 {
4706 vertices[i].position.x = width * unit_box[i].x;
4707 vertices[i].position.y = height * unit_box[i].y;
4708 vertices[i].position.z = depth * unit_box[i].z;
4709 vertices[i].normal.x = normals[i / 4].x;
4710 vertices[i].normal.y = normals[i / 4].y;
4711 vertices[i].normal.z = normals[i / 4].z;
4712 }
4713
4714 face = 0;
4715 for (i = 0; i < 12; i++)
4716 {
4717 faces[i][0] = face++;
4718 faces[i][1] = face++;
4719 faces[i][2] = (i % 2) ? face - 4 : face;
4720 }
4721
4722 box->lpVtbl->UnlockIndexBuffer(box);
4723 box->lpVtbl->UnlockVertexBuffer(box);
4724
4725 if (adjacency)
4726 {
4727 if (FAILED(hr = D3DXCreateBuffer(sizeof(adjacency_table), adjacency)))
4728 {
4729 box->lpVtbl->Release(box);
4730 return hr;
4731 }
4732
4733 adjacency_buf = ID3DXBuffer_GetBufferPointer(*adjacency);
4734 memcpy(adjacency_buf, adjacency_table, sizeof(adjacency_table));
4735 }
4736
4737 *mesh = box;
4738
4739 return D3D_OK;
4740 }
4741
4742 typedef WORD face[3];
4743
4744 struct sincos_table
4745 {
4746 float *sin;
4747 float *cos;
4748 };
4749
4750 static void free_sincos_table(struct sincos_table *sincos_table)
4751 {
4752 HeapFree(GetProcessHeap(), 0, sincos_table->cos);
4753 HeapFree(GetProcessHeap(), 0, sincos_table->sin);
4754 }
4755
4756 /* pre compute sine and cosine tables; caller must free */
4757 static BOOL compute_sincos_table(struct sincos_table *sincos_table, float angle_start, float angle_step, int n)
4758 {
4759 float angle;
4760 int i;
4761
4762 sincos_table->sin = HeapAlloc(GetProcessHeap(), 0, n * sizeof(*sincos_table->sin));
4763 if (!sincos_table->sin)
4764 {
4765 return FALSE;
4766 }
4767 sincos_table->cos = HeapAlloc(GetProcessHeap(), 0, n * sizeof(*sincos_table->cos));
4768 if (!sincos_table->cos)
4769 {
4770 HeapFree(GetProcessHeap(), 0, sincos_table->sin);
4771 return FALSE;
4772 }
4773
4774 angle = angle_start;
4775 for (i = 0; i < n; i++)
4776 {
4777 sincos_table->sin[i] = sinf(angle);
4778 sincos_table->cos[i] = cosf(angle);
4779 angle += angle_step;
4780 }
4781
4782 return TRUE;
4783 }
4784
4785 static WORD vertex_index(UINT slices, int slice, int stack)
4786 {
4787 return stack*slices+slice+1;
4788 }
4789
4790 HRESULT WINAPI D3DXCreateSphere(struct IDirect3DDevice9 *device, float radius, UINT slices,
4791 UINT stacks, struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency)
4792 {
4793 DWORD number_of_vertices, number_of_faces;
4794 HRESULT hr;
4795 ID3DXMesh *sphere;
4796 struct vertex *vertices;
4797 face *faces;
4798 float phi_step, phi_start;
4799 struct sincos_table phi;
4800 float theta_step, theta, sin_theta, cos_theta;
4801 DWORD vertex, face, stack, slice;
4802
4803 TRACE("(%p, %f, %u, %u, %p, %p)\n", device, radius, slices, stacks, mesh, adjacency);
4804
4805 if (!device || radius < 0.0f || slices < 2 || stacks < 2 || !mesh)
4806 {
4807 return D3DERR_INVALIDCALL;
4808 }
4809
4810 number_of_vertices = 2 + slices * (stacks-1);
4811 number_of_faces = 2 * slices + (stacks - 2) * (2 * slices);
4812
4813 hr = D3DXCreateMeshFVF(number_of_faces, number_of_vertices, D3DXMESH_MANAGED,
4814 D3DFVF_XYZ | D3DFVF_NORMAL, device, &sphere);
4815 if (FAILED(hr))
4816 {
4817 return hr;
4818 }
4819
4820 if (FAILED(hr = sphere->lpVtbl->LockVertexBuffer(sphere, 0, (void **)&vertices)))
4821 {
4822 sphere->lpVtbl->Release(sphere);
4823 return hr;
4824 }
4825
4826 if (FAILED(hr = sphere->lpVtbl->LockIndexBuffer(sphere, 0, (void **)&faces)))
4827 {
4828 sphere->lpVtbl->UnlockVertexBuffer(sphere);
4829 sphere->lpVtbl->Release(sphere);
4830 return hr;
4831 }
4832
4833 /* phi = angle on xz plane wrt z axis */
4834 phi_step = -2.0f * D3DX_PI / slices;
4835 phi_start = D3DX_PI / 2.0f;
4836
4837 if (!compute_sincos_table(&phi, phi_start, phi_step, slices))
4838 {
4839 sphere->lpVtbl->UnlockIndexBuffer(sphere);
4840 sphere->lpVtbl->UnlockVertexBuffer(sphere);
4841 sphere->lpVtbl->Release(sphere);
4842 return E_OUTOFMEMORY;
4843 }
4844
4845 /* theta = angle on xy plane wrt x axis */
4846 theta_step = D3DX_PI / stacks;
4847 theta = theta_step;
4848
4849 vertex = 0;
4850 face = 0;
4851
4852 vertices[vertex].normal.x = 0.0f;
4853 vertices[vertex].normal.y = 0.0f;
4854 vertices[vertex].normal.z = 1.0f;
4855 vertices[vertex].position.x = 0.0f;
4856 vertices[vertex].position.y = 0.0f;
4857 vertices[vertex].position.z = radius;
4858 vertex++;
4859
4860 for (stack = 0; stack < stacks - 1; stack++)
4861 {
4862 sin_theta = sinf(theta);
4863 cos_theta = cosf(theta);
4864
4865 for (slice = 0; slice < slices; slice++)
4866 {
4867 vertices[vertex].normal.x = sin_theta * phi.cos[slice];
4868 vertices[vertex].normal.y = sin_theta * phi.sin[slice];
4869 vertices[vertex].normal.z = cos_theta;
4870 vertices[vertex].position.x = radius * sin_theta * phi.cos[slice];
4871 vertices[vertex].position.y = radius * sin_theta * phi.sin[slice];
4872 vertices[vertex].position.z = radius * cos_theta;
4873 vertex++;
4874
4875 if (slice > 0)
4876 {
4877 if (stack == 0)
4878 {
4879 /* top stack is triangle fan */
4880 faces[face][0] = 0;
4881 faces[face][1] = slice + 1;
4882 faces[face][2] = slice;
4883 face++;
4884 }
4885 else
4886 {
4887 /* stacks in between top and bottom are quad strips */
4888 faces[face][0] = vertex_index(slices, slice-1, stack-1);
4889 faces[face][1] = vertex_index(slices, slice, stack-1);
4890 faces[face][2] = vertex_index(slices, slice-1, stack);
4891 face++;
4892
4893 faces[face][0] = vertex_index(slices, slice, stack-1);
4894 faces[face][1] = vertex_index(slices, slice, stack);
4895 faces[face][2] = vertex_index(slices, slice-1, stack);
4896 face++;
4897 }
4898 }
4899 }
4900
4901 theta += theta_step;
4902
4903 if (stack == 0)
4904 {
4905 faces[face][0] = 0;
4906 faces[face][1] = 1;
4907 faces[face][2] = slice;
4908 face++;
4909 }
4910 else
4911 {
4912 faces[face][0] = vertex_index(slices, slice-1, stack-1);
4913 faces[face][1] = vertex_index(slices, 0, stack-1);
4914 faces[face][2] = vertex_index(slices, slice-1, stack);
4915 face++;
4916
4917 faces[face][0] = vertex_index(slices, 0, stack-1);
4918 faces[face][1] = vertex_index(slices, 0, stack);
4919 faces[face][2] = vertex_index(slices, slice-1, stack);
4920 face++;
4921 }
4922 }
4923
4924 vertices[vertex].position.x = 0.0f;
4925 vertices[vertex].position.y = 0.0f;
4926 vertices[vertex].position.z = -radius;
4927 vertices[vertex].normal.x = 0.0f;
4928 vertices[vertex].normal.y = 0.0f;
4929 vertices[vertex].normal.z = -1.0f;
4930
4931 /* bottom stack is triangle fan */
4932 for (slice = 1; slice < slices; slice++)
4933 {
4934 faces[face][0] = vertex_index(slices, slice-1, stack-1);
4935 faces[face][1] = vertex_index(slices, slice, stack-1);
4936 faces[face][2] = vertex;
4937 face++;
4938 }
4939
4940 faces[face][0] = vertex_index(slices, slice-1, stack-1);
4941 faces[face][1] = vertex_index(slices, 0, stack-1);
4942 faces[face][2] = vertex;
4943
4944 free_sincos_table(&phi);
4945 sphere->lpVtbl->UnlockIndexBuffer(sphere);
4946 sphere->lpVtbl->UnlockVertexBuffer(sphere);
4947
4948
4949 if (adjacency)
4950 {
4951 if (FAILED(hr = D3DXCreateBuffer(number_of_faces * sizeof(DWORD) * 3, adjacency)))
4952 {
4953 sphere->lpVtbl->Release(sphere);
4954 return hr;
4955 }
4956
4957 if (FAILED(hr = sphere->lpVtbl->GenerateAdjacency(sphere, 0.0f, (*adjacency)->lpVtbl->GetBufferPointer(*adjacency))))
4958 {
4959 (*adjacency)->lpVtbl->Release(*adjacency);
4960 sphere->lpVtbl->Release(sphere);
4961 return hr;
4962 }
4963 }
4964
4965 *mesh = sphere;
4966
4967 return D3D_OK;
4968 }
4969
4970 HRESULT WINAPI D3DXCreateCylinder(struct IDirect3DDevice9 *device, float radius1, float radius2,
4971 float length, UINT slices, UINT stacks, struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency)
4972 {
4973 DWORD number_of_vertices, number_of_faces;
4974 HRESULT hr;
4975 ID3DXMesh *cylinder;
4976 struct vertex *vertices;
4977 face *faces;
4978 float theta_step, theta_start;
4979 struct sincos_table theta;
4980 float delta_radius, radius, radius_step;
4981 float z, z_step, z_normal;
4982 DWORD vertex, face, slice, stack;
4983
4984 TRACE("(%p, %f, %f, %f, %u, %u, %p, %p)\n", device, radius1, radius2, length, slices, stacks, mesh, adjacency);
4985
4986 if (device == NULL || radius1 < 0.0f || radius2 < 0.0f || length < 0.0f || slices < 2 || stacks < 1 || mesh == NULL)
4987 {
4988 return D3DERR_INVALIDCALL;
4989 }
4990
4991 number_of_vertices = 2 + (slices * (3 + stacks));
4992 number_of_faces = 2 * slices + stacks * (2 * slices);
4993
4994 hr = D3DXCreateMeshFVF(number_of_faces, number_of_vertices, D3DXMESH_MANAGED,
4995 D3DFVF_XYZ | D3DFVF_NORMAL, device, &cylinder);
4996 if (FAILED(hr))
4997 {
4998 return hr;
4999 }
5000
5001 if (FAILED(hr = cylinder->lpVtbl->LockVertexBuffer(cylinder, 0, (void **)&vertices)))
5002 {
5003 cylinder->lpVtbl->Release(cylinder);
5004 return hr;
5005 }
5006
5007 if (FAILED(hr = cylinder->lpVtbl->LockIndexBuffer(cylinder, 0, (void **)&faces)))
5008 {
5009 cylinder->lpVtbl->UnlockVertexBuffer(cylinder);
5010 cylinder->lpVtbl->Release(cylinder);
5011 return hr;
5012 }
5013
5014 /* theta = angle on xy plane wrt x axis */
5015 theta_step = -2.0f * D3DX_PI / slices;
5016 theta_start = D3DX_PI / 2.0f;
5017
5018 if (!compute_sincos_table(&theta, theta_start, theta_step, slices))
5019 {
5020 cylinder->lpVtbl->UnlockIndexBuffer(cylinder);
5021 cylinder->lpVtbl->UnlockVertexBuffer(cylinder);
5022 cylinder->lpVtbl->Release(cylinder);
5023 return E_OUTOFMEMORY;
5024 }
5025
5026 vertex = 0;
5027 face = 0;
5028
5029 delta_radius = radius1 - radius2;
5030 radius = radius1;
5031 radius_step = delta_radius / stacks;
5032
5033 z = -length / 2;
5034 z_step = length / stacks;
5035 z_normal = delta_radius / length;
5036 if (isnan(z_normal))
5037 {
5038 z_normal = 0.0f;
5039 }
5040
5041 vertices[vertex].normal.x = 0.0f;
5042 vertices[vertex].normal.y = 0.0f;
5043 vertices[vertex].normal.z = -1.0f;
5044 vertices[vertex].position.x = 0.0f;
5045 vertices[vertex].position.y = 0.0f;
5046 vertices[vertex++].position.z = z;
5047
5048 for (slice = 0; slice < slices; slice++, vertex++)
5049 {
5050 vertices[vertex].normal.x = 0.0f;
5051 vertices[vertex].normal.y = 0.0f;
5052 vertices[vertex].normal.z = -1.0f;
5053 vertices[vertex].position.x = radius * theta.cos[slice];
5054 vertices[vertex].position.y = radius * theta.sin[slice];
5055 vertices[vertex].position.z = z;
5056
5057 if (slice > 0)
5058 {
5059 faces[face][0] = 0;
5060 faces[face][1] = slice;
5061 faces[face++][2] = slice + 1;
5062 }
5063 }
5064
5065 faces[face][0] = 0;
5066 faces[face][1] = slice;
5067 faces[face++][2] = 1;
5068
5069 for (stack = 1; stack <= stacks+1; stack++)
5070 {
5071 for (slice = 0; slice < slices; slice++, vertex++)
5072 {
5073 vertices[vertex].normal.x = theta.cos[slice];
5074 vertices[vertex].normal.y = theta.sin[slice];
5075 vertices[vertex].normal.z = z_normal;
5076 D3DXVec3Normalize(&vertices[vertex].normal, &vertices[vertex].normal);
5077 vertices[vertex].position.x = radius * theta.cos[slice];
5078 vertices[vertex].position.y = radius * theta.sin[slice];
5079 vertices[vertex].position.z = z;
5080
5081 if (stack > 1 && slice > 0)
5082 {
5083 faces[face][0] = vertex_index(slices, slice-1, stack-1);
5084 faces[face][1] = vertex_index(slices, slice-1, stack);
5085 faces[face++][2] = vertex_index(slices, slice, stack-1);
5086
5087 faces[face][0] = vertex_index(slices, slice, stack-1);
5088 faces[face][1] = vertex_index(slices, slice-1, stack);
5089 faces[face++][2] = vertex_index(slices, slice, stack);
5090 }
5091 }
5092
5093 if (stack > 1)
5094 {
5095 faces[face][0] = vertex_index(slices, slice-1, stack-1);
5096 faces[face][1] = vertex_index(slices, slice-1, stack);
5097 faces[face++][2] = vertex_index(slices, 0, stack-1);
5098
5099 faces[face][0] = vertex_index(slices, 0, stack-1);
5100 faces[face][1] = vertex_index(slices, slice-1, stack);
5101 faces[face++][2] = vertex_index(slices, 0, stack);
5102 }
5103
5104 if (stack < stacks + 1)
5105 {
5106 z += z_step;
5107 radius -= radius_step;
5108 }
5109 }
5110
5111 for (slice = 0; slice < slices; slice++, vertex++)
5112 {
5113 vertices[vertex].normal.x = 0.0f;
5114 vertices[vertex].normal.y = 0.0f;
5115 vertices[vertex].normal.z = 1.0f;
5116 vertices[vertex].position.x = radius * theta.cos[slice];
5117 vertices[vertex].position.y = radius * theta.sin[slice];
5118 vertices[vertex].position.z = z;
5119
5120 if (slice > 0)
5121 {
5122 faces[face][0] = vertex_index(slices, slice-1, stack);
5123 faces[face][1] = number_of_vertices - 1;
5124 faces[face++][2] = vertex_index(slices, slice, stack);
5125 }
5126 }
5127
5128 vertices[vertex].position.x = 0.0f;
5129 vertices[vertex].position.y = 0.0f;
5130 vertices[vertex].position.z = z;
5131 vertices[vertex].normal.x = 0.0f;
5132 vertices[vertex].normal.y = 0.0f;
5133 vertices[vertex].normal.z = 1.0f;
5134
5135 faces[face][0] = vertex_index(slices, slice-1, stack);
5136 faces[face][1] = number_of_vertices - 1;
5137 faces[face][2] = vertex_index(slices, 0, stack);
5138
5139 free_sincos_table(&theta);
5140 cylinder->lpVtbl->UnlockIndexBuffer(cylinder);
5141 cylinder->lpVtbl->UnlockVertexBuffer(cylinder);
5142
5143 if (adjacency)
5144 {
5145 if (FAILED(hr = D3DXCreateBuffer(number_of_faces * sizeof(DWORD) * 3, adjacency)))
5146 {
5147 cylinder->lpVtbl->Release(cylinder);
5148 return hr;
5149 }
5150
5151 if (FAILED(hr = cylinder->lpVtbl->GenerateAdjacency(cylinder, 0.0f, (*adjacency)->lpVtbl->GetBufferPointer(*adjacency))))
5152 {
5153 (*adjacency)->lpVtbl->Release(*adjacency);
5154 cylinder->lpVtbl->Release(cylinder);
5155 return hr;
5156 }
5157 }
5158
5159 *mesh = cylinder;
5160
5161 return D3D_OK;
5162 }
5163
5164 HRESULT WINAPI D3DXCreateTeapot(struct IDirect3DDevice9 *device,
5165 struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency)
5166 {
5167 FIXME("(%p, %p, %p): stub\n", device, mesh, adjacency);
5168
5169 return E_NOTIMPL;
5170 }
5171
5172 HRESULT WINAPI D3DXCreateTextA(struct IDirect3DDevice9 *device, HDC hdc, const char *text, float deviation,
5173 float extrusion, struct ID3DXMesh **mesh, struct ID3DXBuffer **adjacency, GLYPHMETRICSFLOAT *glyphmetrics)
5174 {
5175 WCHAR *textW;
5176 HRESULT hr;
5177 int len;
5178
5179 TRACE("device %p, hdc %p, text %s, deviation %.8e, extrusion %.8e, mesh %p, adjacency %p, glyphmetrics %p.\n",
5180 device, hdc, debugstr_a(text), deviation, extrusion, mesh, adjacency, glyphmetrics);
5181
5182 if (!text)
5183 return D3DERR_INVALIDCALL;
5184
5185 len = MultiByteToWideChar(CP_ACP, 0, text, -1, NULL, 0);
5186 textW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5187 MultiByteToWideChar(CP_ACP, 0, text, -1, textW, len);
5188
5189 hr = D3DXCreateTextW(device, hdc, textW, deviation, extrusion,
5190 mesh, adjacency, glyphmetrics);
5191 HeapFree(GetProcessHeap(), 0, textW);
5192
5193 return hr;
5194 }
5195
5196 HRESULT WINAPI D3DXCreateTorus(struct IDirect3DDevice9 *device,
5197 float innerradius, float outerradius, UINT sides, UINT rings, struct ID3DXMesh **mesh, ID3DXBuffer **adjacency)
5198 {
5199 HRESULT hr;
5200 ID3DXMesh *torus;
5201 WORD (*faces)[3];
5202 struct vertex *vertices;
5203 float phi, phi_step, sin_phi, cos_phi;
5204 float theta, theta_step, sin_theta, cos_theta;
5205 unsigned int i, j, numvert, numfaces;
5206
5207 TRACE("device %p, innerradius %.8e, outerradius %.8e, sides %u, rings %u, mesh %p, adjacency %p.\n",
5208 device, innerradius, outerradius, sides, rings, mesh, adjacency);
5209
5210 numvert = sides * rings;
5211 numfaces = numvert * 2;
5212
5213 if (!device || innerradius < 0.0f || outerradius < 0.0f || sides < 3 || rings < 3 || !mesh)
5214 {
5215 WARN("Invalid arguments.\n");
5216 return D3DERR_INVALIDCALL;
5217 }
5218
5219 if (FAILED(hr = D3DXCreateMeshFVF(numfaces, numvert, D3DXMESH_MANAGED, D3DFVF_XYZ | D3DFVF_NORMAL, device, &torus)))
5220 return hr;
5221
5222 if (FAILED(hr = torus->lpVtbl->LockVertexBuffer(torus, 0, (void **)&vertices)))
5223 {
5224 torus->lpVtbl->Release(torus);
5225 return hr;
5226 }
5227
5228 if (FAILED(hr = torus->lpVtbl->LockIndexBuffer(torus, 0, (void **)&faces)))
5229 {
5230 torus->lpVtbl->UnlockVertexBuffer(torus);
5231 torus->lpVtbl->Release(torus);
5232 return hr;
5233 }
5234
5235 phi_step = D3DX_PI / sides * 2.0f;
5236 theta_step = D3DX_PI / rings * -2.0f;
5237
5238 theta = 0.0f;
5239
5240 for (i = 0; i < rings; ++i)
5241 {
5242 phi = 0.0f;
5243
5244 sin_theta = sinf(theta);
5245 cos_theta = cosf(theta);
5246
5247 for (j = 0; j < sides; ++j)
5248 {
5249 sin_phi = sinf(phi);
5250 cos_phi = cosf(phi);
5251
5252 vertices[i * sides + j].position.x = (innerradius * cos_phi + outerradius) * cos_theta;
5253 vertices[i * sides + j].position.y = (innerradius * cos_phi + outerradius) * sin_theta;
5254 vertices[i * sides + j].position.z = innerradius * sin_phi;
5255 vertices[i * sides + j].normal.x = cos_phi * cos_theta;
5256 vertices[i * sides + j].normal.y = cos_phi * sin_theta;
5257 vertices[i * sides + j].normal.z = sin_phi;
5258
5259 phi += phi_step;
5260 }
5261
5262 theta += theta_step;
5263 }
5264
5265 for (i = 0; i < numfaces - sides * 2; ++i)
5266 {
5267 faces[i][0] = i % 2 ? i / 2 + sides : i / 2;
5268 faces[i][1] = (i / 2 + 1) % sides ? i / 2 + 1 : i / 2 + 1 - sides;
5269 faces[i][2] = (i + 1) % (sides * 2) ? (i + 1) / 2 + sides : (i + 1) / 2;
5270 }
5271
5272 for (j = 0; i < numfaces; ++i, ++j)
5273 {
5274 faces[i][0] = i % 2 ? j / 2 : i / 2;
5275 faces[i][1] = (i / 2 + 1) % sides ? i / 2 + 1 : i / 2 + 1 - sides;
5276 faces[i][2] = i == numfaces - 1 ? 0 : (j + 1) / 2;
5277 }
5278
5279 torus->lpVtbl->UnlockIndexBuffer(torus);
5280 torus->lpVtbl->UnlockVertexBuffer(torus);
5281
5282 if (adjacency)
5283 {
5284 if (FAILED(hr = D3DXCreateBuffer(numfaces * sizeof(DWORD) * 3, adjacency)))
5285 {
5286 torus->lpVtbl->Release(torus);
5287 return hr;
5288 }
5289
5290 if (FAILED(hr = torus->lpVtbl->GenerateAdjacency(torus, 0.0f, (*adjacency)->lpVtbl->GetBufferPointer(*adjacency))))
5291 {
5292 (*adjacency)->lpVtbl->Release(*adjacency);
5293 torus->lpVtbl->Release(torus);
5294 return hr;
5295 }
5296 }
5297
5298 *mesh = torus;
5299
5300 return D3D_OK;
5301 }
5302
5303 enum pointtype {
5304 POINTTYPE_CURVE = 0,
5305 POINTTYPE_CORNER,
5306 POINTTYPE_CURVE_START,
5307 POINTTYPE_CURVE_END,
5308 POINTTYPE_CURVE_MIDDLE,
5309 };
5310
5311 struct point2d
5312 {
5313 D3DXVECTOR2 pos;
5314 enum pointtype corner;
5315 };
5316
5317 struct dynamic_array
5318 {
5319 int count, capacity;
5320 void *items;
5321 };
5322
5323 /* is a dynamic_array */
5324 struct outline
5325 {
5326 int count, capacity;
5327 struct point2d *items;
5328 };
5329
5330 /* is a dynamic_array */
5331 struct outline_array
5332 {
5333 int count, capacity;
5334 struct outline *items;
5335 };
5336
5337 struct face_array
5338 {
5339 int count;
5340 face *items;
5341 };
5342
5343 struct point2d_index
5344 {
5345 struct outline *outline;
5346 int vertex;
5347 };
5348
5349 struct point2d_index_array
5350 {
5351 int count;
5352 struct point2d_index *items;
5353 };
5354
5355 struct glyphinfo
5356 {
5357 struct outline_array outlines;
5358 struct face_array faces;
5359 struct point2d_index_array ordered_vertices;
5360 float offset_x;
5361 };
5362
5363 /* is an dynamic_array */
5364 struct word_array
5365 {
5366 int count, capacity;
5367 WORD *items;
5368 };
5369
5370 /* complex polygons are split into monotone polygons, which have
5371 * at most 2 intersections with the vertical sweep line */
5372 struct triangulation
5373 {
5374 struct word_array vertex_stack;
5375 BOOL last_on_top, merging;
5376 };
5377
5378 /* is an dynamic_array */
5379 struct triangulation_array
5380 {
5381 int count, capacity;
5382 struct triangulation *items;
5383
5384 struct glyphinfo *glyph;
5385 };
5386
5387 static BOOL reserve(struct dynamic_array *array, int count, int itemsize)
5388 {
5389 if (count > array->capacity) {
5390 void *new_buffer;
5391 int new_capacity;
5392 if (array->items && array->capacity) {
5393 new_capacity = max(array->capacity * 2, count);
5394 new_buffer = HeapReAlloc(GetProcessHeap(), 0, array->items, new_capacity * itemsize);
5395 } else {
5396 new_capacity = max(16, count);
5397 new_buffer = HeapAlloc(GetProcessHeap(), 0, new_capacity * itemsize);
5398 }
5399 if (!new_buffer)
5400 return FALSE;
5401 array->items = new_buffer;
5402 array->capacity = new_capacity;
5403 }
5404 return TRUE;
5405 }
5406
5407 static struct point2d *add_points(struct outline *array, int num)
5408 {
5409 struct point2d *item;
5410
5411 if (!reserve((struct dynamic_array *)array, array->count + num, sizeof(array->items[0])))
5412 return NULL;
5413
5414 item = &array->items[array->count];
5415 array->count += num;
5416 return item;
5417 }
5418
5419 static struct outline *add_outline(struct outline_array *array)
5420 {
5421 struct outline *item;
5422
5423 if (!reserve((struct dynamic_array *)array, array->count + 1, sizeof(array->items[0])))
5424 return NULL;
5425
5426 item = &array->items[array->count++];
5427 ZeroMemory(item, sizeof(*item));
5428 return item;
5429 }
5430
5431 static inline face *add_face(struct face_array *array)
5432 {
5433 return &array->items[array->count++];
5434 }
5435
5436 static struct triangulation *add_triangulation(struct triangulation_array *array)
5437 {
5438 struct triangulation *item;
5439
5440 if (!reserve((struct dynamic_array *)array, array->count + 1, sizeof(array->items[0])))
5441 return NULL;
5442
5443 item = &array->items[array->count++];
5444 ZeroMemory(item, sizeof(*item));
5445 return item;
5446 }
5447
5448 static HRESULT add_vertex_index(struct word_array *array, WORD vertex_index)
5449 {
5450 if (!reserve((struct dynamic_array *)array, array->count + 1, sizeof(array->items[0])))
5451 return E_OUTOFMEMORY;
5452
5453 array->items[array->count++] = vertex_index;
5454 return S_OK;
5455 }
5456
5457 /* assume fixed point numbers can be converted to float point in place */
5458 C_ASSERT(sizeof(FIXED) == sizeof(float));
5459 C_ASSERT(sizeof(POINTFX) == sizeof(D3DXVECTOR2));
5460
5461 static inline D3DXVECTOR2 *convert_fixed_to_float(POINTFX *pt, int count, unsigned int emsquare)
5462 {
5463 D3DXVECTOR2 *ret = (D3DXVECTOR2*)pt;
5464 while (count--) {
5465 D3DXVECTOR2 *pt_flt = (D3DXVECTOR2*)pt;
5466 pt_flt->x = (pt->x.value + pt->x.fract / (float)0x10000) / emsquare;
5467 pt_flt->y = (pt->y.value + pt->y.fract / (float)0x10000) / emsquare;
5468 pt++;
5469 }
5470 return ret;
5471 }
5472
5473 static HRESULT add_bezier_points(struct outline *outline, const D3DXVECTOR2 *p1,
5474 const D3DXVECTOR2 *p2, const D3DXVECTOR2 *p3,
5475 float max_deviation_sq)
5476 {
5477 D3DXVECTOR2 split1 = {0, 0}, split2 = {0, 0}, middle, vec;
5478 float deviation_sq;
5479
5480 D3DXVec2Scale(&split1, D3DXVec2Add(&split1, p1, p2), 0.5f);
5481 D3DXVec2Scale(&split2, D3DXVec2Add(&split2, p2, p3), 0.5f);
5482 D3DXVec2Scale(&middle, D3DXVec2Add(&middle, &split1, &split2), 0.5f);
5483
5484 deviation_sq = D3DXVec2LengthSq(D3DXVec2Subtract(&vec, &middle, p2));
5485 if (deviation_sq < max_deviation_sq) {
5486 struct point2d *pt = add_points(outline, 1);
5487 if (!pt) return E_OUTOFMEMORY;
5488 pt->pos = *p2;
5489 pt->corner = POINTTYPE_CURVE;
5490 /* the end point is omitted because the end line merges into the next segment of
5491 * the split bezier curve, and the end of the split bezier curve is added outside
5492 * this recursive function. */
5493 } else {
5494 HRESULT hr = add_bezier_points(outline, p1, &split1, &middle, max_deviation_sq);
5495 if (hr != S_OK) return hr;
5496 hr = add_bezier_points(outline, &middle, &split2, p3, max_deviation_sq);
5497 if (hr != S_OK) return hr;
5498 }
5499
5500 return S_OK;
5501 }
5502
5503 static inline BOOL is_direction_similar(D3DXVECTOR2 *dir1, D3DXVECTOR2 *dir2, float cos_theta)
5504 {
5505 /* dot product = cos(theta) */
5506 return D3DXVec2Dot(dir1, dir2) > cos_theta;
5507 }
5508
5509 static inline D3DXVECTOR2 *unit_vec2(D3DXVECTOR2 *dir, const D3DXVECTOR2 *pt1, const D3DXVECTOR2 *pt2)
5510 {
5511 return D3DXVec2Normalize(D3DXVec2Subtract(dir, pt2, pt1), dir);
5512 }
5513
5514 struct cos_table
5515 {
5516 float cos_half;
5517 float cos_45;
5518 float cos_90;
5519 };
5520
5521 static BOOL attempt_line_merge(struct outline *outline,
5522 int pt_index,
5523 const D3DXVECTOR2 *nextpt,
5524 BOOL to_curve,
5525 const struct cos_table *table)
5526 {
5527 D3DXVECTOR2 curdir, lastdir;
5528 struct point2d *prevpt, *pt;
5529 BOOL ret = FALSE;
5530
5531 pt = &outline->items[pt_index];
5532 pt_index = (pt_index - 1 + outline->count) % outline->count;
5533 prevpt = &outline->items[pt_index];
5534
5535 if (to_curve)
5536 pt->corner = pt->corner != POINTTYPE_CORNER ? POINTTYPE_CURVE_MIDDLE : POINTTYPE_CURVE_START;
5537
5538 if (outline->count < 2)
5539 return FALSE;
5540
5541 /* remove last point if the next line continues the last line */
5542 unit_vec2(&lastdir, &prevpt->pos, &pt->pos);
5543 unit_vec2(&curdir, &pt->pos, nextpt);
5544 if (is_direction_similar(&lastdir, &curdir, table->cos_half))
5545 {
5546 outline->count--;
5547 if (pt->corner == POINTTYPE_CURVE_END)
5548 prevpt->corner = pt->corner;
5549 if (prevpt->corner == POINTTYPE_CURVE_END && to_curve)
5550 prevpt->corner = POINTTYPE_CURVE_MIDDLE;
5551 pt = prevpt;
5552
5553 ret = TRUE;
5554 if (outline->count < 2)
5555 return ret;
5556
5557 pt_index = (pt_index - 1 + outline->count) % outline->count;
5558 prevpt = &outline->items[pt_index];
5559 unit_vec2(&lastdir, &prevpt->pos, &pt->pos);
5560 unit_vec2(&curdir, &pt->pos, nextpt);
5561 }
5562 return ret;
5563 }
5564
5565 static HRESULT create_outline(struct glyphinfo *glyph, void *raw_outline, int datasize,
5566 float max_deviation_sq, unsigned int emsquare,
5567 const struct cos_table *cos_table)
5568 {
5569 TTPOLYGONHEADER *header = (TTPOLYGONHEADER *)raw_outline;
5570
5571 while ((char *)header < (char *)raw_outline + datasize)
5572 {
5573 TTPOLYCURVE *curve = (TTPOLYCURVE *)(header + 1);
5574 struct point2d *lastpt, *pt;
5575 D3DXVECTOR2 lastdir;
5576 D3DXVECTOR2 *pt_flt;
5577 int j;
5578 struct outline *outline = add_outline(&glyph->outlines);
5579
5580 if (!outline)
5581 return E_OUTOFMEMORY;
5582
5583 pt = add_points(outline, 1);
5584 if (!pt)
5585 return E_OUTOFMEMORY;
5586 pt_flt = convert_fixed_to_float(&header->pfxStart, 1, emsquare);
5587 pt->pos = *pt_flt;
5588 pt->corner = POINTTYPE_CORNER;
5589
5590 if (header->dwType != TT_POLYGON_TYPE)
5591 FIXME("Unknown header type %d\n", header->dwType);
5592
5593 while ((char *)curve < (char *)header + header->cb)
5594 {
5595 D3DXVECTOR2 bezier_start = outline->items[outline->count - 1].pos;
5596 BOOL to_curve = curve->wType != TT_PRIM_LINE && curve->cpfx > 1;
5597 unsigned int j2 = 0;
5598
5599 if (!curve->cpfx) {
5600 curve = (TTPOLYCURVE *)&curve->apfx[curve->cpfx];
5601 continue;
5602 }
5603
5604 pt_flt = convert_fixed_to_float(curve->apfx, curve->cpfx, emsquare);
5605
5606 attempt_line_merge(outline, outline->count - 1, &pt_flt[0], to_curve, cos_table);
5607
5608 if (to_curve)
5609 {
5610 HRESULT hr;
5611 int count = curve->cpfx;
5612
5613 while (count > 2)
5614 {
5615 D3DXVECTOR2 bezier_end;
5616
5617 D3DXVec2Scale(&bezier_end, D3DXVec2Add(&bezier_end, &pt_flt[j2], &pt_flt[j2+1]), 0.5f);
5618 hr = add_bezier_points(outline, &bezier_start, &pt_flt[j2], &bezier_end, max_deviation_sq);
5619 if (hr != S_OK)
5620 return hr;
5621 bezier_start = bezier_end;
5622 count--;
5623 j2++;
5624 }
5625 hr = add_bezier_points(outline, &bezier_start, &pt_flt[j2], &pt_flt[j2+1], max_deviation_sq);
5626 if (hr != S_OK)
5627 return hr;
5628
5629 pt = add_points(outline, 1);
5630 if (!pt)
5631 return E_OUTOFMEMORY;
5632 j2++;
5633 pt->pos = pt_flt[j2];
5634 pt->corner = POINTTYPE_CURVE_END;
5635 } else {
5636 pt = add_points(outline, curve->cpfx);
5637 if (!pt)
5638 return E_OUTOFMEMORY;
5639 for (j2 = 0; j2 < curve->cpfx; j2++)
5640 {
5641 pt->pos = pt_flt[j2];
5642 pt->corner = POINTTYPE_CORNER;
5643 pt++;
5644 }
5645 }
5646
5647 curve = (TTPOLYCURVE *)&curve->apfx[curve->cpfx];
5648 }
5649
5650 /* remove last point if the next line continues the last line */
5651 if (outline->count >= 3) {
5652 BOOL to_curve;
5653
5654 lastpt = &outline->items[outline->count - 1];
5655 pt = &outline->items[0];
5656 if (pt->pos.x == lastpt->pos.x && pt->pos.y == lastpt->pos.y) {
5657 if (lastpt->corner == POINTTYPE_CURVE_END)
5658 {
5659 if (pt->corner == POINTTYPE_CURVE_START)
5660 pt->corner = POINTTYPE_CURVE_MIDDLE;
5661 else
5662 pt->corner = POINTTYPE_CURVE_END;
5663 }
5664 outline->count--;
5665 lastpt = &outline->items[outline->count - 1];
5666 } else {
5667 /* outline closed with a line from end to start point */
5668 attempt_line_merge(outline, outline->count - 1, &pt->pos, FALSE, cos_table);
5669 }
5670 lastpt = &outline->items[0];
5671 to_curve = lastpt->corner != POINTTYPE_CORNER && lastpt->corner != POINTTYPE_CURVE_END;
5672 if (lastpt->corner == POINTTYPE_CURVE_START)
5673 lastpt->corner = POINTTYPE_CORNER;
5674 pt = &outline->items[1];
5675 if (attempt_line_merge(outline, 0, &pt->pos, to_curve, cos_table))
5676 *lastpt = outline->items[outline->count];
5677 }
5678
5679 lastpt = &outline->items[outline->count - 1];
5680 pt = &outline->items[0];
5681 unit_vec2(&lastdir, &lastpt->pos, &pt->pos);
5682 for (j = 0; j < outline->count; j++)
5683 {
5684 D3DXVECTOR2 curdir;
5685
5686 lastpt = pt;
5687 pt = &outline->items[(j + 1) % outline->count];
5688 unit_vec2(&curdir, &lastpt->pos, &pt->pos);
5689
5690 switch (lastpt->corner)
5691 {
5692 case POINTTYPE_CURVE_START:
5693 case POINTTYPE_CURVE_END:
5694 if (!is_direction_similar(&lastdir, &curdir, cos_table->cos_45))
5695 lastpt->corner = POINTTYPE_CORNER;
5696 break;
5697 case POINTTYPE_CURVE_MIDDLE:
5698 if (!is_direction_similar(&lastdir, &curdir, cos_table->cos_90))
5699 lastpt->corner = POINTTYPE_CORNER;
5700 else
5701 lastpt->corner = POINTTYPE_CURVE;
5702 break;
5703 default:
5704 break;
5705 }
5706 lastdir = curdir;
5707 }
5708
5709 header = (TTPOLYGONHEADER *)((char *)header + header->cb);
5710 }
5711 return S_OK;
5712 }
5713
5714 /* Get the y-distance from a line to a point */
5715 static float get_line_to_point_y_distance(D3DXVECTOR2 *line_pt1,
5716 D3DXVECTOR2 *line_pt2,
5717 D3DXVECTOR2 *point)
5718 {
5719 D3DXVECTOR2 line_vec = {0, 0};
5720 float line_pt_dx;
5721 float line_y;
5722
5723 D3DXVec2Subtract(&line_vec, line_pt2, line_pt1);
5724 line_pt_dx = point->x - line_pt1->x;
5725 line_y = line_pt1->y + (line_vec.y * line_pt_dx) / line_vec.x;
5726 return point->y - line_y;
5727 }
5728
5729 static D3DXVECTOR2 *get_indexed_point(struct point2d_index *pt_idx)
5730 {
5731 return &pt_idx->outline->items[pt_idx->vertex].pos;
5732 }
5733
5734 static D3DXVECTOR2 *get_ordered_vertex(struct glyphinfo *glyph, WORD index)
5735 {
5736 return get_indexed_point(&glyph->ordered_vertices.items[index]);
5737 }
5738
5739 static void remove_triangulation(struct triangulation_array *array, struct triangulation *item)
5740 {
5741 HeapFree(GetProcessHeap(), 0, item->vertex_stack.items);
5742 MoveMemory(item, item + 1, (char*)&array->items[array->count] - (char*)(item + 1));
5743 array->count--;
5744 }
5745
5746 static HRESULT triangulation_add_point(struct triangulation **t_ptr,
5747 struct triangulation_array *triangulations,
5748 WORD vtx_idx,
5749 BOOL to_top)
5750 {
5751 struct glyphinfo *glyph = triangulations->glyph;
5752 struct triangulation *t = *t_ptr;
5753 HRESULT hr;
5754 face *face;
5755 int f1, f2;
5756
5757 if (t->last_on_top) {
5758 f1 = 1;
5759 f2 = 2;
5760 } else {
5761 f1 = 2;
5762 f2 = 1;
5763 }
5764
5765 if (t->last_on_top != to_top && t->vertex_stack.count > 1) {
5766 /* consume all vertices on the stack */
5767 WORD last_pt = t->vertex_stack.items[0];
5768 int i;
5769 for (i = 1; i < t->vertex_stack.count; i++)
5770 {
5771 face = add_face(&glyph->faces);
5772 if (!face) return E_OUTOFMEMORY;
5773 (*face)[0] = vtx_idx;
5774 (*face)[f1] = last_pt;
5775 (*face)[f2] = last_pt = t->vertex_stack.items[i];
5776 }
5777 t->vertex_stack.items[0] = last_pt;
5778 t->vertex_stack.count = 1;
5779 } else if (t->vertex_stack.count > 1) {
5780 int i = t->vertex_stack.count - 1;
5781 D3DXVECTOR2 *point = get_ordered_vertex(glyph, vtx_idx);
5782 WORD top_idx = t->vertex_stack.items[i--];
5783 D3DXVECTOR2 *top_pt = get_ordered_vertex(glyph, top_idx);
5784
5785 while (i >= 0)
5786 {
5787 WORD prev_idx = t->vertex_stack.items[i--];
5788 D3DXVECTOR2 *prev_pt = get_ordered_vertex(glyph, prev_idx);
5789
5790 if (prev_pt->x != top_pt->x &&
5791 ((to_top && get_line_to_point_y_distance(prev_pt, top_pt, point) > 0) ||
5792 (!to_top && get_line_to_point_y_distance(prev_pt, top_pt, point) < 0)))
5793 break;
5794
5795 face = add_face(&glyph->faces);
5796 if (!face) return E_OUTOFMEMORY;
5797 (*face)[0] = vtx_idx;
5798 (*face)[f1] = prev_idx;
5799 (*face)[f2] = top_idx;
5800
5801 top_pt = prev_pt;
5802 top_idx = prev_idx;
5803 t->vertex_stack.count--;
5804 }
5805 }
5806 t->last_on_top = to_top;
5807
5808 hr = add_vertex_index(&t->vertex_stack, vtx_idx);
5809
5810 if (hr == S_OK && t->merging) {
5811 struct triangulation *t2;
5812
5813 t2 = to_top ? t - 1 : t + 1;
5814 t2->merging = FALSE;
5815 hr = triangulation_add_point(&t2, triangulations, vtx_idx, to_top);
5816 if (hr != S_OK) return hr;
5817 remove_triangulation(triangulations, t);
5818 if (t2 > t)
5819 t2--;
5820 *t_ptr = t2;
5821 }
5822 return hr;
5823 }
5824
5825 /* check if the point is next on the outline for either the top or bottom */
5826 static D3DXVECTOR2 *triangulation_get_next_point(struct triangulation *t, struct glyphinfo *glyph, BOOL on_top)
5827 {
5828 int i = t->last_on_top == on_top ? t->vertex_stack.count - 1 : 0;
5829 WORD idx = t->vertex_stack.items[i];
5830 struct point2d_index *pt_idx = &glyph->ordered_vertices.items[idx];
5831 struct outline *outline = pt_idx->outline;
5832
5833 if (on_top)
5834 i = (pt_idx->vertex + outline->count - 1) % outline->count;
5835 else
5836 i = (pt_idx->vertex + 1) % outline->count;
5837
5838 return &outline->items[i].pos;
5839 }
5840
5841 static int compare_vertex_indices(const void *a, const void *b)
5842 {
5843 const struct point2d_index *idx1 = a, *idx2 = b;
5844 const D3DXVECTOR2 *p1 = &idx1->outline->items[idx1->vertex].pos;
5845 const D3DXVECTOR2 *p2 = &idx2->outline->items[idx2->vertex].pos;
5846 float diff = p1->x - p2->x;
5847
5848 if (diff == 0.0f)
5849 diff = p1->y - p2->y;
5850
5851 return diff == 0.0f ? 0 : (diff > 0.0f ? -1 : 1);
5852 }
5853
5854 static HRESULT triangulate(struct triangulation_array *triangulations)
5855 {
5856 int sweep_idx;
5857 HRESULT hr;
5858 struct glyphinfo *glyph = triangulations->glyph;
5859 int nb_vertices = 0;
5860 int i;
5861 struct point2d_index *idx_ptr;
5862
5863 /* Glyphs without outlines do not generate any vertices. */
5864 if (!glyph->outlines.count)
5865 return D3D_OK;
5866
5867 for (i = 0; i < glyph->outlines.count; i++)
5868 nb_vertices += glyph->outlines.items[i].count;
5869
5870 glyph->ordered_vertices.items = HeapAlloc(GetProcessHeap(), 0,
5871 nb_vertices * sizeof(*glyph->ordered_vertices.items));
5872 if (!glyph->ordered_vertices.items)
5873 return E_OUTOFMEMORY;
5874
5875 idx_ptr = glyph->ordered_vertices.items;
5876 for (i = 0; i < glyph->outlines.count; i++)
5877 {
5878 struct outline *outline = &glyph->outlines.items[i];
5879 int j;
5880
5881 idx_ptr->outline = outline;
5882 idx_ptr->vertex = 0;
5883 idx_ptr++;
5884 for (j = outline->count - 1; j > 0; j--)
5885 {
5886 idx_ptr->outline = outline;
5887 idx_ptr->vertex = j;
5888 idx_ptr++;
5889 }
5890 }
5891 glyph->ordered_vertices.count = nb_vertices;
5892
5893 /* Native implementation seems to try to create a triangle fan from
5894 * the first outline point if the glyph only has one outline. */
5895 if (glyph->outlines.count == 1)
5896 {
5897 struct outline *outline = glyph->outlines.items;
5898 D3DXVECTOR2 *base = &outline->items[0].pos;
5899 D3DXVECTOR2 *last = &outline->items[1].pos;
5900 float ccw = 0;
5901
5902 for (i = 2; i < outline->count; i++)
5903 {
5904 D3DXVECTOR2 *next = &outline->items[i].pos;
5905 D3DXVECTOR2 v1 = {0.0f, 0.0f};
5906 D3DXVECTOR2 v2 = {0.0f, 0.0f};
5907
5908 D3DXVec2Subtract(&v1, base, last);
5909 D3DXVec2Subtract(&v2, last, next);
5910 ccw = D3DXVec2CCW(&v1, &v2);
5911 if (ccw > 0.0f)
5912 break;
5913
5914 last = next;
5915 }
5916 if (ccw <= 0)
5917 {
5918 glyph->faces.items = HeapAlloc(GetProcessHeap(), 0,
5919 (outline->count - 2) * sizeof(glyph->faces.items[0]));
5920 if (!glyph->faces.items)
5921 return E_OUTOFMEMORY;
5922
5923 glyph->faces.count = outline->count - 2;
5924 for (i = 0; i < glyph->faces.count; i++)
5925 {
5926 glyph->faces.items[i][0] = 0;
5927 glyph->faces.items[i][1] = i + 1;
5928 glyph->faces.items[i][2] = i + 2;
5929 }
5930 return S_OK;
5931 }
5932 }
5933
5934 /* Perform 2D polygon triangulation for complex glyphs.
5935 * Triangulation is performed using a sweep line concept, from right to left,
5936 * by processing vertices in sorted order. Complex polygons are split into
5937 * monotone polygons which are triangulated separately. */
5938 /* FIXME: The order of the faces is not consistent with the native implementation. */
5939
5940 /* Reserve space for maximum possible faces from triangulation.
5941 * # faces for outer outlines = outline->count - 2
5942 * # faces for inner outlines = outline->count + 2
5943 * There must be at least 1 outer outline. */
5944 glyph->faces.items = HeapAlloc(GetProcessHeap(), 0,
5945 (nb_vertices + glyph->outlines.count * 2 - 4) * sizeof(glyph->faces.items[0]));
5946 if (!glyph->faces.items)
5947 return E_OUTOFMEMORY;
5948
5949 qsort(glyph->ordered_vertices.items, nb_vertices,
5950 sizeof(glyph->ordered_vertices.items[0]), compare_vertex_indices);
5951 for (sweep_idx = 0; sweep_idx < glyph->ordered_vertices.count; sweep_idx++)
5952 {
5953 int start = 0;
5954 int end = triangulations->count;
5955
5956 while (start < end)
5957 {
5958 D3DXVECTOR2 *sweep_vtx = get_ordered_vertex(glyph, sweep_idx);
5959 int current = (start + end) / 2;
5960 struct triangulation *t = &triangulations->items[current];
5961 BOOL on_top_outline = FALSE;
5962 D3DXVECTOR2 *top_next, *bottom_next;
5963 WORD top_idx, bottom_idx;
5964
5965 if (t->merging && t->last_on_top)
5966 top_next = triangulation_get_next_point(t + 1, glyph, TRUE);
5967 else
5968 top_next = triangulation_get_next_point(t, glyph, TRUE);
5969 if (sweep_vtx == top_next)
5970 {
5971 if (t->merging && t->last_on_top)
5972 t++;
5973 hr = triangulation_add_point(&t, triangulations, sweep_idx, TRUE);
5974 if (hr != S_OK) return hr;
5975
5976 if (t + 1 < &triangulations->items[triangulations->count] &&
5977 triangulation_get_next_point(t + 1, glyph, FALSE) == sweep_vtx)
5978 {
5979 /* point also on bottom outline of higher triangulation */
5980 struct triangulation *t2 = t + 1;
5981 hr = triangulation_add_point(&t2, triangulations, sweep_idx, FALSE);
5982 if (hr != S_OK) return hr;
5983
5984 t->merging = TRUE;
5985 t2->merging = TRUE;
5986 }
5987 on_top_outline = TRUE;
5988 }
5989
5990 if (t->merging && !t->last_on_top)
5991 bottom_next = triangulation_get_next_point(t - 1, glyph, FALSE);
5992 else
5993 bottom_next = triangulation_get_next_point(t, glyph, FALSE);
5994 if (sweep_vtx == bottom_next)
5995 {
5996 if (t->merging && !t->last_on_top)
5997 t--;
5998 if (on_top_outline) {
5999 /* outline finished */
6000 remove_triangulation(triangulations, t);
6001 break;
6002 }
6003
6004 hr = triangulation_add_point(&t, triangulations, sweep_idx, FALSE);
6005 if (hr != S_OK) return hr;
6006
6007 if (t > triangulations->items &&
6008 triangulation_get_next_point(t - 1, glyph, TRUE) == sweep_vtx)
6009 {
6010 struct triangulation *t2 = t - 1;
6011 /* point also on top outline of lower triangulation */
6012 hr = triangulation_add_point(&t2, triangulations, sweep_idx, TRUE);
6013 if (hr != S_OK) return hr;
6014 t = t2 + 1; /* t may be invalidated by triangulation merging */
6015
6016 t->merging = TRUE;
6017 t2->merging = TRUE;
6018 }
6019 break;
6020 }
6021 if (on_top_outline)
6022 break;
6023
6024 if (t->last_on_top) {
6025 top_idx = t->vertex_stack.items[t->vertex_stack.count - 1];
6026 bottom_idx = t->vertex_stack.items[0];
6027 } else {
6028 top_idx = t->vertex_stack.items[0];
6029 bottom_idx = t->vertex_stack.items[t->vertex_stack.count - 1];
6030 }
6031
6032 /* check if the point is inside or outside this polygon */
6033 if (get_line_to_point_y_distance(get_ordered_vertex(glyph, top_idx),
6034 top_next, sweep_vtx) > 0)
6035 { /* above */
6036 start = current + 1;
6037 } else if (get_line_to_point_y_distance(get_ordered_vertex(glyph, bottom_idx),
6038 bottom_next, sweep_vtx) < 0)
6039 { /* below */
6040 end = current;
6041 } else if (t->merging) {
6042 /* inside, so cancel merging */
6043 struct triangulation *t2 = t->last_on_top ? t + 1 : t - 1;
6044 t->merging = FALSE;
6045 t2->merging = FALSE;
6046 hr = triangulation_add_point(&t, triangulations, sweep_idx, t->last_on_top);
6047 if (hr != S_OK) return hr;
6048 hr = triangulation_add_point(&t2, triangulations, sweep_idx, t2->last_on_top);
6049 if (hr != S_OK) return hr;
6050 break;
6051 } else {
6052 /* inside, so split polygon into two monotone parts */
6053 struct triangulation *t2 = add_triangulation(triangulations);
6054 if (!t2) return E_OUTOFMEMORY;
6055 MoveMemory(t + 1, t, (char*)(t2 + 1) - (char*)t);
6056 if (t->last_on_top) {
6057 t2 = t + 1;
6058 } else {
6059 t2 = t;
6060 t++;
6061 }
6062
6063 ZeroMemory(&t2->vertex_stack, sizeof(t2->vertex_stack));
6064 hr = add_vertex_index(&t2->vertex_stack, t->vertex_stack.items[t->vertex_stack.count - 1]);
6065 if (hr != S_OK) return hr;
6066 hr = add_vertex_index(&t2->vertex_stack, sweep_idx);
6067 if (hr != S_OK) return hr;
6068 t2->last_on_top = !t->last_on_top;
6069
6070 hr = triangulation_add_point(&t, triangulations, sweep_idx, t->last_on_top);
6071 if (hr != S_OK) return hr;
6072 break;
6073 }
6074 }
6075 if (start >= end)
6076 {
6077 struct triangulation *t;
6078 struct triangulation *t2 = add_triangulation(triangulations);
6079 if (!t2) return E_OUTOFMEMORY;
6080 t = &triangulations->items[start];
6081 MoveMemory(t + 1, t, (char*)(t2 + 1) - (char*)t);
6082 ZeroMemory(t, sizeof(*t));
6083 hr = add_vertex_index(&t->vertex_stack, sweep_idx);
6084 if (hr != S_OK) return hr;
6085 }
6086 }
6087 return S_OK;
6088 }
6089
6090 HRESULT WINAPI D3DXCreateTextW(struct IDirect3DDevice9 *device, HDC hdc, const WCHAR *text, float deviation,
6091 float extrusion, struct ID3DXMesh **mesh_ptr, struct ID3DXBuffer **adjacency, GLYPHMETRICSFLOAT *glyphmetrics)
6092 {
6093 HRESULT hr;
6094 ID3DXMesh *mesh = NULL;
6095 DWORD nb_vertices, nb_faces;
6096 DWORD nb_front_faces, nb_corners, nb_outline_points;
6097 struct vertex *vertices = NULL;
6098 face *faces = NULL;
6099 int textlen = 0;
6100 float offset_x;
6101 LOGFONTW lf;
6102 OUTLINETEXTMETRICW otm;
6103 HFONT font = NULL, oldfont = NULL;
6104 const MAT2 identity = {{0, 1}, {0, 0}, {0, 0}, {0, 1}};
6105 void *raw_outline = NULL;
6106 int bufsize = 0;
6107 struct glyphinfo *glyphs = NULL;
6108 GLYPHMETRICS gm;
6109 struct triangulation_array triangulations = {0, 0, NULL};
6110 int i;
6111 struct vertex *vertex_ptr;
6112 face *face_ptr;
6113 float max_deviation_sq;
6114 const struct cos_table cos_table = {
6115 cosf(D3DXToRadian(0.5f)),
6116 cosf(D3DXToRadian(45.0f)),
6117 cosf(D3DXToRadian(90.0f)),
6118 };
6119 int f1, f2;
6120
6121 TRACE("(%p, %p, %s, %f, %f, %p, %p, %p)\n", device, hdc,
6122 debugstr_w(text), deviation, extrusion, mesh_ptr, adjacency, glyphmetrics);
6123
6124 if (!device || !hdc || !text || !*text || deviation < 0.0f || extrusion < 0.0f || !mesh_ptr)
6125 return D3DERR_INVALIDCALL;
6126
6127 if (adjacency)
6128 {
6129 FIXME("Case of adjacency != NULL not implemented.\n");
6130 return E_NOTIMPL;
6131 }
6132
6133 if (!GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(lf), &lf) ||
6134 !GetOutlineTextMetricsW(hdc, sizeof(otm), &otm))
6135 {
6136 return D3DERR_INVALIDCALL;
6137 }
6138
6139 if (deviation == 0.0f)
6140 deviation = 1.0f / otm.otmEMSquare;
6141 max_deviation_sq = deviation * deviation;
6142
6143 lf.lfHeight = otm.otmEMSquare;
6144 lf.lfWidth = 0;
6145 font = CreateFontIndirectW(&lf);
6146 if (!font) {
6147 hr = E_OUTOFMEMORY;
6148 goto error;
6149 }
6150 oldfont = SelectObject(hdc, font);
6151
6152 textlen = strlenW(text);
6153 for (i = 0; i < textlen; i++)
6154 {
6155 int datasize = GetGlyphOutlineW(hdc, text[i], GGO_NATIVE, &gm, 0, NULL, &identity);
6156 if (datasize < 0)
6157 return D3DERR_INVALIDCALL;
6158 if (bufsize < datasize)
6159 bufsize = datasize;
6160 }
6161 if (!bufsize) { /* e.g. text == " " */
6162 hr = D3DERR_INVALIDCALL;
6163 goto error;
6164 }
6165
6166 glyphs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, textlen * sizeof(*glyphs));
6167 raw_outline = HeapAlloc(GetProcessHeap(), 0, bufsize);
6168 if (!glyphs || !raw_outline) {
6169 hr = E_OUTOFMEMORY;
6170 goto error;
6171 }
6172
6173 offset_x = 0.0f;
6174 for (i = 0; i < textlen; i++)
6175 {
6176 /* get outline points from data returned from GetGlyphOutline */
6177 int datasize;
6178
6179 glyphs[i].offset_x = offset_x;
6180
6181 datasize = GetGlyphOutlineW(hdc, text[i], GGO_NATIVE, &gm, bufsize, raw_outline, &identity);
6182 hr = create_outline(&glyphs[i], raw_outline, datasize,
6183 max_deviation_sq, otm.otmEMSquare, &cos_table);
6184 if (hr != S_OK) goto error;
6185
6186 triangulations.glyph = &glyphs[i];
6187 hr = triangulate(&triangulations);
6188 if (hr != S_OK) goto error;
6189 if (triangulations.count) {
6190 ERR("%d incomplete triangulations of glyph (%u).\n", triangulations.count, text[i]);
6191 triangulations.count = 0;
6192 }
6193
6194 if (glyphmetrics)
6195 {
6196 glyphmetrics[i].gmfBlackBoxX = gm.gmBlackBoxX / (float)otm.otmEMSquare;
6197 glyphmetrics[i].gmfBlackBoxY = gm.gmBlackBoxY / (float)otm.otmEMSquare;
6198 glyphmetrics[i].gmfptGlyphOrigin.x = gm.gmptGlyphOrigin.x / (float)otm.otmEMSquare;
6199 glyphmetrics[i].gmfptGlyphOrigin.y = gm.gmptGlyphOrigin.y / (float)otm.otmEMSquare;
6200 glyphmetrics[i].gmfCellIncX = gm.gmCellIncX / (float)otm.otmEMSquare;
6201 glyphmetrics[i].gmfCellIncY = gm.gmCellIncY / (float)otm.otmEMSquare;
6202 }
6203 offset_x += gm.gmCellIncX / (float)otm.otmEMSquare;
6204 }
6205
6206 /* corner points need an extra vertex for the different side faces normals */
6207 nb_corners = 0;
6208 nb_outline_points = 0;
6209 nb_front_faces = 0;
6210 for (i = 0; i < textlen; i++)
6211 {
6212 int j;
6213 nb_outline_points += glyphs[i].ordered_vertices.count;
6214 nb_front_faces += glyphs[i].faces.count;
6215 for (j = 0; j < glyphs[i].outlines.count; j++)
6216 {
6217 int k;
6218 struct outline *outline = &glyphs[i].outlines.items[j];
6219 nb_corners++; /* first outline point always repeated as a corner */
6220 for (k = 1; k < outline->count; k++)
6221 if (outline->items[k].corner)
6222 nb_corners++;
6223 }
6224 }
6225
6226 nb_vertices = (nb_outline_points + nb_corners) * 2 + nb_outline_points * 2;
6227 nb_faces = nb_outline_points * 2 + nb_front_faces * 2;
6228
6229
6230 hr = D3DXCreateMeshFVF(nb_faces, nb_vertices, D3DXMESH_MANAGED,
6231 D3DFVF_XYZ | D3DFVF_NORMAL, device, &mesh);
6232 if (FAILED(hr))
6233 goto error;
6234
6235 if (FAILED(hr = mesh->lpVtbl->LockVertexBuffer(mesh, 0, (void **)&vertices)))
6236 goto error;
6237
6238 if (FAILED(hr = mesh->lpVtbl->LockIndexBuffer(mesh, 0, (void **)&faces)))
6239 goto error;
6240
6241 /* convert 2D vertices and faces into 3D mesh */
6242 vertex_ptr = vertices;
6243 face_ptr = faces;
6244 if (extrusion == 0.0f) {
6245 f1 = 1;
6246 f2 = 2;
6247 } else {
6248 f1 = 2;
6249 f2 = 1;
6250 }
6251 for (i = 0; i < textlen; i++)
6252 {
6253 int j;
6254 int count;
6255 struct vertex *back_vertices;
6256 face *back_faces;
6257
6258 /* side vertices and faces */
6259 for (j = 0; j < glyphs[i].outlines.count; j++)
6260 {
6261 struct vertex *outline_vertices = vertex_ptr;
6262 struct outline *outline = &glyphs[i].outlines.items[j];
6263 int k;
6264 struct point2d *prevpt = &outline->items[outline->count - 1];
6265 struct point2d *pt = &outline->items[0];
6266
6267 for (k = 1; k <= outline->count; k++)
6268 {
6269 struct vertex vtx;
6270 struct point2d *nextpt = &outline->items[k % outline->count];
6271 WORD vtx_idx = vertex_ptr - vertices;
6272 D3DXVECTOR2 vec;
6273
6274 if (pt->corner == POINTTYPE_CURVE_START)
6275 D3DXVec2Subtract(&vec, &pt->pos, &prevpt->pos);
6276 else if (pt->corner)
6277 D3DXVec2Subtract(&vec, &nextpt->pos, &pt->pos);
6278 else
6279 D3DXVec2Subtract(&vec, &nextpt->pos, &prevpt->pos);
6280 D3DXVec2Normalize(&vec, &vec);
6281 vtx.normal.x = -vec.y;
6282 vtx.normal.y = vec.x;
6283 vtx.normal.z = 0;
6284
6285 vtx.position.x = pt->pos.x + glyphs[i].offset_x;
6286 vtx.position.y = pt->pos.y;
6287 vtx.position.z = 0;
6288 *vertex_ptr++ = vtx;
6289
6290 vtx.position.z = -extrusion;
6291 *vertex_ptr++ = vtx;
6292
6293 vtx.position.x = nextpt->pos.x + glyphs[i].offset_x;
6294 vtx.position.y = nextpt->pos.y;
6295 if (pt->corner && nextpt->corner && nextpt->corner != POINTTYPE_CURVE_END) {
6296 vtx.position.z = -extrusion;
6297 *vertex_ptr++ = vtx;
6298 vtx.position.z = 0;
6299 *vertex_ptr++ = vtx;
6300
6301 (*face_ptr)[0] = vtx_idx;
6302 (*face_ptr)[1] = vtx_idx + 2;
6303 (*face_ptr)[2] = vtx_idx + 1;
6304 face_ptr++;
6305
6306 (*face_ptr)[0] = vtx_idx;
6307 (*face_ptr)[1] = vtx_idx + 3;
6308 (*face_ptr)[2] = vtx_idx + 2;
6309 face_ptr++;
6310 } else {
6311 if (nextpt->corner) {
6312 if (nextpt->corner == POINTTYPE_CURVE_END) {
6313 D3DXVECTOR2 *nextpt2 = &outline->items[(k + 1) % outline->count].pos;
6314 D3DXVec2Subtract(&vec, nextpt2, &nextpt->pos);
6315 } else {
6316 D3DXVec2Subtract(&vec, &nextpt->pos, &pt->pos);
6317 }
6318 D3DXVec2Normalize(&vec, &vec);
6319 vtx.normal.x = -vec.y;
6320 vtx.normal.y = vec.x;
6321
6322 vtx.position.z = 0;
6323 *vertex_ptr++ = vtx;
6324 vtx.position.z = -extrusion;
6325 *vertex_ptr++ = vtx;
6326 }
6327
6328 (*face_ptr)[0] = vtx_idx;
6329 (*face_ptr)[1] = vtx_idx + 3;
6330 (*face_ptr)[2] = vtx_idx + 1;
6331 face_ptr++;
6332
6333 (*face_ptr)[0] = vtx_idx;
6334 (*face_ptr)[1] = vtx_idx + 2;
6335 (*face_ptr)[2] = vtx_idx + 3;
6336 face_ptr++;
6337 }
6338
6339 prevpt = pt;
6340 pt = nextpt;
6341 }
6342 if (!pt->corner) {
6343 *vertex_ptr++ = *outline_vertices++;
6344 *vertex_ptr++ = *outline_vertices++;
6345 }
6346 }
6347
6348 /* back vertices and faces */
6349 back_faces = face_ptr;
6350 back_vertices = vertex_ptr;
6351 for (j = 0; j < glyphs[i].ordered_vertices.count; j++)
6352 {
6353 D3DXVECTOR2 *pt = get_ordered_vertex(&glyphs[i], j);
6354 vertex_ptr->position.x = pt->x + glyphs[i].offset_x;
6355 vertex_ptr->position.y = pt->y;
6356 vertex_ptr->position.z = 0;
6357 vertex_ptr->normal.x = 0;
6358 vertex_ptr->normal.y = 0;
6359 vertex_ptr->normal.z = 1;
6360 vertex_ptr++;
6361 }
6362 count = back_vertices - vertices;
6363 for (j = 0; j < glyphs[i].faces.count; j++)
6364 {
6365 face *f = &glyphs[i].faces.items[j];
6366 (*face_ptr)[0] = (*f)[0] + count;
6367 (*face_ptr)[1] = (*f)[1] + count;
6368 (*face_ptr)[2] = (*f)[2] + count;
6369 face_ptr++;
6370 }
6371
6372 /* front vertices and faces */
6373 j = count = vertex_ptr - back_vertices;
6374 while (j--)
6375 {
6376 vertex_ptr->position.x = back_vertices->position.x;
6377 vertex_ptr->position.y = back_vertices->position.y;
6378 vertex_ptr->position.z = -extrusion;
6379 vertex_ptr->normal.x = 0;
6380 vertex_ptr->normal.y = 0;
6381 vertex_ptr->normal.z = extrusion == 0.0f ? 1.0f : -1.0f;
6382 vertex_ptr++;
6383 back_vertices++;
6384 }
6385 j = face_ptr - back_faces;
6386 while (j--)
6387 {
6388 (*face_ptr)[0] = (*back_faces)[0] + count;
6389 (*face_ptr)[1] = (*back_faces)[f1] + count;
6390 (*face_ptr)[2] = (*back_faces)[f2] + count;
6391 face_ptr++;
6392 back_faces++;
6393 }
6394 }
6395
6396 *mesh_ptr = mesh;
6397 hr = D3D_OK;
6398 error:
6399 if (mesh) {
6400 if (faces) mesh->lpVtbl->UnlockIndexBuffer(mesh);
6401 if (vertices) mesh->lpVtbl->UnlockVertexBuffer(mesh);
6402 if (hr != D3D_OK) mesh->lpVtbl->Release(mesh);
6403 }
6404 if (glyphs) {
6405 for (i = 0; i < textlen; i++)
6406 {
6407 int j;
6408 for (j = 0; j < glyphs[i].outlines.count; j++)
6409 HeapFree(GetProcessHeap(), 0, glyphs[i].outlines.items[j].items);
6410 HeapFree(GetProcessHeap(), 0, glyphs[i].outlines.items);
6411 HeapFree(GetProcessHeap(), 0, glyphs[i].faces.items);
6412 HeapFree(GetProcessHeap(), 0, glyphs[i].ordered_vertices.items);
6413 }
6414 HeapFree(GetProcessHeap(), 0, glyphs);
6415 }
6416 if (triangulations.items) {
6417 int i;
6418 for (i = 0; i < triangulations.count; i++)
6419 HeapFree(GetProcessHeap(), 0, triangulations.items[i].vertex_stack.items);
6420 HeapFree(GetProcessHeap(), 0, triangulations.items);
6421 }
6422 HeapFree(GetProcessHeap(), 0, raw_outline);
6423 if (oldfont) SelectObject(hdc, oldfont);
6424 if (font) DeleteObject(font);
6425
6426 return hr;
6427 }
6428
6429 HRESULT WINAPI D3DXValidMesh(ID3DXMesh *mesh, const DWORD *adjacency, ID3DXBuffer **errors_and_warnings)
6430 {
6431 FIXME("(%p, %p, %p): stub\n", mesh, adjacency, *errors_and_warnings);
6432
6433 return E_NOTIMPL;
6434 }
6435
6436 static BOOL weld_float1(void *to, void *from, FLOAT epsilon)
6437 {
6438 FLOAT *v1 = to;
6439 FLOAT *v2 = from;
6440
6441 if (fabsf(*v1 - *v2) <= epsilon)
6442 {
6443 *v1 = *v2;
6444
6445 return TRUE;
6446 }
6447
6448 return FALSE;
6449 }
6450
6451 static BOOL weld_float2(void *to, void *from, FLOAT epsilon)
6452 {
6453 D3DXVECTOR2 *v1 = to;
6454 D3DXVECTOR2 *v2 = from;
6455 FLOAT diff_x = fabsf(v1->x - v2->x);
6456 FLOAT diff_y = fabsf(v1->y - v2->y);
6457 FLOAT max_abs_diff = max(diff_x, diff_y);
6458
6459 if (max_abs_diff <= epsilon)
6460 {
6461 memcpy(to, from, sizeof(D3DXVECTOR2));
6462
6463 return TRUE;
6464 }
6465
6466 return FALSE;
6467 }
6468
6469 static BOOL weld_float3(void *to, void *from, FLOAT epsilon)
6470 {
6471 D3DXVECTOR3 *v1 = to;
6472 D3DXVECTOR3 *v2 = from;
6473 FLOAT diff_x = fabsf(v1->x - v2->x);
6474 FLOAT diff_y = fabsf(v1->y - v2->y);
6475 FLOAT diff_z = fabsf(v1->z - v2->z);
6476 FLOAT max_abs_diff = max(diff_x, diff_y);
6477 max_abs_diff = max(diff_z, max_abs_diff);
6478
6479 if (max_abs_diff <= epsilon)
6480 {
6481 memcpy(to, from, sizeof(D3DXVECTOR3));
6482
6483 return TRUE;
6484 }
6485
6486 return FALSE;
6487 }
6488
6489 static BOOL weld_float4(void *to, void *from, FLOAT epsilon)
6490 {
6491 D3DXVECTOR4 *v1 = to;
6492 D3DXVECTOR4 *v2 = from;
6493 FLOAT diff_x = fabsf(v1->x - v2->x);
6494 FLOAT diff_y = fabsf(v1->y - v2->y);
6495 FLOAT diff_z = fabsf(v1->z - v2->z);
6496 FLOAT diff_w = fabsf(v1->w - v2->w);
6497 FLOAT max_abs_diff = max(diff_x, diff_y);
6498 max_abs_diff = max(diff_z, max_abs_diff);
6499 max_abs_diff = max(diff_w, max_abs_diff);
6500
6501 if (max_abs_diff <= epsilon)
6502 {
6503 memcpy(to, from, sizeof(D3DXVECTOR4));
6504
6505 return TRUE;
6506 }
6507
6508 return FALSE;
6509 }
6510
6511 static BOOL weld_ubyte4(void *to, void *from, FLOAT epsilon)
6512 {
6513 BYTE *b1 = to;
6514 BYTE *b2 = from;
6515 BYTE truncated_epsilon = (BYTE)epsilon;
6516 BYTE diff_x = b1[0] > b2[0] ? b1[0] - b2[0] : b2[0] - b1[0];
6517 BYTE diff_y = b1[1] > b2[1] ? b1[1] - b2[1] : b2[1] - b1[1];
6518 BYTE diff_z = b1[2] > b2[2] ? b1[2] - b2[2] : b2[2] - b1[2];
6519 BYTE diff_w = b1[3] > b2[3] ? b1[3] - b2[3] : b2[3] - b1[3];
6520 BYTE max_diff = max(diff_x, diff_y);
6521 max_diff = max(diff_z, max_diff);
6522 max_diff = max(diff_w, max_diff);
6523
6524 if (max_diff <= truncated_epsilon)
6525 {
6526 memcpy(to, from, 4 * sizeof(BYTE));
6527
6528 return TRUE;
6529 }
6530
6531 return FALSE;
6532 }
6533
6534 static BOOL weld_ubyte4n(void *to, void *from, FLOAT epsilon)
6535 {
6536 return weld_ubyte4(to, from, epsilon * UCHAR_MAX);
6537 }
6538
6539 static BOOL weld_d3dcolor(void *to, void *from, FLOAT epsilon)
6540 {
6541 return weld_ubyte4n(to, from, epsilon);
6542 }
6543
6544 static BOOL weld_short2(void *to, void *from, FLOAT epsilon)
6545 {
6546 SHORT *s1 = to;
6547 SHORT *s2 = from;
6548 SHORT truncated_epsilon = (SHORT)epsilon;
6549 SHORT diff_x = abs(s1[0] - s2[0]);
6550 SHORT diff_y = abs(s1[1] - s2[1]);
6551 SHORT max_abs_diff = max(diff_x, diff_y);
6552
6553 if (max_abs_diff <= truncated_epsilon)
6554 {
6555 memcpy(to, from, 2 * sizeof(SHORT));
6556
6557 return TRUE;
6558 }
6559
6560 return FALSE;
6561 }
6562
6563 static BOOL weld_short2n(void *to, void *from, FLOAT epsilon)
6564 {
6565 return weld_short2(to, from, epsilon * SHRT_MAX);
6566 }
6567
6568 static BOOL weld_short4(void *to, void *from, FLOAT epsilon)
6569 {
6570 SHORT *s1 = to;
6571 SHORT *s2 = from;
6572 SHORT truncated_epsilon = (SHORT)epsilon;
6573 SHORT diff_x = abs(s1[0] - s2[0]);
6574 SHORT diff_y = abs(s1[1] - s2[1]);
6575 SHORT diff_z = abs(s1[2] - s2[2]);
6576 SHORT diff_w = abs(s1[3] - s2[3]);
6577 SHORT max_abs_diff = max(diff_x, diff_y);
6578 max_abs_diff = max(diff_z, max_abs_diff);
6579 max_abs_diff = max(diff_w, max_abs_diff);
6580
6581 if (max_abs_diff <= truncated_epsilon)
6582 {
6583 memcpy(to, from, 4 * sizeof(SHORT));
6584
6585 return TRUE;
6586 }
6587
6588 return FALSE;
6589 }
6590
6591 static BOOL weld_short4n(void *to, void *from, FLOAT epsilon)
6592 {
6593 return weld_short4(to, from, epsilon * SHRT_MAX);
6594 }
6595
6596 static BOOL weld_ushort2n(void *to, void *from, FLOAT epsilon)
6597 {
6598 USHORT *s1 = to;
6599 USHORT *s2 = from;
6600 USHORT scaled_epsilon = (USHORT)(epsilon * USHRT_MAX);
6601 USHORT diff_x = s1[0] > s2[0] ? s1[0] - s2[0] : s2[0] - s1[0];
6602 USHORT diff_y = s1[1] > s2[1] ? s1[1] - s2[1] : s2[1] - s1[1];
6603 USHORT max_diff = max(diff_x, diff_y);
6604
6605 if (max_diff <= scaled_epsilon)
6606 {
6607 memcpy(to, from, 2 * sizeof(USHORT));
6608
6609 return TRUE;
6610 }
6611
6612 return FALSE;
6613 }
6614
6615 static BOOL weld_ushort4n(void *to, void *from, FLOAT epsilon)
6616 {
6617 USHORT *s1 = to;
6618 USHORT *s2 = from;
6619 USHORT scaled_epsilon = (USHORT)(epsilon * USHRT_MAX);
6620 USHORT diff_x = s1[0] > s2[0] ? s1[0] - s2[0] : s2[0] - s1[0];
6621 USHORT diff_y = s1[1] > s2[1] ? s1[1] - s2[1] : s2[1] - s1[1];
6622 USHORT diff_z = s1[2] > s2[2] ? s1[2] - s2[2] : s2[2] - s1[2];
6623 USHORT diff_w = s1[3] > s2[3] ? s1[3] - s2[3] : s2[3] - s1[3];
6624 USHORT max_diff = max(diff_x, diff_y);
6625 max_diff = max(diff_z, max_diff);
6626 max_diff = max(diff_w, max_diff);
6627
6628 if (max_diff <= scaled_epsilon)
6629 {
6630 memcpy(to, from, 4 * sizeof(USHORT));
6631
6632 return TRUE;
6633 }
6634
6635 return FALSE;
6636 }
6637
6638 struct udec3
6639 {
6640 UINT x;
6641 UINT y;
6642 UINT z;
6643 UINT w;
6644 };
6645
6646 static struct udec3 dword_to_udec3(DWORD d)
6647 {
6648 struct udec3 v;
6649
6650 v.x = d & 0x3ff;
6651 v.y = (d & 0xffc00) >> 10;
6652 v.z = (d & 0x3ff00000) >> 20;
6653 v.w = (d & 0xc0000000) >> 30;
6654
6655 return v;
6656 }
6657
6658 static BOOL weld_udec3(void *to, void *from, FLOAT epsilon)
6659 {
6660 DWORD *d1 = to;
6661 DWORD *d2 = from;
6662 struct udec3 v1 = dword_to_udec3(*d1);
6663 struct udec3 v2 = dword_to_udec3(*d2);
6664 UINT truncated_epsilon = (UINT)epsilon;
6665 UINT diff_x = v1.x > v2.x ? v1.x - v2.x : v2.x - v1.x;
6666 UINT diff_y = v1.y > v2.y ? v1.y - v2.y : v2.y - v1.y;
6667 UINT diff_z = v1.z > v2.z ? v1.z - v2.z : v2.z - v1.z;
6668 UINT diff_w = v1.w > v2.w ? v1.w - v2.w : v2.w - v1.w;
6669 UINT max_diff = max(diff_x, diff_y);
6670 max_diff = max(diff_z, max_diff);
6671 max_diff = max(diff_w, max_diff);
6672
6673 if (max_diff <= truncated_epsilon)
6674 {
6675 memcpy(to, from, sizeof(DWORD));
6676
6677 return TRUE;
6678 }
6679
6680 return FALSE;
6681 }
6682
6683 struct dec3n
6684 {
6685 INT x;
6686 INT y;
6687 INT z;
6688 INT w;
6689 };
6690
6691 static struct dec3n dword_to_dec3n(DWORD d)
6692 {
6693 struct dec3n v;
6694
6695 v.x = d & 0x3ff;
6696 v.y = (d & 0xffc00) >> 10;
6697 v.z = (d & 0x3ff00000) >> 20;
6698 v.w = (d & 0xc0000000) >> 30;
6699
6700 return v;
6701 }
6702
6703 static BOOL weld_dec3n(void *to, void *from, FLOAT epsilon)
6704 {
6705 const UINT MAX_DEC3N = 511;
6706 DWORD *d1 = to;
6707 DWORD *d2 = from;
6708 struct dec3n v1 = dword_to_dec3n(*d1);
6709 struct dec3n v2 = dword_to_dec3n(*d2);
6710 INT scaled_epsilon = (INT)(epsilon * MAX_DEC3N);
6711 INT diff_x = abs(v1.x - v2.x);
6712 INT diff_y = abs(v1.y - v2.y);
6713 INT diff_z = abs(v1.z - v2.z);
6714 INT diff_w = abs(v1.w - v2.w);
6715 INT max_abs_diff = max(diff_x, diff_y);
6716 max_abs_diff = max(diff_z, max_abs_diff);
6717 max_abs_diff = max(diff_w, max_abs_diff);
6718
6719 if (max_abs_diff <= scaled_epsilon)
6720 {
6721 memcpy(to, from, sizeof(DWORD));
6722
6723 return TRUE;
6724 }
6725
6726 return FALSE;
6727 }
6728
6729 static BOOL weld_float16_2(void *to, void *from, FLOAT epsilon)
6730 {
6731 D3DXFLOAT16 *v1_float16 = to;
6732 D3DXFLOAT16 *v2_float16 = from;
6733 FLOAT diff_x;
6734 FLOAT diff_y;
6735 FLOAT max_abs_diff;
6736 #define NUM_ELEM 2
6737 FLOAT v1[NUM_ELEM];
6738 FLOAT v2[NUM_ELEM];
6739
6740 D3DXFloat16To32Array(v1, v1_float16, NUM_ELEM);
6741 D3DXFloat16To32Array(v2, v2_float16, NUM_ELEM);
6742
6743 diff_x = fabsf(v1[0] - v2[0]);
6744 diff_y = fabsf(v1[1] - v2[1]);
6745 max_abs_diff = max(diff_x, diff_y);
6746
6747 if (max_abs_diff <= epsilon)
6748 {
6749 memcpy(to, from, NUM_ELEM * sizeof(D3DXFLOAT16));
6750
6751 return TRUE;
6752 }
6753
6754 return FALSE;
6755 #undef NUM_ELEM
6756 }
6757
6758 static BOOL weld_float16_4(void *to, void *from, FLOAT epsilon)
6759 {
6760 D3DXFLOAT16 *v1_float16 = to;
6761 D3DXFLOAT16 *v2_float16 = from;
6762 FLOAT diff_x;
6763 FLOAT diff_y;
6764 FLOAT diff_z;
6765 FLOAT diff_w;
6766 FLOAT max_abs_diff;
6767 #define NUM_ELEM 4
6768 FLOAT v1[NUM_ELEM];
6769 FLOAT v2[NUM_ELEM];
6770
6771 D3DXFloat16To32Array(v1, v1_float16, NUM_ELEM);
6772 D3DXFloat16To32Array(v2, v2_float16, NUM_ELEM);
6773
6774 diff_x = fabsf(v1[0] - v2[0]);
6775 diff_y = fabsf(v1[1] - v2[1]);
6776 diff_z = fabsf(v1[2] - v2[2]);
6777 diff_w = fabsf(v1[3] - v2[3]);
6778 max_abs_diff = max(diff_x, diff_y);
6779 max_abs_diff = max(diff_z, max_abs_diff);
6780 max_abs_diff = max(diff_w, max_abs_diff);
6781
6782 if (max_abs_diff <= epsilon)
6783 {
6784 memcpy(to, from, NUM_ELEM * sizeof(D3DXFLOAT16));
6785
6786 return TRUE;
6787 }
6788
6789 return FALSE;
6790 #undef NUM_ELEM
6791 }
6792
6793 /* Sets the vertex components to the same value if they are within epsilon. */
6794 static BOOL weld_component(void *to, void *from, D3DDECLTYPE type, FLOAT epsilon)
6795 {
6796 /* Quiet FIXMEs as this is in a loop with potentially thousand of iterations. */
6797 BOOL fixme_once_unused = FALSE;
6798 BOOL fixme_once_unknown = FALSE;
6799
6800 switch (type)
6801 {
6802 case D3DDECLTYPE_FLOAT1:
6803 return weld_float1(to, from, epsilon);
6804
6805 case D3DDECLTYPE_FLOAT2:
6806 return weld_float2(to, from, epsilon);
6807
6808 case D3DDECLTYPE_FLOAT3:
6809 return weld_float3(to, from, epsilon);
6810
6811 case D3DDECLTYPE_FLOAT4:
6812 return weld_float4(to, from, epsilon);
6813
6814 case D3DDECLTYPE_D3DCOLOR:
6815 return weld_d3dcolor(to, from, epsilon);
6816
6817 case D3DDECLTYPE_UBYTE4:
6818 return weld_ubyte4(to, from, epsilon);
6819
6820 case D3DDECLTYPE_SHORT2:
6821 return weld_short2(to, from, epsilon);
6822
6823 case D3DDECLTYPE_SHORT4:
6824 return weld_short4(to, from, epsilon);
6825
6826 case D3DDECLTYPE_UBYTE4N:
6827 return weld_ubyte4n(to, from, epsilon);
6828
6829 case D3DDECLTYPE_SHORT2N:
6830 return weld_short2n(to, from, epsilon);
6831
6832 case D3DDECLTYPE_SHORT4N:
6833 return weld_short4n(to, from, epsilon);
6834
6835 case D3DDECLTYPE_USHORT2N:
6836 return weld_ushort2n(to, from, epsilon);
6837
6838 case D3DDECLTYPE_USHORT4N:
6839 return weld_ushort4n(to, from, epsilon);
6840
6841 case D3DDECLTYPE_UDEC3:
6842 return weld_udec3(to, from, epsilon);
6843
6844 case D3DDECLTYPE_DEC3N:
6845 return weld_dec3n(to, from, epsilon);
6846
6847 case D3DDECLTYPE_FLOAT16_2:
6848 return weld_float16_2(to, from, epsilon);
6849
6850 case D3DDECLTYPE_FLOAT16_4:
6851 return weld_float16_4(to, from, epsilon);
6852
6853 case D3DDECLTYPE_UNUSED:
6854 if (!fixme_once_unused++)
6855 FIXME("D3DDECLTYPE_UNUSED welding not implemented.\n");
6856 break;
6857
6858 default:
6859 if (!fixme_once_unknown++)
6860 FIXME("Welding of unknown declaration type %d is not implemented.\n", type);
6861 break;
6862 }
6863
6864 return FALSE;
6865 }
6866
6867 static FLOAT get_component_epsilon(const D3DVERTEXELEMENT9 *decl_ptr, const D3DXWELDEPSILONS *epsilons)
6868 {
6869 FLOAT epsilon = 0.0f;
6870 /* Quiet FIXMEs as this is in a loop with potentially thousand of iterations. */
6871 static BOOL fixme_once_blendindices = FALSE;
6872 static BOOL fixme_once_positiont = FALSE;
6873 static BOOL fixme_once_fog = FALSE;
6874 static BOOL fixme_once_depth = FALSE;
6875 static BOOL fixme_once_sample = FALSE;
6876 static BOOL fixme_once_unknown = FALSE;
6877
6878 switch (decl_ptr->Usage)
6879 {
6880 case D3DDECLUSAGE_POSITION:
6881 epsilon = epsilons->Position;
6882 break;
6883 case D3DDECLUSAGE_BLENDWEIGHT:
6884 epsilon = epsilons->BlendWeights;
6885 break;
6886 case D3DDECLUSAGE_NORMAL:
6887 epsilon = epsilons->Normals;
6888 break;
6889 case D3DDECLUSAGE_PSIZE:
6890 epsilon = epsilons->PSize;
6891 break;
6892 case D3DDECLUSAGE_TEXCOORD:
6893 {
6894 BYTE usage_index = decl_ptr->UsageIndex;
6895 if (usage_index > 7)
6896 usage_index = 7;
6897 epsilon = epsilons->Texcoords[usage_index];
6898 break;
6899 }
6900 case D3DDECLUSAGE_TANGENT:
6901 epsilon = epsilons->Tangent;
6902 break;
6903 case D3DDECLUSAGE_BINORMAL:
6904 epsilon = epsilons->Binormal;
6905 break;
6906 case D3DDECLUSAGE_TESSFACTOR:
6907 epsilon = epsilons->TessFactor;
6908 break;
6909 case D3DDECLUSAGE_COLOR:
6910 if (decl_ptr->UsageIndex == 0)
6911 epsilon = epsilons->Diffuse;
6912 else if (decl_ptr->UsageIndex == 1)
6913 epsilon = epsilons->Specular;
6914 else
6915 epsilon = 1e-6f;
6916 break;
6917 case D3DDECLUSAGE_BLENDINDICES:
6918 if (!fixme_once_blendindices++)
6919 FIXME("D3DDECLUSAGE_BLENDINDICES welding not implemented.\n");
6920 break;
6921 case D3DDECLUSAGE_POSITIONT:
6922 if (!fixme_once_positiont++)
6923 FIXME("D3DDECLUSAGE_POSITIONT welding not implemented.\n");
6924 break;
6925 case D3DDECLUSAGE_FOG:
6926 if (!fixme_once_fog++)
6927 FIXME("D3DDECLUSAGE_FOG welding not implemented.\n");
6928 break;
6929 case D3DDECLUSAGE_DEPTH:
6930 if (!fixme_once_depth++)
6931 FIXME("D3DDECLUSAGE_DEPTH welding not implemented.\n");
6932 break;
6933 case D3DDECLUSAGE_SAMPLE:
6934 if (!fixme_once_sample++)
6935 FIXME("D3DDECLUSAGE_SAMPLE welding not implemented.\n");
6936 break;
6937 default:
6938 if (!fixme_once_unknown++)
6939 FIXME("Unknown usage %x\n", decl_ptr->Usage);
6940 break;
6941 }
6942
6943 return epsilon;
6944 }
6945
6946 /* Helper function for reading a 32-bit index buffer. */
6947 static inline DWORD read_ib(void *index_buffer, BOOL indices_are_32bit,
6948 DWORD index)
6949 {
6950 if (indices_are_32bit)
6951 {
6952 DWORD *indices = index_buffer;
6953 return indices[index];
6954 }
6955 else
6956 {
6957 WORD *indices = index_buffer;
6958 return indices[index];
6959 }
6960 }
6961
6962 /* Helper function for writing to a 32-bit index buffer. */
6963 static inline void write_ib(void *index_buffer, BOOL indices_are_32bit,
6964 DWORD index, DWORD value)
6965 {
6966 if (indices_are_32bit)
6967 {
6968 DWORD *indices = index_buffer;
6969 indices[index] = value;
6970 }
6971 else
6972 {
6973 WORD *indices = index_buffer;
6974 indices[index] = value;
6975 }
6976 }
6977
6978 /*************************************************************************
6979 * D3DXWeldVertices (D3DX9_36.@)
6980 *
6981 * Welds together similar vertices. The similarity between vert-
6982 * ices can be the position and other components such as
6983 * normal and color.
6984 *
6985 * PARAMS
6986 * mesh [I] Mesh which vertices will be welded together.
6987 * flags [I] D3DXWELDEPSILONSFLAGS specifying how to weld.
6988 * epsilons [I] How similar a component needs to be for welding.
6989 * adjacency [I] Which faces are adjacent to other faces.
6990 * adjacency_out [O] Updated adjacency after welding.
6991 * face_remap_out [O] Which faces the old faces have been mapped to.
6992 * vertex_remap_out [O] Which vertices the old vertices have been mapped to.
6993 *
6994 * RETURNS
6995 * Success: D3D_OK.
6996 * Failure: D3DERR_INVALIDCALL, E_OUTOFMEMORY.
6997 *
6998 * BUGS
6999 * Attribute sorting not implemented.
7000 *
7001 */
7002 HRESULT WINAPI D3DXWeldVertices(ID3DXMesh *mesh, DWORD flags, const D3DXWELDEPSILONS *epsilons,
7003 const DWORD *adjacency, DWORD *adjacency_out, DWORD *face_remap_out, ID3DXBuffer **vertex_remap_out)
7004 {
7005 DWORD *adjacency_generated = NULL;
7006 const DWORD *adjacency_ptr;
7007 DWORD *attributes = NULL;
7008 const FLOAT DEFAULT_EPSILON = 1.0e-6f;
7009 HRESULT hr;
7010 DWORD i;
7011 void *indices = NULL;
7012 BOOL indices_are_32bit = mesh->lpVtbl->GetOptions(mesh) & D3DXMESH_32BIT;
7013 DWORD optimize_flags;
7014 DWORD *point_reps = NULL;
7015 struct d3dx9_mesh *This = impl_from_ID3DXMesh(mesh);
7016 DWORD *vertex_face_map = NULL;
7017 BYTE *vertices = NULL;
7018
7019 TRACE("mesh %p, flags %#x, epsilons %p, adjacency %p, adjacency_out %p, face_remap_out %p, vertex_remap_out %p.\n",
7020 mesh, flags, epsilons, adjacency, adjacency_out, face_remap_out, vertex_remap_out);
7021
7022 if (flags == 0)
7023 {
7024 WARN("No flags are undefined. Using D3DXWELDEPSILONS_WELDPARTIALMATCHES instead.\n");
7025 flags = D3DXWELDEPSILONS_WELDPARTIALMATCHES;
7026 }
7027
7028 if (adjacency) /* Use supplied adjacency. */
7029 {
7030 adjacency_ptr = adjacency;
7031 }
7032 else /* Adjacency has to be generated. */
7033 {
7034 adjacency_generated = HeapAlloc(GetProcessHeap(), 0, 3 * This->numfaces * sizeof(*adjacency_generated));
7035 if (!adjacency_generated)
7036 {
7037 ERR("Couldn't allocate memory for adjacency_generated.\n");
7038 hr = E_OUTOFMEMORY;
7039 goto cleanup;
7040 }
7041 hr = mesh->lpVtbl->GenerateAdjacency(mesh, DEFAULT_EPSILON, adjacency_generated);
7042 if (FAILED(hr))
7043 {
7044 ERR("Couldn't generate adjacency.\n");
7045 goto cleanup;
7046 }
7047 adjacency_ptr = adjacency_generated;
7048 }
7049
7050 /* Point representation says which vertices can be replaced. */
7051 point_reps = HeapAlloc(GetProcessHeap(), 0, This->numvertices * sizeof(*point_reps));
7052 if (!point_reps)
7053 {
7054 hr = E_OUTOFMEMORY;
7055 ERR("Couldn't allocate memory for point_reps.\n");
7056 goto cleanup;
7057 }
7058 hr = mesh->lpVtbl->ConvertAdjacencyToPointReps(mesh, adjacency_ptr, point_reps);
7059 if (FAILED(hr))
7060 {
7061 ERR("ConvertAdjacencyToPointReps failed.\n");
7062 goto cleanup;
7063 }
7064
7065 hr = mesh->lpVtbl->LockIndexBuffer(mesh, 0, &indices);
7066 if (FAILED(hr))
7067 {
7068 ERR("Couldn't lock index buffer.\n");
7069 goto cleanup;
7070 }
7071
7072 hr = mesh->lpVtbl->LockAttributeBuffer(mesh, 0, &attributes);
7073 if (FAILED(hr))
7074 {
7075 ERR("Couldn't lock attribute buffer.\n");
7076 goto cleanup;
7077 }
7078 vertex_face_map = HeapAlloc(GetProcessHeap(), 0, This->numvertices * sizeof(*vertex_face_map));
7079 if (!vertex_face_map)
7080 {
7081 hr = E_OUTOFMEMORY;
7082 ERR("Couldn't allocate memory for vertex_face_map.\n");
7083 goto cleanup;
7084 }
7085 /* Build vertex face map, so that a vertex's face can be looked up. */
7086 for (i = 0; i < This->numfaces; i++)
7087 {
7088 DWORD j;
7089 for (j = 0; j < 3; j++)
7090 {
7091 DWORD index = read_ib(indices, indices_are_32bit, 3*i + j);
7092 vertex_face_map[index] = i;
7093 }
7094 }
7095
7096 if (flags & D3DXWELDEPSILONS_WELDPARTIALMATCHES)
7097 {
7098 hr = mesh->lpVtbl->LockVertexBuffer(mesh, 0, (void**)&vertices);
7099 if (FAILED(hr))
7100 {
7101 ERR("Couldn't lock vertex buffer.\n");
7102 goto cleanup;
7103 }
7104 /* For each vertex that can be removed, compare its vertex components
7105 * with the vertex components from the vertex that can replace it. A
7106 * vertex is only fully replaced if all the components match and the
7107 * flag D3DXWELDEPSILONS_DONOTREMOVEVERTICES is not set, and they
7108 * belong to the same attribute group. Otherwise the vertex components
7109 * that are within epsilon are set to the same value.
7110 */
7111 for (i = 0; i < 3 * This->numfaces; i++)
7112 {
7113 D3DVERTEXELEMENT9 *decl_ptr;
7114 DWORD vertex_size = mesh->lpVtbl->GetNumBytesPerVertex(mesh);
7115 DWORD num_vertex_components;
7116 INT matches = 0;
7117 BOOL all_match;
7118 DWORD index = read_ib(indices, indices_are_32bit, i);
7119
7120 for (decl_ptr = This->cached_declaration, num_vertex_components = 0; decl_ptr->Stream != 0xFF; decl_ptr++, num_vertex_components++)
7121 {
7122 BYTE *to = &vertices[vertex_size*index + decl_ptr->Offset];
7123 BYTE *from = &vertices[vertex_size*point_reps[index] + decl_ptr->Offset];
7124 FLOAT epsilon = get_component_epsilon(decl_ptr, epsilons);
7125
7126 /* Don't weld self */
7127 if (index == point_reps[index])
7128 {
7129 matches++;
7130 continue;
7131 }
7132
7133 if (weld_component(to, from, decl_ptr->Type, epsilon))
7134 matches++;
7135 }
7136
7137 all_match = (num_vertex_components == matches);
7138 if (all_match && !(flags & D3DXWELDEPSILONS_DONOTREMOVEVERTICES))
7139 {
7140 DWORD to_face = vertex_face_map[index];
7141 DWORD from_face = vertex_face_map[point_reps[index]];
7142 if(attributes[to_face] != attributes[from_face] && !(flags & D3DXWELDEPSILONS_DONOTSPLIT))
7143 continue;
7144 write_ib(indices, indices_are_32bit, i, point_reps[index]);
7145 }
7146 }
7147 mesh->lpVtbl->UnlockVertexBuffer(mesh);
7148 vertices = NULL;
7149 }
7150 else if (flags & D3DXWELDEPSILONS_WELDALL)
7151 {
7152 for (i = 0; i < 3 * This->numfaces; i++)
7153 {
7154 DWORD index = read_ib(indices, indices_are_32bit, i);
7155 DWORD to_face = vertex_face_map[index];
7156 DWORD from_face = vertex_face_map[point_reps[index]];
7157 if(attributes[to_face] != attributes[from_face] && !(flags & D3DXWELDEPSILONS_DONOTSPLIT))
7158 continue;
7159 write_ib(indices, indices_are_32bit, i, point_reps[index]);
7160 }
7161 }
7162 mesh->lpVtbl->UnlockAttributeBuffer(mesh);
7163 attributes = NULL;
7164 mesh->lpVtbl->UnlockIndexBuffer(mesh);
7165 indices = NULL;
7166
7167 /* Compact mesh using OptimizeInplace */
7168 optimize_flags = D3DXMESHOPT_COMPACT;
7169 hr = mesh->lpVtbl->OptimizeInplace(mesh, optimize_flags, adjacency_ptr, adjacency_out, face_remap_out, vertex_remap_out);
7170 if (FAILED(hr))
7171 {
7172 ERR("Couldn't compact mesh.\n");
7173 goto cleanup;
7174 }
7175
7176 hr = D3D_OK;
7177 cleanup:
7178 HeapFree(GetProcessHeap(), 0, adjacency_generated);
7179 HeapFree(GetProcessHeap(), 0, point_reps);
7180 HeapFree(GetProcessHeap(), 0, vertex_face_map);
7181 if (attributes) mesh->lpVtbl->UnlockAttributeBuffer(mesh);
7182 if (indices) mesh->lpVtbl->UnlockIndexBuffer(mesh);
7183 if (vertices) mesh->lpVtbl->UnlockVertexBuffer(mesh);
7184
7185 return hr;
7186 }
7187
7188 /*************************************************************************
7189 * D3DXOptimizeFaces (D3DX9_36.@)
7190 *
7191 * Re-orders the faces so the vertex cache is used optimally.
7192 *
7193 * PARAMS
7194 * indices [I] Pointer to an index buffer belonging to a mesh.
7195 * num_faces [I] Number of faces in the mesh.
7196 * num_vertices [I] Number of vertices in the mesh.
7197 * indices_are_32bit [I] Specifies whether indices are 32- or 16-bit.
7198 * face_remap [I/O] The new order the faces should be drawn in.
7199 *
7200 * RETURNS
7201 * Success: D3D_OK.
7202 * Failure: D3DERR_INVALIDCALL.
7203 *
7204 * BUGS
7205 * The face re-ordering does not use the vertex cache optimally.
7206 *
7207 */
7208 HRESULT WINAPI D3DXOptimizeFaces(const void *indices, UINT num_faces,
7209 UINT num_vertices, BOOL indices_are_32bit, DWORD *face_remap)
7210 {
7211 UINT i;
7212 UINT j = num_faces - 1;
7213 UINT limit_16_bit = 2 << 15; /* According to MSDN */
7214 HRESULT hr = D3D_OK;
7215
7216 FIXME("indices %p, num_faces %u, num_vertices %u, indices_are_32bit %#x, face_remap %p semi-stub. "
7217 "Face order will not be optimal.\n",
7218 indices, num_faces, num_vertices, indices_are_32bit, face_remap);
7219
7220 if (!indices_are_32bit && num_faces >= limit_16_bit)
7221 {
7222 WARN("Number of faces must be less than %d when using 16-bit indices.\n",
7223 limit_16_bit);
7224 hr = D3DERR_INVALIDCALL;
7225 goto error;
7226 }
7227
7228 if (!face_remap)
7229 {
7230 WARN("Face remap pointer is NULL.\n");
7231 hr = D3DERR_INVALIDCALL;
7232 goto error;
7233 }
7234
7235 /* The faces are drawn in reverse order for simple meshes. This ordering
7236 * is not optimal for complicated meshes, but will not break anything
7237 * either. The ordering should be changed to take advantage of the vertex
7238 * cache on the graphics card.
7239 *
7240 * TODO Re-order to take advantage of vertex cache.
7241 */
7242 for (i = 0; i < num_faces; i++)
7243 {
7244 face_remap[i] = j--;
7245 }
7246
7247 return D3D_OK;
7248
7249 error:
7250 return hr;
7251 }
7252
7253 static D3DXVECTOR3 *vertex_element_vec3(BYTE *vertices, const D3DVERTEXELEMENT9 *declaration,
7254 DWORD vertex_stride, DWORD index)
7255 {
7256 return (D3DXVECTOR3 *)(vertices + declaration->Offset + index * vertex_stride);
7257 }
7258
7259 static D3DXVECTOR3 read_vec3(BYTE *vertices, const D3DVERTEXELEMENT9 *declaration,
7260 DWORD vertex_stride, DWORD index)
7261 {
7262 D3DXVECTOR3 vec3 = {0};
7263 const D3DXVECTOR3 *src = vertex_element_vec3(vertices, declaration, vertex_stride, index);
7264
7265 switch (declaration->Type)
7266 {
7267 case D3DDECLTYPE_FLOAT1:
7268 vec3.x = src->x;
7269 break;
7270 case D3DDECLTYPE_FLOAT2:
7271 vec3.x = src->x;
7272 vec3.y = src->y;
7273 break;
7274 case D3DDECLTYPE_FLOAT3:
7275 case D3DDECLTYPE_FLOAT4:
7276 vec3 = *src;
7277 break;
7278 default:
7279 ERR("Cannot read vec3\n");
7280 break;
7281 }
7282
7283 return vec3;
7284 }
7285
7286 /*************************************************************************
7287 * D3DXComputeTangentFrameEx (D3DX9_36.@)
7288 */
7289 HRESULT WINAPI D3DXComputeTangentFrameEx(ID3DXMesh *mesh, DWORD texture_in_semantic, DWORD texture_in_index,
7290 DWORD u_partial_out_semantic, DWORD u_partial_out_index, DWORD v_partial_out_semantic,
7291 DWORD v_partial_out_index, DWORD normal_out_semantic, DWORD normal_out_index, DWORD options,
7292 const DWORD *adjacency, float partial_edge_threshold, float singular_point_threshold,
7293 float normal_edge_threshold, ID3DXMesh **mesh_out, ID3DXBuffer **vertex_mapping)
7294 {
7295 HRESULT hr;
7296 void *indices = NULL;
7297 BYTE *vertices = NULL;
7298 DWORD *point_reps = NULL;
7299 size_t normal_size;
7300 BOOL indices_are_32bit;
7301 DWORD i, j, num_faces, num_vertices, vertex_stride;
7302 D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE] = {D3DDECL_END()};
7303 D3DVERTEXELEMENT9 *position_declaration = NULL, *normal_declaration = NULL;
7304 DWORD weighting_method = options & (D3DXTANGENT_WEIGHT_EQUAL | D3DXTANGENT_WEIGHT_BY_AREA);
7305
7306 TRACE("mesh %p, texture_in_semantic %u, texture_in_index %u, u_partial_out_semantic %u, u_partial_out_index %u, "
7307 "v_partial_out_semantic %u, v_partial_out_index %u, normal_out_semantic %u, normal_out_index %u, "
7308 "options %#x, adjacency %p, partial_edge_threshold %f, singular_point_threshold %f, "
7309 "normal_edge_threshold %f, mesh_out %p, vertex_mapping %p\n",
7310 mesh, texture_in_semantic, texture_in_index, u_partial_out_semantic, u_partial_out_index,
7311 v_partial_out_semantic, v_partial_out_index, normal_out_semantic, normal_out_index, options, adjacency,
7312 partial_edge_threshold, singular_point_threshold, normal_edge_threshold, mesh_out, vertex_mapping);
7313
7314 if (!mesh)
7315 {
7316 WARN("mesh is NULL\n");
7317 return D3DERR_INVALIDCALL;
7318 }
7319
7320 if (weighting_method == (D3DXTANGENT_WEIGHT_EQUAL | D3DXTANGENT_WEIGHT_BY_AREA))
7321 {
7322 WARN("D3DXTANGENT_WEIGHT_BY_AREA and D3DXTANGENT_WEIGHT_EQUAL are mutally exclusive\n");
7323 return D3DERR_INVALIDCALL;
7324 }
7325
7326 if (u_partial_out_semantic != D3DX_DEFAULT)
7327 {
7328 FIXME("tangent vectors computation is not supported\n");
7329 return E_NOTIMPL;
7330 }
7331
7332 if (v_partial_out_semantic != D3DX_DEFAULT)
7333 {
7334 FIXME("binormal vectors computation is not supported\n");
7335 return E_NOTIMPL;
7336 }
7337
7338 if (options & ~(D3DXTANGENT_GENERATE_IN_PLACE | D3DXTANGENT_CALCULATE_NORMALS | D3DXTANGENT_WEIGHT_EQUAL | D3DXTANGENT_WEIGHT_BY_AREA))
7339 {
7340 FIXME("unsupported options %#x\n", options);
7341 return E_NOTIMPL;
7342 }
7343
7344 if (!(options & D3DXTANGENT_CALCULATE_NORMALS))
7345 {
7346 FIXME("only normals computation is supported\n");
7347 return E_NOTIMPL;
7348 }
7349
7350 if (!(options & D3DXTANGENT_GENERATE_IN_PLACE) || mesh_out || vertex_mapping)
7351 {
7352 FIXME("only D3DXTANGENT_GENERATE_IN_PLACE is supported\n");
7353 return E_NOTIMPL;
7354 }
7355
7356 if (FAILED(hr = mesh->lpVtbl->GetDeclaration(mesh, declaration)))
7357 return hr;
7358
7359 for (i = 0; declaration[i].Stream != 0xff; i++)
7360 {
7361 if (declaration[i].Usage == D3DDECLUSAGE_POSITION && !declaration[i].UsageIndex)
7362 position_declaration = &declaration[i];
7363 if (declaration[i].Usage == normal_out_semantic && declaration[i].UsageIndex == normal_out_index)
7364 normal_declaration = &declaration[i];
7365 }
7366
7367 if (!position_declaration || !normal_declaration)
7368 return D3DERR_INVALIDCALL;
7369
7370 if (normal_declaration->Type == D3DDECLTYPE_FLOAT3)
7371 {
7372 normal_size = sizeof(D3DXVECTOR3);
7373 }
7374 else if (normal_declaration->Type == D3DDECLTYPE_FLOAT4)
7375 {
7376 normal_size = sizeof(D3DXVECTOR4);
7377 }
7378 else
7379 {
7380 WARN("unsupported normals type %u\n", normal_declaration->Type);
7381 return D3DERR_INVALIDCALL;
7382 }
7383
7384 num_faces = mesh->lpVtbl->GetNumFaces(mesh);
7385 num_vertices = mesh->lpVtbl->GetNumVertices(mesh);
7386 vertex_stride = mesh->lpVtbl->GetNumBytesPerVertex(mesh);
7387 indices_are_32bit = mesh->lpVtbl->GetOptions(mesh) & D3DXMESH_32BIT;
7388
7389 point_reps = HeapAlloc(GetProcessHeap(), 0, num_vertices * sizeof(*point_reps));
7390 if (!point_reps)
7391 {
7392 hr = E_OUTOFMEMORY;
7393 goto done;
7394 }
7395
7396 if (adjacency)
7397 {
7398 if (FAILED(hr = mesh->lpVtbl->ConvertAdjacencyToPointReps(mesh, adjacency, point_reps)))
7399 goto done;
7400 }
7401 else
7402 {
7403 for (i = 0; i < num_vertices; i++)
7404 point_reps[i] = i;
7405 }
7406
7407 if (FAILED(hr = mesh->lpVtbl->LockIndexBuffer(mesh, 0, &indices)))
7408 goto done;
7409
7410 if (FAILED(hr = mesh->lpVtbl->LockVertexBuffer(mesh, 0, (void **)&vertices)))
7411 goto done;
7412
7413 for (i = 0; i < num_vertices; i++)
7414 {
7415 static const D3DXVECTOR4 default_vector = {0.0f, 0.0f, 0.0f, 1.0f};
7416 void *normal = vertices + normal_declaration->Offset + i * vertex_stride;
7417
7418 memcpy(normal, &default_vector, normal_size);
7419 }
7420
7421 for (i = 0; i < num_faces; i++)
7422 {
7423 float denominator, weights[3];
7424 D3DXVECTOR3 a, b, cross, face_normal;
7425 const DWORD face_indices[3] =
7426 {
7427 read_ib(indices, indices_are_32bit, 3 * i + 0),
7428 read_ib(indices, indices_are_32bit, 3 * i + 1),
7429 read_ib(indices, indices_are_32bit, 3 * i + 2)
7430 };
7431 const D3DXVECTOR3 v0 = read_vec3(vertices, position_declaration, vertex_stride, face_indices[0]);
7432 const D3DXVECTOR3 v1 = read_vec3(vertices, position_declaration, vertex_stride, face_indices[1]);
7433 const D3DXVECTOR3 v2 = read_vec3(vertices, position_declaration, vertex_stride, face_indices[2]);
7434
7435 D3DXVec3Cross(&cross, D3DXVec3Subtract(&a, &v0, &v1), D3DXVec3Subtract(&b, &v0, &v2));
7436
7437 switch (weighting_method)
7438 {
7439 case D3DXTANGENT_WEIGHT_EQUAL:
7440 weights[0] = weights[1] = weights[2] = 1.0f;
7441 break;
7442 case D3DXTANGENT_WEIGHT_BY_AREA:
7443 weights[0] = weights[1] = weights[2] = D3DXVec3Length(&cross);
7444 break;
7445 default:
7446 /* weight by angle */
7447 denominator = D3DXVec3Length(&a) * D3DXVec3Length(&b);
7448 if (!denominator)
7449 weights[0] = 0.0f;
7450 else
7451 weights[0] = acosf(D3DXVec3Dot(&a, &b) / denominator);
7452
7453 D3DXVec3Subtract(&a, &v1, &v0);
7454 D3DXVec3Subtract(&b, &v1, &v2);
7455 denominator = D3DXVec3Length(&a) * D3DXVec3Length(&b);
7456 if (!denominator)
7457 weights[1] = 0.0f;
7458 else
7459 weights[1] = acosf(D3DXVec3Dot(&a, &b) / denominator);
7460
7461 D3DXVec3Subtract(&a, &v2, &v0);
7462 D3DXVec3Subtract(&b, &v2, &v1);
7463 denominator = D3DXVec3Length(&a) * D3DXVec3Length(&b);
7464 if (!denominator)
7465 weights[2] = 0.0f;
7466 else
7467 weights[2] = acosf(D3DXVec3Dot(&a, &b) / denominator);
7468
7469 break;
7470 }
7471
7472 D3DXVec3Normalize(&face_normal, &cross);
7473
7474 for (j = 0; j < 3; j++)
7475 {
7476 D3DXVECTOR3 normal;
7477 DWORD rep_index = point_reps[face_indices[j]];
7478 D3DXVECTOR3 *rep_normal = vertex_element_vec3(vertices, normal_declaration, vertex_stride, rep_index);
7479
7480 D3DXVec3Scale(&normal, &face_normal, weights[j]);
7481 D3DXVec3Add(rep_normal, rep_normal, &normal);
7482 }
7483 }
7484
7485 for (i = 0; i < num_vertices; i++)
7486 {
7487 DWORD rep_index = point_reps[i];
7488 D3DXVECTOR3 *normal = vertex_element_vec3(vertices, normal_declaration, vertex_stride, i);
7489 D3DXVECTOR3 *rep_normal = vertex_element_vec3(vertices, normal_declaration, vertex_stride, rep_index);
7490
7491 if (i == rep_index)
7492 D3DXVec3Normalize(rep_normal, rep_normal);
7493 else
7494 *normal = *rep_normal;
7495 }
7496
7497 hr = D3D_OK;
7498
7499 done:
7500 if (vertices)
7501 mesh->lpVtbl->UnlockVertexBuffer(mesh);
7502
7503 if (indices)
7504 mesh->lpVtbl->UnlockIndexBuffer(mesh);
7505
7506 HeapFree(GetProcessHeap(), 0, point_reps);
7507
7508 return hr;
7509 }
7510
7511 /*************************************************************************
7512 * D3DXComputeNormals (D3DX9_36.@)
7513 */
7514 HRESULT WINAPI D3DXComputeNormals(struct ID3DXBaseMesh *mesh, const DWORD *adjacency)
7515 {
7516 TRACE("mesh %p, adjacency %p\n", mesh, adjacency);
7517
7518 if (mesh && (ID3DXMeshVtbl *)mesh->lpVtbl != &D3DXMesh_Vtbl)
7519 {
7520 ERR("Invalid virtual table\n");
7521 return D3DERR_INVALIDCALL;
7522 }
7523
7524 return D3DXComputeTangentFrameEx((ID3DXMesh *)mesh, D3DX_DEFAULT, 0,
7525 D3DX_DEFAULT, 0, D3DX_DEFAULT, 0, D3DDECLUSAGE_NORMAL, 0,
7526 D3DXTANGENT_GENERATE_IN_PLACE | D3DXTANGENT_CALCULATE_NORMALS,
7527 adjacency, -1.01f, -0.01f, -1.01f, NULL, NULL);
7528 }
7529
7530 /*************************************************************************
7531 * D3DXIntersect (D3DX9_36.@)
7532 */
7533 HRESULT WINAPI D3DXIntersect(ID3DXBaseMesh *mesh, const D3DXVECTOR3 *ray_pos, const D3DXVECTOR3 *ray_dir,
7534 BOOL *hit, DWORD *face_index, float *u, float *v, float *distance, ID3DXBuffer **all_hits, DWORD *count_of_hits)
7535 {
7536 FIXME("mesh %p, ray_pos %p, ray_dir %p, hit %p, face_index %p, u %p, v %p, distance %p, all_hits %p, "
7537 "count_of_hits %p stub!\n", mesh, ray_pos, ray_dir, hit, face_index, u, v, distance, all_hits, count_of_hits);
7538
7539 return E_NOTIMPL;
7540 }
7541
7542 HRESULT WINAPI D3DXTessellateNPatches(ID3DXMesh *mesh, const DWORD *adjacency_in, float num_segs,
7543 BOOL quadratic_normals, ID3DXMesh **mesh_out, ID3DXBuffer **adjacency_out)
7544 {
7545 FIXME("mesh %p, adjacency_in %p, num_segs %f, quadratic_normals %d, mesh_out %p, adjacency_out %p stub.\n",
7546 mesh, adjacency_in, num_segs, quadratic_normals, mesh_out, adjacency_out);
7547
7548 return E_NOTIMPL;
7549 }
7550
7551 HRESULT WINAPI D3DXConvertMeshSubsetToSingleStrip(struct ID3DXBaseMesh *mesh_in, DWORD attribute_id,
7552 DWORD ib_flags, struct IDirect3DIndexBuffer9 **index_buffer, DWORD *index_count)
7553 {
7554 FIXME("mesh_in %p, attribute_id %u, ib_flags %u, index_buffer %p, index_count %p stub.\n",
7555 mesh_in, attribute_id, ib_flags, index_buffer, index_count);
7556
7557 return E_NOTIMPL;
7558 }
Windows API implementation