dll/directx/wine/d3dx9_36/xfile.c

   1 /*
   2  * Copyright (C) 2012 Christian Costa
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  *
  18  */
  19
  20 #include "wine/debug.h"
  21
  22 #include "d3dx9.h"
  23 #include "d3dx9xof.h"
  24 #undef MAKE_DDHRESULT
  25 #include "dxfile.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
  28
  29 static HRESULT error_dxfile_to_d3dxfile(HRESULT error)
  30 {
  31     switch (error)
  32     {
  33         case DXFILEERR_BADFILETYPE:
  34             return D3DXFERR_BADFILETYPE;
  35         case DXFILEERR_BADFILEVERSION:
  36             return D3DXFERR_BADFILEVERSION;
  37         case DXFILEERR_BADFILEFLOATSIZE:
  38             return D3DXFERR_BADFILEFLOATSIZE;
  39         case DXFILEERR_PARSEERROR:
  40             return D3DXFERR_PARSEERROR;
  41         case DXFILEERR_BADVALUE:
  42             return D3DXFERR_BADVALUE;
  43         default:
  44             FIXME("Cannot map error %#x\n", error);
  45             return E_FAIL;
  46     }
  47 }
  48
  49 typedef struct {
  50     ID3DXFile ID3DXFile_iface;
  51     LONG ref;
  52     IDirectXFile *dxfile;
  53 } ID3DXFileImpl;
  54
  55 typedef struct {
  56     ID3DXFileEnumObject ID3DXFileEnumObject_iface;
  57     LONG ref;
  58     ULONG nb_children;
  59     ID3DXFileData **children;
  60 } ID3DXFileEnumObjectImpl;
  61
  62 typedef struct {
  63     ID3DXFileData ID3DXFileData_iface;
  64     LONG ref;
  65     BOOL reference;
  66     IDirectXFileData *dxfile_data;
  67     ULONG nb_children;
  68     ID3DXFileData **children;
  69 } ID3DXFileDataImpl;
  70
  71
  72 static inline ID3DXFileImpl* impl_from_ID3DXFile(ID3DXFile *iface)
  73 {
  74     return CONTAINING_RECORD(iface, ID3DXFileImpl, ID3DXFile_iface);
  75 }
  76
  77 static inline ID3DXFileEnumObjectImpl* impl_from_ID3DXFileEnumObject(ID3DXFileEnumObject *iface)
  78 {
  79     return CONTAINING_RECORD(iface, ID3DXFileEnumObjectImpl, ID3DXFileEnumObject_iface);
  80 }
  81
  82 static inline ID3DXFileDataImpl* impl_from_ID3DXFileData(ID3DXFileData *iface)
  83 {
  84     return CONTAINING_RECORD(iface, ID3DXFileDataImpl, ID3DXFileData_iface);
  85 }
  86
  87 /*** IUnknown methods ***/
  88
  89 static HRESULT WINAPI ID3DXFileDataImpl_QueryInterface(ID3DXFileData *iface, REFIID riid, void **ret_iface)
  90 {
  91     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ret_iface);
  92
  93     if (IsEqualGUID(riid, &IID_IUnknown) ||
  94         IsEqualGUID(riid, &IID_ID3DXFileData))
  95     {
  96         iface->lpVtbl->AddRef(iface);
  97         *ret_iface = iface;
  98         return S_OK;
  99     }
 100
 101     WARN("(%p)->(%s, %p), not found\n", iface, debugstr_guid(riid), ret_iface);
 102     *ret_iface = NULL;
 103     return E_NOINTERFACE;
 104 }
 105
 106 static ULONG WINAPI ID3DXFileDataImpl_AddRef(ID3DXFileData *iface)
 107 {
 108     ID3DXFileDataImpl *This = impl_from_ID3DXFileData(iface);
 109     ULONG ref = InterlockedIncrement(&This->ref);
 110
 111     TRACE("(%p)->(): new ref = %u\n", iface, ref);
 112
 113     return ref;
 114 }
 115
 116 static ULONG WINAPI ID3DXFileDataImpl_Release(ID3DXFileData *iface)
 117 {
 118     ID3DXFileDataImpl *This = impl_from_ID3DXFileData(iface);
 119     ULONG ref = InterlockedDecrement(&This->ref);
 120
 121     TRACE("(%p)->(): new ref = %u\n", iface, ref);
 122
 123     if (!ref)
 124     {
 125         ULONG i;
 126
 127         for (i = 0; i < This->nb_children; i++)
 128             (This->children[i])->lpVtbl->Release(This->children[i]);
 129         HeapFree(GetProcessHeap(), 0, This->children);
 130         IDirectXFileData_Release(This->dxfile_data);
 131         HeapFree(GetProcessHeap(), 0, This);
 132     }
 133
 134     return ref;
 135 }
 136
 137
 138 /*** ID3DXFileData methods ***/
 139
 140 static HRESULT WINAPI ID3DXFileDataImpl_GetEnum(ID3DXFileData *iface, ID3DXFileEnumObject **enum_object)
 141 {
 142     FIXME("(%p)->(%p): stub\n", iface, enum_object);
 143
 144     return E_NOTIMPL;
 145 }
 146
 147
 148 static HRESULT WINAPI ID3DXFileDataImpl_GetName(ID3DXFileData *iface, char *name, SIZE_T *size)
 149 {
 150     ID3DXFileDataImpl *This = impl_from_ID3DXFileData(iface);
 151     DWORD dxfile_size;
 152     HRESULT ret;
 153
 154     TRACE("(%p)->(%p, %p)\n", iface, name, size);
 155
 156     if (!size)
 157         return D3DXFERR_BADVALUE;
 158
 159     dxfile_size = *size;
 160
 161     ret = IDirectXFileData_GetName(This->dxfile_data, name, &dxfile_size);
 162     if (ret != DXFILE_OK)
 163         return error_dxfile_to_d3dxfile(ret);
 164
 165     if (!dxfile_size)
 166     {
 167         /* Contrary to d3dxof, d3dx9_36 returns an empty string with a null byte when no name is available.
 168          * If the input size is 0, it returns a length of 1 without touching the buffer */
 169         dxfile_size = 1;
 170         if (name && *size)
 171             name[0] = 0;
 172     }
 173
 174     *size = dxfile_size;
 175
 176     return S_OK;
 177 }
 178
 179
 180 static HRESULT WINAPI ID3DXFileDataImpl_GetId(ID3DXFileData *iface, GUID *guid)
 181 {
 182     ID3DXFileDataImpl *This = impl_from_ID3DXFileData(iface);
 183     HRESULT ret;
 184
 185     TRACE("(%p)->(%p)\n", iface, guid);
 186
 187     if (!guid)
 188         return E_POINTER;
 189
 190     ret = IDirectXFileData_GetId(This->dxfile_data, guid);
 191     if (ret != DXFILE_OK)
 192         return error_dxfile_to_d3dxfile(ret);
 193
 194     return S_OK;
 195 }
 196
 197
 198 static HRESULT WINAPI ID3DXFileDataImpl_Lock(ID3DXFileData *iface, SIZE_T *size, const void **data)
 199 {
 200     ID3DXFileDataImpl *This = impl_from_ID3DXFileData(iface);
 201     DWORD dxfile_size;
 202     HRESULT ret;
 203
 204     TRACE("(%p)->(%p, %p)\n", iface, size, data);
 205
 206     if (!size || !data)
 207         return E_POINTER;
 208
 209     ret = IDirectXFileData_GetData(This->dxfile_data, NULL, &dxfile_size, (void**)data);
 210     if (ret != DXFILE_OK)
 211         return error_dxfile_to_d3dxfile(ret);
 212
 213     *size = dxfile_size;
 214
 215     return S_OK;
 216 }
 217
 218
 219 static HRESULT WINAPI ID3DXFileDataImpl_Unlock(ID3DXFileData *iface)
 220 {
 221     TRACE("(%p)->()\n", iface);
 222
 223     /* Nothing to do */
 224
 225     return S_OK;
 226 }
 227
 228
 229 static HRESULT WINAPI ID3DXFileDataImpl_GetType(ID3DXFileData *iface, GUID *guid)
 230 {
 231     ID3DXFileDataImpl *This = impl_from_ID3DXFileData(iface);
 232     const GUID *dxfile_guid;
 233     HRESULT ret;
 234
 235     TRACE("(%p)->(%p)\n", iface, guid);
 236
 237     ret = IDirectXFileData_GetType(This->dxfile_data, &dxfile_guid);
 238     if (ret != DXFILE_OK)
 239         return error_dxfile_to_d3dxfile(ret);
 240
 241     *guid = *dxfile_guid;
 242
 243     return S_OK;
 244 }
 245
 246
 247 static BOOL WINAPI ID3DXFileDataImpl_IsReference(ID3DXFileData *iface)
 248 {
 249     ID3DXFileDataImpl *This = impl_from_ID3DXFileData(iface);
 250
 251     TRACE("(%p)->()\n", iface);
 252
 253     return This->reference;
 254 }
 255
 256
 257 static HRESULT WINAPI ID3DXFileDataImpl_GetChildren(ID3DXFileData *iface, SIZE_T *children)
 258 {
 259     ID3DXFileDataImpl *This = impl_from_ID3DXFileData(iface);
 260
 261     TRACE("(%p)->(%p)\n", iface, children);
 262
 263     if (!children)
 264         return E_POINTER;
 265
 266     *children = This->nb_children;
 267
 268     return S_OK;
 269 }
 270
 271
 272 static HRESULT WINAPI ID3DXFileDataImpl_GetChild(ID3DXFileData *iface, SIZE_T id, ID3DXFileData **object)
 273 {
 274     ID3DXFileDataImpl *This = impl_from_ID3DXFileData(iface);
 275
 276     TRACE("(%p)->(%lu, %p)\n", iface, id, object);
 277
 278     if (!object)
 279         return E_POINTER;
 280
 281     *object = This->children[id];
 282     (*object)->lpVtbl->AddRef(*object);
 283
 284     return S_OK;
 285 }
 286
 287
 288 static const ID3DXFileDataVtbl ID3DXFileData_Vtbl =
 289 {
 290     ID3DXFileDataImpl_QueryInterface,
 291     ID3DXFileDataImpl_AddRef,
 292     ID3DXFileDataImpl_Release,
 293     ID3DXFileDataImpl_GetEnum,
 294     ID3DXFileDataImpl_GetName,
 295     ID3DXFileDataImpl_GetId,
 296     ID3DXFileDataImpl_Lock,
 297     ID3DXFileDataImpl_Unlock,
 298     ID3DXFileDataImpl_GetType,
 299     ID3DXFileDataImpl_IsReference,
 300     ID3DXFileDataImpl_GetChildren,
 301     ID3DXFileDataImpl_GetChild
 302 };
 303
 304
 305 static HRESULT ID3DXFileDataImpl_Create(IDirectXFileObject *dxfile_object, ID3DXFileData **ret_iface)
 306 {
 307     ID3DXFileDataImpl *object;
 308     IDirectXFileObject *data_object;
 309     HRESULT ret;
 310
 311     TRACE("(%p, %p)\n", dxfile_object, ret_iface);
 312
 313     *ret_iface = NULL;
 314
 315     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 316     if (!object)
 317         return E_OUTOFMEMORY;
 318
 319     object->ID3DXFileData_iface.lpVtbl = &ID3DXFileData_Vtbl;
 320     object->ref = 1;
 321
 322     ret = IDirectXFileObject_QueryInterface(dxfile_object, &IID_IDirectXFileData, (void **)&object->dxfile_data);
 323     if (FAILED(ret))
 324     {
 325         IDirectXFileDataReference *reference;
 326
 327         ret = IDirectXFileObject_QueryInterface(dxfile_object, &IID_IDirectXFileDataReference, (void **)&reference);
 328         if (SUCCEEDED(ret))
 329         {
 330             ret = IDirectXFileDataReference_Resolve(reference, &object->dxfile_data);
 331             if (FAILED(ret))
 332             {
 333                 HeapFree(GetProcessHeap(), 0, object);
 334                 return E_FAIL;
 335             }
 336             object->reference = TRUE;
 337         }
 338         else
 339         {
 340             FIXME("Don't known what to do with binary object\n");
 341             HeapFree(GetProcessHeap(), 0, object);
 342             return E_FAIL;
 343         }
 344     }
 345
 346     while (SUCCEEDED(ret = IDirectXFileData_GetNextObject(object->dxfile_data, &data_object)))
 347     {
 348         if (object->children)
 349             object->children = HeapReAlloc(GetProcessHeap(), 0, object->children, sizeof(ID3DXFileData*) * (object->nb_children + 1));
 350         else
 351             object->children = HeapAlloc(GetProcessHeap(), 0, sizeof(ID3DXFileData*));
 352         if (!object->children)
 353         {
 354             ret = E_OUTOFMEMORY;
 355             break;
 356         }
 357         ret = ID3DXFileDataImpl_Create(data_object, &object->children[object->nb_children]);
 358         if (ret != S_OK)
 359             break;
 360         object->nb_children++;
 361     }
 362
 363     if (ret != DXFILEERR_NOMOREOBJECTS)
 364     {
 365         (&object->ID3DXFileData_iface)->lpVtbl->Release(&object->ID3DXFileData_iface);
 366         return ret;
 367     }
 368
 369     TRACE("Found %u children\n", object->nb_children);
 370
 371     *ret_iface = &object->ID3DXFileData_iface;
 372
 373     return S_OK;
 374 }
 375
 376
 377 /*** IUnknown methods ***/
 378
 379 static HRESULT WINAPI ID3DXFileEnumObjectImpl_QueryInterface(ID3DXFileEnumObject *iface, REFIID riid, void **ret_iface)
 380 {
 381     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ret_iface);
 382
 383     if (IsEqualGUID(riid, &IID_IUnknown) ||
 384         IsEqualGUID(riid, &IID_ID3DXFileEnumObject))
 385     {
 386         iface->lpVtbl->AddRef(iface);
 387         *ret_iface = iface;
 388         return S_OK;
 389     }
 390
 391     WARN("(%p)->(%s, %p), not found\n", iface, debugstr_guid(riid), ret_iface);
 392     *ret_iface = NULL;
 393     return E_NOINTERFACE;
 394 }
 395
 396 static ULONG WINAPI ID3DXFileEnumObjectImpl_AddRef(ID3DXFileEnumObject *iface)
 397 {
 398     ID3DXFileEnumObjectImpl *This = impl_from_ID3DXFileEnumObject(iface);
 399     ULONG ref = InterlockedIncrement(&This->ref);
 400
 401     TRACE("(%p)->(): new ref = %u\n", iface, ref);
 402
 403     return ref;
 404 }
 405
 406 static ULONG WINAPI ID3DXFileEnumObjectImpl_Release(ID3DXFileEnumObject *iface)
 407 {
 408     ID3DXFileEnumObjectImpl *This = impl_from_ID3DXFileEnumObject(iface);
 409     ULONG ref = InterlockedDecrement(&This->ref);
 410
 411     TRACE("(%p)->(): new ref = %u\n", iface, ref);
 412
 413     if (!ref)
 414     {
 415         ULONG i;
 416
 417         for (i = 0; i < This->nb_children; i++)
 418             (This->children[i])->lpVtbl->Release(This->children[i]);
 419         HeapFree(GetProcessHeap(), 0, This->children);
 420         HeapFree(GetProcessHeap(), 0, This);
 421     }
 422
 423     return ref;
 424 }
 425
 426
 427 /*** ID3DXFileEnumObject methods ***/
 428
 429 static HRESULT WINAPI ID3DXFileEnumObjectImpl_GetFile(ID3DXFileEnumObject *iface, ID3DXFile **file)
 430 {
 431     FIXME("(%p)->(%p): stub\n", iface, file);
 432
 433     return E_NOTIMPL;
 434 }
 435
 436
 437 static HRESULT WINAPI ID3DXFileEnumObjectImpl_GetChildren(ID3DXFileEnumObject *iface, SIZE_T *children)
 438 {
 439     ID3DXFileEnumObjectImpl *This = impl_from_ID3DXFileEnumObject(iface);
 440
 441     TRACE("(%p)->(%p)\n", iface, children);
 442
 443     if (!children)
 444         return E_POINTER;
 445
 446     *children = This->nb_children;
 447
 448     return S_OK;
 449 }
 450
 451
 452 static HRESULT WINAPI ID3DXFileEnumObjectImpl_GetChild(ID3DXFileEnumObject *iface, SIZE_T id, ID3DXFileData **object)
 453 {
 454     ID3DXFileEnumObjectImpl *This = impl_from_ID3DXFileEnumObject(iface);
 455
 456     TRACE("(%p)->(%lu, %p)\n", iface, id, object);
 457
 458     if (!object)
 459         return E_POINTER;
 460
 461     *object = This->children[id];
 462     (*object)->lpVtbl->AddRef(*object);
 463
 464     return S_OK;
 465 }
 466
 467
 468 static HRESULT WINAPI ID3DXFileEnumObjectImpl_GetDataObjectById(ID3DXFileEnumObject *iface, REFGUID guid, ID3DXFileData **object)
 469 {
 470     FIXME("(%p)->(%s, %p): stub\n", iface, debugstr_guid(guid), object);
 471
 472     return E_NOTIMPL;
 473 }
 474
 475
 476 static HRESULT WINAPI ID3DXFileEnumObjectImpl_GetDataObjectByName(ID3DXFileEnumObject *iface, const char *name, ID3DXFileData **object)
 477 {
 478     FIXME("(%p)->(%s, %p): stub\n", iface, debugstr_a(name), object);
 479
 480     return E_NOTIMPL;
 481 }
 482
 483
 484 static const ID3DXFileEnumObjectVtbl ID3DXFileEnumObject_Vtbl =
 485 {
 486     ID3DXFileEnumObjectImpl_QueryInterface,
 487     ID3DXFileEnumObjectImpl_AddRef,
 488     ID3DXFileEnumObjectImpl_Release,
 489     ID3DXFileEnumObjectImpl_GetFile,
 490     ID3DXFileEnumObjectImpl_GetChildren,
 491     ID3DXFileEnumObjectImpl_GetChild,
 492     ID3DXFileEnumObjectImpl_GetDataObjectById,
 493     ID3DXFileEnumObjectImpl_GetDataObjectByName
 494 };
 495
 496
 497 /*** IUnknown methods ***/
 498
 499 static HRESULT WINAPI ID3DXFileImpl_QueryInterface(ID3DXFile *iface, REFIID riid, void **ret_iface)
 500 {
 501     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ret_iface);
 502
 503     if (IsEqualGUID(riid, &IID_IUnknown) ||
 504         IsEqualGUID(riid, &IID_ID3DXFile))
 505     {
 506         iface->lpVtbl->AddRef(iface);
 507         *ret_iface = iface;
 508         return S_OK;
 509     }
 510
 511     WARN("(%p)->(%s, %p), not found\n", iface, debugstr_guid(riid), ret_iface);
 512     *ret_iface = NULL;
 513     return E_NOINTERFACE;
 514 }
 515
 516
 517 static ULONG WINAPI ID3DXFileImpl_AddRef(ID3DXFile *iface)
 518 {
 519     ID3DXFileImpl *This = impl_from_ID3DXFile(iface);
 520     ULONG ref = InterlockedIncrement(&This->ref);
 521
 522     TRACE("(%p)->(): new ref = %u\n", iface, ref);
 523
 524     return ref;
 525 }
 526
 527
 528 static ULONG WINAPI ID3DXFileImpl_Release(ID3DXFile *iface)
 529 {
 530     ID3DXFileImpl *This = impl_from_ID3DXFile(iface);
 531     ULONG ref = InterlockedDecrement(&This->ref);
 532
 533     TRACE("(%p)->(): new ref = %u\n", iface, ref);
 534
 535     if (!ref)
 536     {
 537         IDirectXFile_Release(This->dxfile);
 538         HeapFree(GetProcessHeap(), 0, This);
 539     }
 540
 541     return ref;
 542 }
 543
 544
 545 /*** ID3DXFile methods ***/
 546
 547 static HRESULT WINAPI ID3DXFileImpl_CreateEnumObject(ID3DXFile *iface, const void *source, D3DXF_FILELOADOPTIONS options, ID3DXFileEnumObject **enum_object)
 548 {
 549     ID3DXFileImpl *This = impl_from_ID3DXFile(iface);
 550     ID3DXFileEnumObjectImpl *object;
 551     IDirectXFileEnumObject *dxfile_enum_object;
 552     void *dxfile_source;
 553     DXFILELOADOPTIONS dxfile_options;
 554     DXFILELOADRESOURCE dxfile_resource;
 555     DXFILELOADMEMORY dxfile_memory;
 556     IDirectXFileData *data_object;
 557     HRESULT ret;
 558
 559     TRACE("(%p)->(%p, %x, %p)\n", iface, source, options, enum_object);
 560
 561     if (!enum_object)
 562         return E_POINTER;
 563
 564     *enum_object = NULL;
 565
 566     if (options == D3DXF_FILELOAD_FROMFILE)
 567     {
 568         dxfile_source = (void*)source;
 569         dxfile_options = DXFILELOAD_FROMFILE;
 570     }
 571     else if (options == D3DXF_FILELOAD_FROMRESOURCE)
 572     {
 573         D3DXF_FILELOADRESOURCE *resource = (D3DXF_FILELOADRESOURCE*)source;
 574
 575         dxfile_resource.hModule = resource->hModule;
 576         dxfile_resource.lpName = resource->lpName;
 577         dxfile_resource.lpType = resource->lpType;
 578         dxfile_source = &dxfile_resource;
 579         dxfile_options = DXFILELOAD_FROMRESOURCE;
 580     }
 581     else if (options == D3DXF_FILELOAD_FROMMEMORY)
 582     {
 583         D3DXF_FILELOADMEMORY *memory = (D3DXF_FILELOADMEMORY*)source;
 584
 585         dxfile_memory.lpMemory = memory->lpMemory;
 586         dxfile_memory.dSize = memory->dSize;
 587         dxfile_source = &dxfile_memory;
 588         dxfile_options = DXFILELOAD_FROMMEMORY;
 589     }
 590     else
 591     {
 592         FIXME("Source type %u is not handled yet\n", options);
 593         return E_NOTIMPL;
 594     }
 595
 596     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 597     if (!object)
 598         return E_OUTOFMEMORY;
 599
 600     object->ID3DXFileEnumObject_iface.lpVtbl = &ID3DXFileEnumObject_Vtbl;
 601     object->ref = 1;
 602
 603     ret = IDirectXFile_CreateEnumObject(This->dxfile, dxfile_source, dxfile_options, &dxfile_enum_object);
 604
 605     if (ret != S_OK)
 606     {
 607         HeapFree(GetProcessHeap(), 0, object);
 608         return ret;
 609     }
 610
 611     /* Fill enum object with top level data objects */
 612     while (SUCCEEDED(ret = IDirectXFileEnumObject_GetNextDataObject(dxfile_enum_object, &data_object)))
 613     {
 614         if (object->children)
 615             object->children = HeapReAlloc(GetProcessHeap(), 0, object->children, sizeof(*object->children) * (object->nb_children + 1));
 616         else
 617             object->children = HeapAlloc(GetProcessHeap(), 0, sizeof(*object->children));
 618         if (!object->children)
 619         {
 620             ret = E_OUTOFMEMORY;
 621             break;
 622         }
 623         ret = ID3DXFileDataImpl_Create((IDirectXFileObject*)data_object, &object->children[object->nb_children]);
 624         if (ret != S_OK)
 625             break;
 626         object->nb_children++;
 627     }
 628
 629     IDirectXFileEnumObject_Release(dxfile_enum_object);
 630
 631     if (ret != DXFILEERR_NOMOREOBJECTS)
 632         WARN("Cannot get all top level data objects\n");
 633
 634     TRACE("Found %u children\n", object->nb_children);
 635
 636     *enum_object = &object->ID3DXFileEnumObject_iface;
 637
 638     return S_OK;
 639 }
 640
 641
 642 static HRESULT WINAPI ID3DXFileImpl_CreateSaveObject(ID3DXFile *iface, const void *data, D3DXF_FILESAVEOPTIONS options, D3DXF_FILEFORMAT format, ID3DXFileSaveObject **save_object)
 643 {
 644     FIXME("(%p)->(%p, %x, %u, %p): stub\n", iface, data, options, format, save_object);
 645
 646     return E_NOTIMPL;
 647 }
 648
 649
 650 static HRESULT WINAPI ID3DXFileImpl_RegisterTemplates(ID3DXFile *iface, const void *data, SIZE_T size)
 651 {
 652     ID3DXFileImpl *This = impl_from_ID3DXFile(iface);
 653     HRESULT ret;
 654
 655     TRACE("(%p)->(%p, %lu)\n", iface, data, size);
 656
 657     ret = IDirectXFile_RegisterTemplates(This->dxfile, (void*)data, size);
 658     if (ret != DXFILE_OK)
 659     {
 660         WARN("Error %#x\n", ret);
 661         return error_dxfile_to_d3dxfile(ret);
 662     }
 663
 664     return S_OK;
 665 }
 666
 667
 668 static HRESULT WINAPI ID3DXFileImpl_RegisterEnumTemplates(ID3DXFile *iface, ID3DXFileEnumObject *enum_object)
 669 {
 670     FIXME("(%p)->(%p): stub\n", iface, enum_object);
 671
 672     return E_NOTIMPL;
 673 }
 674
 675
 676 static const ID3DXFileVtbl ID3DXFile_Vtbl =
 677 {
 678     ID3DXFileImpl_QueryInterface,
 679     ID3DXFileImpl_AddRef,
 680     ID3DXFileImpl_Release,
 681     ID3DXFileImpl_CreateEnumObject,
 682     ID3DXFileImpl_CreateSaveObject,
 683     ID3DXFileImpl_RegisterTemplates,
 684     ID3DXFileImpl_RegisterEnumTemplates
 685 };
 686
 687 HRESULT WINAPI D3DXFileCreate(ID3DXFile **d3dxfile)
 688 {
 689     ID3DXFileImpl *object;
 690     HRESULT ret;
 691
 692     TRACE("(%p)\n", d3dxfile);
 693
 694     if (!d3dxfile)
 695         return E_POINTER;
 696
 697     *d3dxfile = NULL;
 698
 699     object = HeapAlloc(GetProcessHeap(), 0, sizeof(*object));
 700     if (!object)
 701         return E_OUTOFMEMORY;
 702
 703     ret = DirectXFileCreate(&object->dxfile);
 704     if (ret != S_OK)
 705     {
 706         HeapFree(GetProcessHeap(), 0, object);
 707         if (ret == E_OUTOFMEMORY)
 708             return ret;
 709         return E_FAIL;
 710     }
 711
 712     object->ID3DXFile_iface.lpVtbl = &ID3DXFile_Vtbl;
 713     object->ref = 1;
 714
 715     *d3dxfile = &object->ID3DXFile_iface;
 716
 717     return S_OK;
 718 }