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