dlls/d3drm/meshbuilder.c

   1 /*
   2  * Implementation of IDirect3DRMMeshBuilderX and IDirect3DRMMesh interfaces
   3  *
   4  * Copyright 2010, 2012 Christian Costa
   5  * Copyright 2011 André Hentschel
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include "d3drm_private.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(d3drm);
  28
  29 struct mesh_group
  30 {
  31     unsigned nb_vertices;
  32     D3DRMVERTEX* vertices;
  33     unsigned nb_faces;
  34     unsigned vertex_per_face;
  35     DWORD face_data_size;
  36     unsigned* face_data;
  37     D3DCOLOR color;
  38     IDirect3DRMMaterial2* material;
  39     IDirect3DRMTexture3* texture;
  40 };
  41
  42 struct d3drm_mesh
  43 {
  44     struct d3drm_object obj;
  45     IDirect3DRMMesh IDirect3DRMMesh_iface;
  46     LONG ref;
  47     DWORD groups_capacity;
  48     DWORD nb_groups;
  49     struct mesh_group *groups;
  50 };
  51
  52 struct coords_2d
  53 {
  54     D3DVALUE u;
  55     D3DVALUE v;
  56 };
  57
  58 struct mesh_material
  59 {
  60     D3DCOLOR color;
  61     IDirect3DRMMaterial2 *material;
  62     IDirect3DRMTexture3 *texture;
  63 };
  64
  65 char templates[] = {
  66 "xof 0302txt 0064"
  67 "template Header"
  68 "{"
  69 "<3D82AB43-62DA-11CF-AB39-0020AF71E433>"
  70 "WORD major;"
  71 "WORD minor;"
  72 "DWORD flags;"
  73 "}"
  74 "template Vector"
  75 "{"
  76 "<3D82AB5E-62DA-11CF-AB39-0020AF71E433>"
  77 "FLOAT x;"
  78 "FLOAT y;"
  79 "FLOAT z;"
  80 "}"
  81 "template Coords2d"
  82 "{"
  83 "<F6F23F44-7686-11CF-8F52-0040333594A3>"
  84 "FLOAT u;"
  85 "FLOAT v;"
  86 "}"
  87 "template Matrix4x4"
  88 "{"
  89 "<F6F23F45-7686-11CF-8F52-0040333594A3>"
  90 "array FLOAT matrix[16];"
  91 "}"
  92 "template ColorRGBA"
  93 "{"
  94 "<35FF44E0-6C7C-11CF-8F52-0040333594A3>"
  95 "FLOAT red;"
  96 "FLOAT green;"
  97 "FLOAT blue;"
  98 "FLOAT alpha;"
  99 "}"
 100 "template ColorRGB"
 101 "{"
 102 "<D3E16E81-7835-11CF-8F52-0040333594A3>"
 103 "FLOAT red;"
 104 "FLOAT green;"
 105 "FLOAT blue;"
 106 "}"
 107 "template IndexedColor"
 108 "{"
 109 "<1630B820-7842-11CF-8F52-0040333594A3>"
 110 "DWORD index;"
 111 "ColorRGBA indexColor;"
 112 "}"
 113 "template Boolean"
 114 "{"
 115 "<537DA6A0-CA37-11D0-941C-0080C80CFA7B>"
 116 "DWORD truefalse;"
 117 "}"
 118 "template Boolean2d"
 119 "{"
 120 "<4885AE63-78E8-11CF-8F52-0040333594A3>"
 121 "Boolean u;"
 122 "Boolean v;"
 123 "}"
 124 "template MaterialWrap"
 125 "{"
 126 "<4885AE60-78E8-11CF-8F52-0040333594A3>"
 127 "Boolean u;"
 128 "Boolean v;"
 129 "}"
 130 "template TextureFilename"
 131 "{"
 132 "<A42790E1-7810-11CF-8F52-0040333594A3>"
 133 "STRING filename;"
 134 "}"
 135 "template Material"
 136 "{"
 137 "<3D82AB4D-62DA-11CF-AB39-0020AF71E433>"
 138 "ColorRGBA faceColor;"
 139 "FLOAT power;"
 140 "ColorRGB specularColor;"
 141 "ColorRGB emissiveColor;"
 142 "[...]"
 143 "}"
 144 "template MeshFace"
 145 "{"
 146 "<3D82AB5F-62DA-11CF-AB39-0020AF71E433>"
 147 "DWORD nFaceVertexIndices;"
 148 "array DWORD faceVertexIndices[nFaceVertexIndices];"
 149 "}"
 150 "template MeshFaceWraps"
 151 "{"
 152 "<ED1EC5C0-C0A8-11D0-941C-0080C80CFA7B>"
 153 "DWORD nFaceWrapValues;"
 154 "array Boolean2d faceWrapValues[nFaceWrapValues];"
 155 "}"
 156 "template MeshTextureCoords"
 157 "{"
 158 "<F6F23F40-7686-11CF-8F52-0040333594A3>"
 159 "DWORD nTextureCoords;"
 160 "array Coords2d textureCoords[nTextureCoords];"
 161 "}"
 162 "template MeshMaterialList"
 163 "{"
 164 "<F6F23F42-7686-11CF-8F52-0040333594A3>"
 165 "DWORD nMaterials;"
 166 "DWORD nFaceIndexes;"
 167 "array DWORD faceIndexes[nFaceIndexes];"
 168 "[Material]"
 169 "}"
 170 "template MeshNormals"
 171 "{"
 172 "<F6F23F43-7686-11CF-8F52-0040333594A3>"
 173 "DWORD nNormals;"
 174 "array Vector normals[nNormals];"
 175 "DWORD nFaceNormals;"
 176 "array MeshFace faceNormals[nFaceNormals];"
 177 "}"
 178 "template MeshVertexColors"
 179 "{"
 180 "<1630B821-7842-11CF-8F52-0040333594A3>"
 181 "DWORD nVertexColors;"
 182 "array IndexedColor vertexColors[nVertexColors];"
 183 "}"
 184 "template Mesh"
 185 "{"
 186 "<3D82AB44-62DA-11CF-AB39-0020AF71E433>"
 187 "DWORD nVertices;"
 188 "array Vector vertices[nVertices];"
 189 "DWORD nFaces;"
 190 "array MeshFace faces[nFaces];"
 191 "[...]"
 192 "}"
 193 "template FrameTransformMatrix"
 194 "{"
 195 "<F6F23F41-7686-11CF-8F52-0040333594A3>"
 196 "Matrix4x4 frameMatrix;"
 197 "}"
 198 "template Frame"
 199 "{"
 200 "<3D82AB46-62DA-11CF-AB39-0020AF71E433>"
 201 "[...]"
 202 "}"
 203 "template FloatKeys"
 204 "{"
 205 "<10DD46A9-775B-11CF-8F52-0040333594A3>"
 206 "DWORD nValues;"
 207 "array FLOAT values[nValues];"
 208 "}"
 209 "template TimedFloatKeys"
 210 "{"
 211 "<F406B180-7B3B-11CF-8F52-0040333594A3>"
 212 "DWORD time;"
 213 "FloatKeys tfkeys;"
 214 "}"
 215 "template AnimationKey"
 216 "{"
 217 "<10DD46A8-775B-11CF-8F52-0040333594A3>"
 218 "DWORD keyType;"
 219 "DWORD nKeys;"
 220 "array TimedFloatKeys keys[nKeys];"
 221 "}"
 222 "template AnimationOptions"
 223 "{"
 224 "<E2BF56C0-840F-11CF-8F52-0040333594A3>"
 225 "DWORD openclosed;"
 226 "DWORD positionquality;"
 227 "}"
 228 "template Animation"
 229 "{"
 230 "<3D82AB4F-62DA-11CF-AB39-0020AF71E433>"
 231 "[...]"
 232 "}"
 233 "template AnimationSet"
 234 "{"
 235 "<3D82AB50-62DA-11CF-AB39-0020AF71E433>"
 236 "[Animation]"
 237 "}"
 238 "template InlineData"
 239 "{"
 240 "<3A23EEA0-94B1-11D0-AB39-0020AF71E433>"
 241 "[BINARY]"
 242 "}"
 243 "template Url"
 244 "{"
 245 "<3A23EEA1-94B1-11D0-AB39-0020AF71E433>"
 246 "DWORD nUrls;"
 247 "array STRING urls[nUrls];"
 248 "}"
 249 "template ProgressiveMesh"
 250 "{"
 251 "<8A63C360-997D-11D0-941C-0080C80CFA7B>"
 252 "[Url,InlineData]"
 253 "}"
 254 "template Guid"
 255 "{"
 256 "<A42790E0-7810-11CF-8F52-0040333594A3>"
 257 "DWORD data1;"
 258 "WORD data2;"
 259 "WORD data3;"
 260 "array UCHAR data4[8];"
 261 "}"
 262 "template StringProperty"
 263 "{"
 264 "<7F0F21E0-BFE1-11D1-82C0-00A0C9697271>"
 265 "STRING key;"
 266 "STRING value;"
 267 "}"
 268 "template PropertyBag"
 269 "{"
 270 "<7F0F21E1-BFE1-11D1-82C0-00A0C9697271>"
 271 "[StringProperty]"
 272 "}"
 273 "template ExternalVisual"
 274 "{"
 275 "<98116AA0-BDBA-11D1-82C0-00A0C9697271>"
 276 "Guid guidExternalVisual;"
 277 "[...]"
 278 "}"
 279 "template RightHanded"
 280 "{"
 281 "<7F5D5EA0-D53A-11D1-82C0-00A0C9697271>"
 282 "DWORD bRightHanded;"
 283 "}"
 284 };
 285
 286 static BOOL d3drm_array_reserve(void **elements, SIZE_T *capacity, SIZE_T element_count, SIZE_T element_size)
 287 {
 288     SIZE_T new_capacity, max_capacity;
 289     void *new_elements;
 290
 291     if (element_count <= *capacity)
 292         return TRUE;
 293
 294     max_capacity = ~(SIZE_T)0 / element_size;
 295     if (max_capacity < element_count)
 296         return FALSE;
 297
 298     new_capacity = max(*capacity, 4);
 299     while (new_capacity < element_count && new_capacity <= max_capacity / 2)
 300         new_capacity *= 2;
 301
 302     if (new_capacity < element_count)
 303         new_capacity = max_capacity;
 304
 305     if (*elements)
 306         new_elements = HeapReAlloc(GetProcessHeap(), 0, *elements, new_capacity * element_size);
 307     else
 308         new_elements = HeapAlloc(GetProcessHeap(), 0, new_capacity * element_size);
 309
 310     if (!new_elements)
 311         return FALSE;
 312
 313     *elements = new_elements;
 314     *capacity = new_capacity;
 315     return TRUE;
 316 }
 317
 318 static inline struct d3drm_mesh *impl_from_IDirect3DRMMesh(IDirect3DRMMesh *iface)
 319 {
 320     return CONTAINING_RECORD(iface, struct d3drm_mesh, IDirect3DRMMesh_iface);
 321 }
 322
 323 static inline struct d3drm_mesh_builder *impl_from_IDirect3DRMMeshBuilder2(IDirect3DRMMeshBuilder2 *iface)
 324 {
 325     return CONTAINING_RECORD(iface, struct d3drm_mesh_builder, IDirect3DRMMeshBuilder2_iface);
 326 }
 327
 328 static inline struct d3drm_mesh_builder *impl_from_IDirect3DRMMeshBuilder3(IDirect3DRMMeshBuilder3 *iface)
 329 {
 330     return CONTAINING_RECORD(iface, struct d3drm_mesh_builder, IDirect3DRMMeshBuilder3_iface);
 331 }
 332
 333 static void clean_mesh_builder_data(struct d3drm_mesh_builder *mesh_builder)
 334 {
 335     DWORD i;
 336
 337     HeapFree(GetProcessHeap(), 0, mesh_builder->name);
 338     mesh_builder->name = NULL;
 339     HeapFree(GetProcessHeap(), 0, mesh_builder->vertices);
 340     mesh_builder->vertices = NULL;
 341     mesh_builder->nb_vertices = 0;
 342     mesh_builder->vertices_size = 0;
 343     HeapFree(GetProcessHeap(), 0, mesh_builder->normals);
 344     mesh_builder->normals = NULL;
 345     mesh_builder->nb_normals = 0;
 346     mesh_builder->normals_size = 0;
 347     HeapFree(GetProcessHeap(), 0, mesh_builder->pFaceData);
 348     mesh_builder->pFaceData = NULL;
 349     mesh_builder->face_data_size = 0;
 350     mesh_builder->nb_faces = 0;
 351     HeapFree(GetProcessHeap(), 0, mesh_builder->pCoords2d);
 352     mesh_builder->pCoords2d = NULL;
 353     mesh_builder->nb_coords2d = 0;
 354     for (i = 0; i < mesh_builder->nb_materials; i++)
 355     {
 356         if (mesh_builder->materials[i].material)
 357             IDirect3DRMMaterial2_Release(mesh_builder->materials[i].material);
 358         if (mesh_builder->materials[i].texture)
 359             IDirect3DRMTexture3_Release(mesh_builder->materials[i].texture);
 360     }
 361     mesh_builder->nb_materials = 0;
 362     HeapFree(GetProcessHeap(), 0, mesh_builder->materials);
 363     mesh_builder->materials = NULL;
 364     HeapFree(GetProcessHeap(), 0, mesh_builder->material_indices);
 365     mesh_builder->material_indices = NULL;
 366 }
 367
 368 static HRESULT WINAPI d3drm_mesh_builder2_QueryInterface(IDirect3DRMMeshBuilder2 *iface, REFIID riid, void **out)
 369 {
 370     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 371
 372     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 373
 374     if (IsEqualGUID(riid, &IID_IDirect3DRMMeshBuilder2)
 375             || IsEqualGUID(riid, &IID_IDirect3DRMMeshBuilder)
 376             || IsEqualGUID(riid, &IID_IDirect3DRMVisual)
 377             || IsEqualGUID(riid, &IID_IDirect3DRMObject)
 378             || IsEqualGUID(riid, &IID_IUnknown))
 379     {
 380         *out = &mesh_builder->IDirect3DRMMeshBuilder2_iface;
 381     }
 382     else if (IsEqualGUID(riid, &IID_IDirect3DRMMeshBuilder3))
 383     {
 384         *out = &mesh_builder->IDirect3DRMMeshBuilder3_iface;
 385     }
 386     else
 387     {
 388         *out = NULL;
 389         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 390         return E_NOINTERFACE;
 391     }
 392
 393     IUnknown_AddRef((IUnknown *)*out);
 394     return S_OK;
 395 }
 396
 397 static ULONG WINAPI d3drm_mesh_builder2_AddRef(IDirect3DRMMeshBuilder2 *iface)
 398 {
 399     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 400     ULONG refcount = InterlockedIncrement(&mesh_builder->ref);
 401
 402     TRACE("%p increasing refcount to %u.\n", mesh_builder, refcount);
 403
 404     return refcount;
 405 }
 406
 407 static ULONG WINAPI d3drm_mesh_builder2_Release(IDirect3DRMMeshBuilder2 *iface)
 408 {
 409     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 410     ULONG refcount = InterlockedDecrement(&mesh_builder->ref);
 411
 412     TRACE("%p decreasing refcount to %u.\n", mesh_builder, refcount);
 413
 414     if (!refcount)
 415     {
 416         d3drm_object_cleanup((IDirect3DRMObject *)iface, &mesh_builder->obj);
 417         clean_mesh_builder_data(mesh_builder);
 418         if (mesh_builder->material)
 419             IDirect3DRMMaterial2_Release(mesh_builder->material);
 420         if (mesh_builder->texture)
 421             IDirect3DRMTexture3_Release(mesh_builder->texture);
 422         IDirect3DRM_Release(mesh_builder->d3drm);
 423         HeapFree(GetProcessHeap(), 0, mesh_builder);
 424     }
 425
 426     return refcount;
 427 }
 428
 429 static HRESULT WINAPI d3drm_mesh_builder2_Clone(IDirect3DRMMeshBuilder2 *iface,
 430         IUnknown *outer, REFIID iid, void **out)
 431 {
 432     FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
 433
 434     return E_NOTIMPL;
 435 }
 436
 437 static HRESULT WINAPI d3drm_mesh_builder2_AddDestroyCallback(IDirect3DRMMeshBuilder2 *iface,
 438         D3DRMOBJECTCALLBACK cb, void *ctx)
 439 {
 440     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 441
 442     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
 443
 444     return IDirect3DRMMeshBuilder3_AddDestroyCallback(&mesh_builder->IDirect3DRMMeshBuilder3_iface, cb, ctx);
 445 }
 446
 447 static HRESULT WINAPI d3drm_mesh_builder2_DeleteDestroyCallback(IDirect3DRMMeshBuilder2 *iface,
 448         D3DRMOBJECTCALLBACK cb, void *ctx)
 449 {
 450     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 451
 452     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
 453
 454     return IDirect3DRMMeshBuilder3_DeleteDestroyCallback(&mesh_builder->IDirect3DRMMeshBuilder3_iface, cb, ctx);
 455 }
 456
 457 static HRESULT WINAPI d3drm_mesh_builder2_SetAppData(IDirect3DRMMeshBuilder2 *iface, DWORD data)
 458 {
 459     FIXME("iface %p, data %#x stub!\n", iface, data);
 460
 461     return E_NOTIMPL;
 462 }
 463
 464 static DWORD WINAPI d3drm_mesh_builder2_GetAppData(IDirect3DRMMeshBuilder2 *iface)
 465 {
 466     FIXME("iface %p stub!\n", iface);
 467
 468     return 0;
 469 }
 470
 471 static HRESULT WINAPI d3drm_mesh_builder2_SetName(IDirect3DRMMeshBuilder2 *iface, const char *name)
 472 {
 473     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 474
 475     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
 476
 477     return IDirect3DRMMeshBuilder3_SetName(&mesh_builder->IDirect3DRMMeshBuilder3_iface, name);
 478 }
 479
 480 static HRESULT WINAPI d3drm_mesh_builder2_GetName(IDirect3DRMMeshBuilder2 *iface, DWORD *size, char *name)
 481 {
 482     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 483
 484     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 485
 486     return IDirect3DRMMeshBuilder3_GetName(&mesh_builder->IDirect3DRMMeshBuilder3_iface, size, name);
 487 }
 488
 489 static HRESULT WINAPI d3drm_mesh_builder2_GetClassName(IDirect3DRMMeshBuilder2 *iface, DWORD *size, char *name)
 490 {
 491     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 492
 493     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 494
 495     return IDirect3DRMMeshBuilder3_GetClassName(&mesh_builder->IDirect3DRMMeshBuilder3_iface, size, name);
 496 }
 497
 498 static HRESULT WINAPI d3drm_mesh_builder2_Load(IDirect3DRMMeshBuilder2 *iface, void *filename,
 499         void *name, D3DRMLOADOPTIONS flags, D3DRMLOADTEXTURECALLBACK cb, void *ctx)
 500 {
 501     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 502
 503     TRACE("iface %p, filename %p, name %p, flags %#x, cb %p, ctx %p.\n",
 504             iface, filename, name, flags, cb, ctx);
 505
 506     if (cb)
 507         FIXME("Texture callback is not yet supported\n");
 508
 509     return IDirect3DRMMeshBuilder3_Load(&mesh_builder->IDirect3DRMMeshBuilder3_iface,
 510             filename, name, flags, NULL, ctx);
 511 }
 512
 513 static HRESULT WINAPI d3drm_mesh_builder2_Save(IDirect3DRMMeshBuilder2 *iface,
 514         const char *filename, D3DRMXOFFORMAT format, D3DRMSAVEOPTIONS flags)
 515 {
 516     FIXME("iface %p, filename %s, format %#x, flags %#x stub!\n",
 517             iface, debugstr_a(filename), format, flags);
 518
 519     return E_NOTIMPL;
 520 }
 521
 522 static HRESULT WINAPI d3drm_mesh_builder2_Scale(IDirect3DRMMeshBuilder2 *iface,
 523         D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
 524 {
 525     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 526
 527     TRACE("iface %p, sx %.8e, sy %.8e, sz %.8e.\n", iface, sx, sy, sz);
 528
 529     return IDirect3DRMMeshBuilder3_Scale(&mesh_builder->IDirect3DRMMeshBuilder3_iface, sx, sy, sz);
 530 }
 531
 532 static HRESULT WINAPI d3drm_mesh_builder2_Translate(IDirect3DRMMeshBuilder2 *iface,
 533         D3DVALUE tx, D3DVALUE ty, D3DVALUE tz)
 534 {
 535     FIXME("iface %p, tx %.8e, ty %.8e, tz %.8e stub!\n", iface, tx, ty, tz);
 536
 537     return E_NOTIMPL;
 538 }
 539
 540 static HRESULT WINAPI d3drm_mesh_builder2_SetColorSource(IDirect3DRMMeshBuilder2 *iface, D3DRMCOLORSOURCE source)
 541 {
 542     FIXME("iface %p, source %#x stub!\n", iface, source);
 543
 544     return E_NOTIMPL;
 545 }
 546
 547 static HRESULT WINAPI d3drm_mesh_builder2_GetBox(IDirect3DRMMeshBuilder2 *iface, D3DRMBOX *box)
 548 {
 549     FIXME("iface %p, box %p stub!\n", iface, box);
 550
 551     return E_NOTIMPL;
 552 }
 553
 554 static HRESULT WINAPI d3drm_mesh_builder2_GenerateNormals(IDirect3DRMMeshBuilder2 *iface)
 555 {
 556     FIXME("iface %p stub!\n", iface);
 557
 558     return E_NOTIMPL;
 559 }
 560
 561 static D3DRMCOLORSOURCE WINAPI d3drm_mesh_builder2_GetColorSource(IDirect3DRMMeshBuilder2 *iface)
 562 {
 563     FIXME("iface %p stub!\n", iface);
 564
 565     return E_NOTIMPL;
 566 }
 567
 568 static HRESULT WINAPI d3drm_mesh_builder2_AddMesh(IDirect3DRMMeshBuilder2 *iface, IDirect3DRMMesh *mesh)
 569 {
 570     FIXME("iface %p, mesh %p stub!\n", iface, mesh);
 571
 572     return E_NOTIMPL;
 573 }
 574
 575 static HRESULT WINAPI d3drm_mesh_builder2_AddMeshBuilder(IDirect3DRMMeshBuilder2 *iface,
 576         IDirect3DRMMeshBuilder *mesh_builder)
 577 {
 578     FIXME("iface %p, mesh_builder %p stub!\n", iface, mesh_builder);
 579
 580     return E_NOTIMPL;
 581 }
 582
 583 static HRESULT WINAPI d3drm_mesh_builder2_AddFrame(IDirect3DRMMeshBuilder2 *iface, IDirect3DRMFrame *frame)
 584 {
 585     FIXME("iface %p, frame %p stub!\n", iface, frame);
 586
 587     return E_NOTIMPL;
 588 }
 589
 590 static HRESULT WINAPI d3drm_mesh_builder2_AddFace(IDirect3DRMMeshBuilder2 *iface, IDirect3DRMFace *face)
 591 {
 592     FIXME("iface %p, face %p stub!\n", iface, face);
 593
 594     return E_NOTIMPL;
 595 }
 596
 597 static HRESULT WINAPI d3drm_mesh_builder2_AddFaces(IDirect3DRMMeshBuilder2 *iface,
 598         DWORD vertex_count, D3DVECTOR *vertices, DWORD normal_count, D3DVECTOR *normals,
 599         DWORD *face_data, IDirect3DRMFaceArray **array)
 600 {
 601     FIXME("iface %p, vertex_count %u, vertices %p, normal_count %u, normals %p, face_data %p, array %p stub!\n",
 602             iface, vertex_count, vertices, normal_count, normals, face_data, array);
 603
 604     return E_NOTIMPL;
 605 }
 606
 607 static HRESULT WINAPI d3drm_mesh_builder2_ReserveSpace(IDirect3DRMMeshBuilder2 *iface,
 608         DWORD vertex_count, DWORD normal_count, DWORD face_count)
 609 {
 610     FIXME("iface %p, vertex_count %u, normal_count %u, face_count %u stub!\n",
 611             iface, vertex_count, normal_count, face_count);
 612
 613     return E_NOTIMPL;
 614 }
 615
 616 static HRESULT WINAPI d3drm_mesh_builder2_SetColorRGB(IDirect3DRMMeshBuilder2 *iface,
 617         D3DVALUE red, D3DVALUE green, D3DVALUE blue)
 618 {
 619     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 620
 621     TRACE("iface %p, red %.8e, green %.8e, blue %.8e.\n", iface, red, green, blue);
 622
 623     return IDirect3DRMMeshBuilder3_SetColorRGB(&mesh_builder->IDirect3DRMMeshBuilder3_iface, red, green, blue);
 624 }
 625
 626 static HRESULT WINAPI d3drm_mesh_builder2_SetColor(IDirect3DRMMeshBuilder2 *iface, D3DCOLOR color)
 627 {
 628     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 629
 630     TRACE("iface %p, color 0x%08x.\n", iface, color);
 631
 632     return IDirect3DRMMeshBuilder3_SetColor(&mesh_builder->IDirect3DRMMeshBuilder3_iface, color);
 633 }
 634
 635 static HRESULT WINAPI d3drm_mesh_builder2_SetTexture(IDirect3DRMMeshBuilder2 *iface,
 636         IDirect3DRMTexture *texture)
 637 {
 638     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 639     IDirect3DRMTexture3 *texture3 = NULL;
 640     HRESULT hr = D3DRM_OK;
 641
 642     TRACE("iface %p, texture %p.\n", iface, texture);
 643
 644     if (texture)
 645         hr = IDirect3DRMTexture_QueryInterface(texture, &IID_IDirect3DRMTexture3, (void **)&texture3);
 646     if (SUCCEEDED(hr))
 647         hr = IDirect3DRMMeshBuilder3_SetTexture(&mesh_builder->IDirect3DRMMeshBuilder3_iface, texture3);
 648     if (texture3)
 649         IDirect3DRMTexture3_Release(texture3);
 650
 651     return hr;
 652 }
 653
 654 static HRESULT WINAPI d3drm_mesh_builder2_SetMaterial(IDirect3DRMMeshBuilder2 *iface,
 655         IDirect3DRMMaterial *material)
 656 {
 657     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 658
 659     TRACE("iface %p, material %p.\n", iface, material);
 660
 661     return IDirect3DRMMeshBuilder3_SetMaterial(&mesh_builder->IDirect3DRMMeshBuilder3_iface,
 662             (IDirect3DRMMaterial2 *)material);
 663 }
 664
 665 static HRESULT WINAPI d3drm_mesh_builder2_SetTextureTopology(IDirect3DRMMeshBuilder2 *iface,
 666         BOOL wrap_u, BOOL wrap_v)
 667 {
 668     FIXME("iface %p, wrap_u %#x, wrap_v %#x stub!\n", iface, wrap_u, wrap_v);
 669
 670     return E_NOTIMPL;
 671 }
 672
 673 static HRESULT WINAPI d3drm_mesh_builder2_SetQuality(IDirect3DRMMeshBuilder2 *iface,
 674         D3DRMRENDERQUALITY quality)
 675 {
 676     FIXME("iface %p, quality %#x stub!\n", iface, quality);
 677
 678     return E_NOTIMPL;
 679 }
 680
 681 static HRESULT WINAPI d3drm_mesh_builder2_SetPerspective(IDirect3DRMMeshBuilder2 *iface, BOOL enable)
 682 {
 683     FIXME("iface %p, enable %#x stub!\n", iface, enable);
 684
 685     return E_NOTIMPL;
 686 }
 687
 688 static HRESULT WINAPI d3drm_mesh_builder2_SetVertex(IDirect3DRMMeshBuilder2 *iface,
 689         DWORD index, D3DVALUE x, D3DVALUE y, D3DVALUE z)
 690 {
 691     FIXME("iface %p, index %u, x %.8e, y %.8e, z %.8e stub!\n", iface, index, x, y, z);
 692
 693     return E_NOTIMPL;
 694 }
 695
 696 static HRESULT WINAPI d3drm_mesh_builder2_SetNormal(IDirect3DRMMeshBuilder2 *iface,
 697         DWORD index, D3DVALUE x, D3DVALUE y, D3DVALUE z)
 698 {
 699     FIXME("iface %p, index %u, x %.8e, y %.8e, z %.8e stub!\n", iface, index, x, y, z);
 700
 701     return E_NOTIMPL;
 702 }
 703
 704 static HRESULT WINAPI d3drm_mesh_builder2_SetTextureCoordinates(IDirect3DRMMeshBuilder2 *iface,
 705         DWORD index, D3DVALUE u, D3DVALUE v)
 706 {
 707     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 708
 709     TRACE("iface %p, index %u, u %.8e, v %.8e.\n", iface, index, u, v);
 710
 711     return IDirect3DRMMeshBuilder3_SetTextureCoordinates(&mesh_builder->IDirect3DRMMeshBuilder3_iface,
 712             index, u, v);
 713 }
 714
 715 static HRESULT WINAPI d3drm_mesh_builder2_SetVertexColor(IDirect3DRMMeshBuilder2 *iface,
 716         DWORD index, D3DCOLOR color)
 717 {
 718     FIXME("iface %p, index %u, color 0x%08x stub!\n", iface, index, color);
 719
 720     return E_NOTIMPL;
 721 }
 722
 723 static HRESULT WINAPI d3drm_mesh_builder2_SetVertexColorRGB(IDirect3DRMMeshBuilder2 *iface,
 724         DWORD index, D3DVALUE red, D3DVALUE green, D3DVALUE blue)
 725 {
 726     FIXME("iface %p, index %u, red %.8e, green %.8e, blue %.8e stub!\n",
 727             iface, index, red, green, blue);
 728
 729     return E_NOTIMPL;
 730 }
 731
 732 static HRESULT WINAPI d3drm_mesh_builder2_GetFaces(IDirect3DRMMeshBuilder2 *iface,
 733         IDirect3DRMFaceArray **array)
 734 {
 735     FIXME("iface %p, array %p stub!\n", iface, array);
 736
 737     return E_NOTIMPL;
 738 }
 739
 740 static HRESULT WINAPI d3drm_mesh_builder2_GetVertices(IDirect3DRMMeshBuilder2 *iface,
 741         DWORD *vertex_count, D3DVECTOR *vertices, DWORD *normal_count, D3DVECTOR *normals,
 742         DWORD *face_data_size, DWORD *face_data)
 743 {
 744     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 745
 746     TRACE("iface %p, vertex_count %p, vertices %p, normal_count %p, normals %p, face_data_size %p, face_data %p.\n",
 747             iface, vertex_count, vertices, normal_count, normals, face_data_size, face_data);
 748
 749     if (vertices && (!vertex_count || (*vertex_count < mesh_builder->nb_vertices)))
 750         return D3DRMERR_BADVALUE;
 751     if (vertex_count)
 752         *vertex_count = mesh_builder->nb_vertices;
 753     if (vertices && mesh_builder->nb_vertices)
 754         memcpy(vertices, mesh_builder->vertices, mesh_builder->nb_vertices * sizeof(*vertices));
 755
 756     if (normals && (!normal_count || (*normal_count < mesh_builder->nb_normals)))
 757         return D3DRMERR_BADVALUE;
 758     if (normal_count)
 759         *normal_count = mesh_builder->nb_normals;
 760     if (normals && mesh_builder->nb_normals)
 761         memcpy(normals, mesh_builder->normals, mesh_builder->nb_normals * sizeof(*normals));
 762
 763     if (face_data && (!face_data_size || (*face_data_size < mesh_builder->face_data_size)))
 764         return D3DRMERR_BADVALUE;
 765     if (face_data_size)
 766         *face_data_size = mesh_builder->face_data_size;
 767     if (face_data && mesh_builder->face_data_size)
 768         memcpy(face_data, mesh_builder->pFaceData, mesh_builder->face_data_size * sizeof(*face_data));
 769
 770     return D3DRM_OK;
 771 }
 772
 773 static HRESULT WINAPI d3drm_mesh_builder2_GetTextureCoordinates(IDirect3DRMMeshBuilder2 *iface,
 774         DWORD index, D3DVALUE *u, D3DVALUE *v)
 775 {
 776     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 777
 778     TRACE("iface %p, index %u, u %p, v %p.\n", iface, index, u, v);
 779
 780     return IDirect3DRMMeshBuilder3_GetTextureCoordinates(&mesh_builder->IDirect3DRMMeshBuilder3_iface,
 781             index, u, v);
 782 }
 783
 784 static int WINAPI d3drm_mesh_builder2_AddVertex(IDirect3DRMMeshBuilder2 *iface,
 785         D3DVALUE x, D3DVALUE y, D3DVALUE z)
 786 {
 787     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 788
 789     TRACE("iface %p, x %.8e, y %.8e, z %.8e.\n", iface, x, y, z);
 790
 791     return IDirect3DRMMeshBuilder3_AddVertex(&mesh_builder->IDirect3DRMMeshBuilder3_iface, x, y, z);
 792 }
 793
 794 static int WINAPI d3drm_mesh_builder2_AddNormal(IDirect3DRMMeshBuilder2 *iface,
 795         D3DVALUE x, D3DVALUE y, D3DVALUE z)
 796 {
 797     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 798
 799     TRACE("iface %p, x %.8e, y %.8e, z %.8e.\n", iface, x, y, z);
 800
 801     return IDirect3DRMMeshBuilder3_AddNormal(&mesh_builder->IDirect3DRMMeshBuilder3_iface, x, y, z);
 802 }
 803
 804 static HRESULT WINAPI d3drm_mesh_builder2_CreateFace(IDirect3DRMMeshBuilder2 *iface, IDirect3DRMFace **face)
 805 {
 806     struct d3drm_face *object;
 807     HRESULT hr;
 808
 809     TRACE("iface %p, face %p.\n", iface, face);
 810
 811     if (FAILED(hr = d3drm_face_create(&object)))
 812         return hr;
 813
 814     *face = &object->IDirect3DRMFace_iface;
 815
 816     return S_OK;
 817 }
 818
 819 static D3DRMRENDERQUALITY WINAPI d3drm_mesh_builder2_GetQuality(IDirect3DRMMeshBuilder2 *iface)
 820 {
 821     FIXME("iface %p stub!\n", iface);
 822
 823     return 0;
 824 }
 825
 826 static BOOL WINAPI d3drm_mesh_builder2_GetPerspective(IDirect3DRMMeshBuilder2 *iface)
 827 {
 828     FIXME("iface %p stub!\n", iface);
 829
 830     return FALSE;
 831 }
 832
 833 static int WINAPI d3drm_mesh_builder2_GetFaceCount(IDirect3DRMMeshBuilder2 *iface)
 834 {
 835     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 836
 837     TRACE("iface %p.\n", iface);
 838
 839     return mesh_builder->nb_faces;
 840 }
 841
 842 static int WINAPI d3drm_mesh_builder2_GetVertexCount(IDirect3DRMMeshBuilder2 *iface)
 843 {
 844     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 845
 846     TRACE("iface %p.\n", iface);
 847
 848     return mesh_builder->nb_vertices;
 849 }
 850
 851 static D3DCOLOR WINAPI d3drm_mesh_builder2_GetVertexColor(IDirect3DRMMeshBuilder2 *iface, DWORD index)
 852 {
 853     FIXME("iface %p, index %u stub!\n", iface, index);
 854
 855     return 0;
 856 }
 857
 858 static HRESULT WINAPI d3drm_mesh_builder2_CreateMesh(IDirect3DRMMeshBuilder2 *iface, IDirect3DRMMesh **mesh)
 859 {
 860     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder2(iface);
 861
 862     TRACE("iface %p, mesh %p.\n", iface, mesh);
 863
 864     return IDirect3DRMMeshBuilder3_CreateMesh(&mesh_builder->IDirect3DRMMeshBuilder3_iface, mesh);
 865 }
 866
 867 static HRESULT WINAPI d3drm_mesh_builder2_GenerateNormals2(IDirect3DRMMeshBuilder2 *iface,
 868         D3DVALUE crease, DWORD flags)
 869 {
 870     FIXME("iface %p, crease %.8e, flags %#x stub!\n", iface, crease, flags);
 871
 872     return E_NOTIMPL;
 873 }
 874
 875 static HRESULT WINAPI d3drm_mesh_builder2_GetFace(IDirect3DRMMeshBuilder2 *iface,
 876         DWORD index, IDirect3DRMFace **face)
 877 {
 878     FIXME("iface %p, index %u, face %p stub!\n", iface, index, face);
 879
 880     return E_NOTIMPL;
 881 }
 882
 883 static const struct IDirect3DRMMeshBuilder2Vtbl d3drm_mesh_builder2_vtbl =
 884 {
 885     d3drm_mesh_builder2_QueryInterface,
 886     d3drm_mesh_builder2_AddRef,
 887     d3drm_mesh_builder2_Release,
 888     d3drm_mesh_builder2_Clone,
 889     d3drm_mesh_builder2_AddDestroyCallback,
 890     d3drm_mesh_builder2_DeleteDestroyCallback,
 891     d3drm_mesh_builder2_SetAppData,
 892     d3drm_mesh_builder2_GetAppData,
 893     d3drm_mesh_builder2_SetName,
 894     d3drm_mesh_builder2_GetName,
 895     d3drm_mesh_builder2_GetClassName,
 896     d3drm_mesh_builder2_Load,
 897     d3drm_mesh_builder2_Save,
 898     d3drm_mesh_builder2_Scale,
 899     d3drm_mesh_builder2_Translate,
 900     d3drm_mesh_builder2_SetColorSource,
 901     d3drm_mesh_builder2_GetBox,
 902     d3drm_mesh_builder2_GenerateNormals,
 903     d3drm_mesh_builder2_GetColorSource,
 904     d3drm_mesh_builder2_AddMesh,
 905     d3drm_mesh_builder2_AddMeshBuilder,
 906     d3drm_mesh_builder2_AddFrame,
 907     d3drm_mesh_builder2_AddFace,
 908     d3drm_mesh_builder2_AddFaces,
 909     d3drm_mesh_builder2_ReserveSpace,
 910     d3drm_mesh_builder2_SetColorRGB,
 911     d3drm_mesh_builder2_SetColor,
 912     d3drm_mesh_builder2_SetTexture,
 913     d3drm_mesh_builder2_SetMaterial,
 914     d3drm_mesh_builder2_SetTextureTopology,
 915     d3drm_mesh_builder2_SetQuality,
 916     d3drm_mesh_builder2_SetPerspective,
 917     d3drm_mesh_builder2_SetVertex,
 918     d3drm_mesh_builder2_SetNormal,
 919     d3drm_mesh_builder2_SetTextureCoordinates,
 920     d3drm_mesh_builder2_SetVertexColor,
 921     d3drm_mesh_builder2_SetVertexColorRGB,
 922     d3drm_mesh_builder2_GetFaces,
 923     d3drm_mesh_builder2_GetVertices,
 924     d3drm_mesh_builder2_GetTextureCoordinates,
 925     d3drm_mesh_builder2_AddVertex,
 926     d3drm_mesh_builder2_AddNormal,
 927     d3drm_mesh_builder2_CreateFace,
 928     d3drm_mesh_builder2_GetQuality,
 929     d3drm_mesh_builder2_GetPerspective,
 930     d3drm_mesh_builder2_GetFaceCount,
 931     d3drm_mesh_builder2_GetVertexCount,
 932     d3drm_mesh_builder2_GetVertexColor,
 933     d3drm_mesh_builder2_CreateMesh,
 934     d3drm_mesh_builder2_GenerateNormals2,
 935     d3drm_mesh_builder2_GetFace,
 936 };
 937
 938 static HRESULT WINAPI d3drm_mesh_builder3_QueryInterface(IDirect3DRMMeshBuilder3 *iface, REFIID riid, void **out)
 939 {
 940     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
 941
 942     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 943
 944     return d3drm_mesh_builder2_QueryInterface(&mesh_builder->IDirect3DRMMeshBuilder2_iface, riid, out);
 945 }
 946
 947 static ULONG WINAPI d3drm_mesh_builder3_AddRef(IDirect3DRMMeshBuilder3 *iface)
 948 {
 949     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
 950
 951     TRACE("iface %p.\n", iface);
 952
 953     return d3drm_mesh_builder2_AddRef(&mesh_builder->IDirect3DRMMeshBuilder2_iface);
 954 }
 955
 956 static ULONG WINAPI d3drm_mesh_builder3_Release(IDirect3DRMMeshBuilder3 *iface)
 957 {
 958     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
 959
 960     TRACE("iface %p.\n", iface);
 961
 962     return d3drm_mesh_builder2_Release(&mesh_builder->IDirect3DRMMeshBuilder2_iface);
 963 }
 964
 965 static HRESULT WINAPI d3drm_mesh_builder3_Clone(IDirect3DRMMeshBuilder3 *iface,
 966         IUnknown *outer, REFIID iid, void **out)
 967 {
 968     FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
 969
 970     return E_NOTIMPL;
 971 }
 972
 973 static HRESULT WINAPI d3drm_mesh_builder3_AddDestroyCallback(IDirect3DRMMeshBuilder3 *iface,
 974         D3DRMOBJECTCALLBACK cb, void *ctx)
 975 {
 976     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
 977
 978     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
 979
 980     return d3drm_object_add_destroy_callback(&mesh_builder->obj, cb, ctx);
 981 }
 982
 983 static HRESULT WINAPI d3drm_mesh_builder3_DeleteDestroyCallback(IDirect3DRMMeshBuilder3 *iface,
 984         D3DRMOBJECTCALLBACK cb, void *ctx)
 985 {
 986     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
 987
 988     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
 989
 990     return d3drm_object_delete_destroy_callback(&mesh_builder->obj, cb, ctx);
 991 }
 992
 993 static HRESULT WINAPI d3drm_mesh_builder3_SetAppData(IDirect3DRMMeshBuilder3 *iface, DWORD data)
 994 {
 995     FIXME("iface %p, data %#x stub!\n", iface, data);
 996
 997     return E_NOTIMPL;
 998 }
 999
1000 static DWORD WINAPI d3drm_mesh_builder3_GetAppData(IDirect3DRMMeshBuilder3 *iface)
1001 {
1002     FIXME("iface %p stub!\n", iface);
1003
1004     return 0;
1005 }
1006
1007 static HRESULT WINAPI d3drm_mesh_builder3_SetName(IDirect3DRMMeshBuilder3 *iface, const char *name)
1008 {
1009     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
1010     char *string = NULL;
1011
1012     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
1013
1014     if (name)
1015     {
1016         string = HeapAlloc(GetProcessHeap(), 0, strlen(name) + 1);
1017         if (!string) return E_OUTOFMEMORY;
1018         strcpy(string, name);
1019     }
1020     HeapFree(GetProcessHeap(), 0, mesh_builder->name);
1021     mesh_builder->name = string;
1022
1023     return D3DRM_OK;
1024 }
1025
1026 static HRESULT WINAPI d3drm_mesh_builder3_GetName(IDirect3DRMMeshBuilder3 *iface,
1027         DWORD *size, char *name)
1028 {
1029     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
1030
1031     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
1032
1033     if (!size)
1034         return E_POINTER;
1035
1036     if (!mesh_builder->name)
1037     {
1038         *size = 0;
1039         return D3DRM_OK;
1040     }
1041
1042     if (*size < (strlen(mesh_builder->name) + 1))
1043         return E_INVALIDARG;
1044
1045     strcpy(name, mesh_builder->name);
1046     *size = strlen(mesh_builder->name) + 1;
1047
1048     return D3DRM_OK;
1049 }
1050
1051 static HRESULT WINAPI d3drm_mesh_builder3_GetClassName(IDirect3DRMMeshBuilder3 *iface,
1052         DWORD *size, char *name)
1053 {
1054     struct d3drm_mesh_builder *meshbuilder = impl_from_IDirect3DRMMeshBuilder3(iface);
1055
1056     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
1057
1058     return d3drm_object_get_class_name(&meshbuilder->obj, size, name);
1059 }
1060
1061 HRESULT load_mesh_data(IDirect3DRMMeshBuilder3 *iface, IDirectXFileData *pData,
1062         D3DRMLOADTEXTURECALLBACK load_texture_proc, void *arg)
1063 {
1064     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
1065     IDirectXFileData *pData2 = NULL;
1066     const GUID* guid;
1067     DWORD size;
1068     BYTE *ptr;
1069     HRESULT hr;
1070     HRESULT ret = D3DRMERR_BADOBJECT;
1071     DWORD* faces_vertex_idx_data = NULL;
1072     DWORD* faces_vertex_idx_ptr;
1073     DWORD faces_vertex_idx_size;
1074     DWORD* faces_normal_idx_data = NULL;
1075     DWORD* faces_normal_idx_ptr = NULL;
1076     DWORD* faces_data_ptr;
1077     DWORD faces_data_size = 0;
1078     DWORD i;
1079
1080     TRACE("(%p)->(%p)\n", mesh_builder, pData);
1081
1082     hr = IDirectXFileData_GetName(pData, NULL, &size);
1083     if (hr != DXFILE_OK)
1084         return hr;
1085     if (size)
1086     {
1087         mesh_builder->name = HeapAlloc(GetProcessHeap(), 0, size);
1088         if (!mesh_builder->name)
1089             return E_OUTOFMEMORY;
1090
1091         hr = IDirectXFileData_GetName(pData, mesh_builder->name, &size);
1092         if (hr != DXFILE_OK)
1093             return hr;
1094     }
1095
1096     TRACE("Mesh name is %s\n", debugstr_a(mesh_builder->name));
1097
1098     mesh_builder->nb_normals = 0;
1099
1100     hr = IDirectXFileData_GetData(pData, NULL, &size, (void**)&ptr);
1101     if (hr != DXFILE_OK)
1102         goto end;
1103
1104     mesh_builder->nb_vertices = *(DWORD*)ptr;
1105     mesh_builder->nb_faces = *(DWORD*)(ptr + sizeof(DWORD) + mesh_builder->nb_vertices * sizeof(D3DVECTOR));
1106     faces_vertex_idx_size = size - sizeof(DWORD) - mesh_builder->nb_vertices * sizeof(D3DVECTOR) - sizeof(DWORD);
1107
1108     TRACE("Mesh: nb_vertices = %lu, nb_faces = %d, faces_vertex_idx_size = %d\n", mesh_builder->nb_vertices,
1109             mesh_builder->nb_faces, faces_vertex_idx_size);
1110
1111     if (!d3drm_array_reserve((void **)&mesh_builder->vertices, &mesh_builder->vertices_size, mesh_builder->nb_vertices,
1112            sizeof(*mesh_builder->vertices)))
1113     {
1114         hr = E_OUTOFMEMORY;
1115         goto end;
1116     }
1117     memcpy(mesh_builder->vertices, ptr + sizeof(DWORD), mesh_builder->nb_vertices * sizeof(D3DVECTOR));
1118
1119     faces_vertex_idx_ptr = faces_vertex_idx_data = HeapAlloc(GetProcessHeap(), 0, faces_vertex_idx_size);
1120     memcpy(faces_vertex_idx_data, ptr + sizeof(DWORD) + mesh_builder->nb_vertices * sizeof(D3DVECTOR) + sizeof(DWORD),
1121             faces_vertex_idx_size);
1122
1123     /* Each vertex index will have its normal index counterpart so just allocate twice the size */
1124     mesh_builder->pFaceData = HeapAlloc(GetProcessHeap(), 0, faces_vertex_idx_size * 2);
1125     faces_data_ptr = (DWORD*)mesh_builder->pFaceData;
1126
1127     while (1)
1128     {
1129         IDirectXFileObject *object;
1130
1131         hr =  IDirectXFileData_GetNextObject(pData, &object);
1132         if (hr == DXFILEERR_NOMOREOBJECTS)
1133         {
1134             TRACE("No more object\n");
1135             break;
1136         }
1137         if (hr != DXFILE_OK)
1138            goto end;
1139
1140         hr = IDirectXFileObject_QueryInterface(object, &IID_IDirectXFileData, (void**)&pData2);
1141         IDirectXFileObject_Release(object);
1142         if (hr != DXFILE_OK)
1143             goto end;
1144
1145         hr = IDirectXFileData_GetType(pData2, &guid);
1146         if (hr != DXFILE_OK)
1147             goto end;
1148
1149         TRACE("Found object type whose GUID = %s\n", debugstr_guid(guid));
1150
1151         if (IsEqualGUID(guid, &TID_D3DRMMeshNormals))
1152         {
1153             DWORD nb_faces_normals;
1154             DWORD faces_normal_idx_size;
1155
1156             hr = IDirectXFileData_GetData(pData2, NULL, &size, (void**)&ptr);
1157             if (hr != DXFILE_OK)
1158                 goto end;
1159
1160             mesh_builder->nb_normals = *(DWORD*)ptr;
1161             nb_faces_normals = *(DWORD*)(ptr + sizeof(DWORD) + mesh_builder->nb_normals * sizeof(D3DVECTOR));
1162
1163             TRACE("MeshNormals: nb_normals = %lu, nb_faces_normals = %d\n", mesh_builder->nb_normals, nb_faces_normals);
1164             if (nb_faces_normals != mesh_builder->nb_faces)
1165                 WARN("nb_face_normals (%d) != nb_faces (%d)\n", nb_faces_normals, mesh_builder->nb_faces);
1166
1167             if (!d3drm_array_reserve((void **)&mesh_builder->normals, &mesh_builder->normals_size,
1168                     mesh_builder->nb_normals, sizeof(*mesh_builder->normals)))
1169             {
1170                 hr = E_OUTOFMEMORY;
1171                 goto end;
1172             }
1173             memcpy(mesh_builder->normals, ptr + sizeof(DWORD), mesh_builder->nb_normals * sizeof(D3DVECTOR));
1174
1175             faces_normal_idx_size = size - (2 * sizeof(DWORD) + mesh_builder->nb_normals * sizeof(D3DVECTOR));
1176             faces_normal_idx_ptr = faces_normal_idx_data = HeapAlloc(GetProcessHeap(), 0, faces_normal_idx_size);
1177             memcpy(faces_normal_idx_data, ptr + sizeof(DWORD) + mesh_builder->nb_normals * sizeof(D3DVECTOR) + sizeof(DWORD), faces_normal_idx_size);
1178         }
1179         else if (IsEqualGUID(guid, &TID_D3DRMMeshTextureCoords))
1180         {
1181             hr = IDirectXFileData_GetData(pData2, NULL, &size, (void**)&ptr);
1182             if (hr != DXFILE_OK)
1183                 goto end;
1184
1185             mesh_builder->nb_coords2d = *(DWORD*)ptr;
1186
1187             TRACE("MeshTextureCoords: nb_coords2d = %d\n", mesh_builder->nb_coords2d);
1188
1189             mesh_builder->pCoords2d = HeapAlloc(GetProcessHeap(), 0, mesh_builder->nb_coords2d * sizeof(*mesh_builder->pCoords2d));
1190             memcpy(mesh_builder->pCoords2d, ptr + sizeof(DWORD), mesh_builder->nb_coords2d * sizeof(*mesh_builder->pCoords2d));
1191         }
1192         else if (IsEqualGUID(guid, &TID_D3DRMMeshMaterialList))
1193         {
1194             DWORD nb_materials;
1195             DWORD nb_face_indices;
1196             DWORD data_size;
1197             IDirectXFileObject *child;
1198             DWORD i = 0;
1199             float* values;
1200             struct d3drm_texture *texture_object;
1201
1202             TRACE("Process MeshMaterialList\n");
1203
1204             hr = IDirectXFileData_GetData(pData2, NULL, &size, (void**)&ptr);
1205             if (hr != DXFILE_OK)
1206                 goto end;
1207
1208             nb_materials = *(DWORD*)ptr;
1209             nb_face_indices = *(DWORD*)(ptr + sizeof(DWORD));
1210             data_size = 2 * sizeof(DWORD) + nb_face_indices * sizeof(DWORD);
1211
1212             TRACE("nMaterials = %u, nFaceIndexes = %u\n", nb_materials, nb_face_indices);
1213
1214             if (size != data_size)
1215                 WARN("Returned size %u does not match expected one %u\n", size, data_size);
1216
1217             mesh_builder->material_indices = HeapAlloc(GetProcessHeap(), 0, sizeof(*mesh_builder->material_indices) * nb_face_indices);
1218             if (!mesh_builder->material_indices)
1219                 goto end;
1220             memcpy(mesh_builder->material_indices, ptr + 2 * sizeof(DWORD), sizeof(*mesh_builder->material_indices) * nb_face_indices),
1221
1222             mesh_builder->materials = HeapAlloc(GetProcessHeap(), 0, sizeof(*mesh_builder->materials) * nb_materials);
1223             if (!mesh_builder->materials)
1224             {
1225                 HeapFree(GetProcessHeap(), 0, mesh_builder->material_indices);
1226                 goto end;
1227             }
1228             mesh_builder->nb_materials = nb_materials;
1229
1230             while (SUCCEEDED(hr = IDirectXFileData_GetNextObject(pData2, &child)) && (i < nb_materials))
1231             {
1232                 IDirectXFileData *data;
1233                 IDirectXFileDataReference *reference;
1234                 IDirectXFileObject *material_child;
1235                 struct d3drm_material *object;
1236
1237                 hr = IDirectXFileObject_QueryInterface(child, &IID_IDirectXFileData, (void **)&data);
1238                 if (FAILED(hr))
1239                 {
1240                     hr = IDirectXFileObject_QueryInterface(child, &IID_IDirectXFileDataReference, (void **)&reference);
1241                     IDirectXFileObject_Release(child);
1242                     if (FAILED(hr))
1243                         goto end;
1244
1245                     hr = IDirectXFileDataReference_Resolve(reference, &data);
1246                     IDirectXFileDataReference_Release(reference);
1247                     if (FAILED(hr))
1248                         goto end;
1249                 }
1250                 else
1251                 {
1252                     IDirectXFileObject_Release(child);
1253                 }
1254
1255                 hr = d3drm_material_create(&object, mesh_builder->d3drm);
1256                 if (FAILED(hr))
1257                 {
1258                     IDirectXFileData_Release(data);
1259                     goto end;
1260                 }
1261                 mesh_builder->materials[i].material = &object->IDirect3DRMMaterial2_iface;
1262
1263                 hr = IDirectXFileData_GetData(data, NULL, &size, (void**)&ptr);
1264                 if (hr != DXFILE_OK)
1265                 {
1266                     IDirectXFileData_Release(data);
1267                     goto end;
1268                 }
1269
1270                 if (size != 44)
1271                     WARN("Material size %u does not match expected one %u\n", size, 44);
1272
1273                 values = (float*)ptr;
1274
1275                 d3drm_set_color(&mesh_builder->materials[i].color, values[0], values[1], values[2], values[3]);
1276
1277                 IDirect3DRMMaterial2_SetAmbient(mesh_builder->materials[i].material, values[0], values [1], values[2]); /* Alpha ignored */
1278                 IDirect3DRMMaterial2_SetPower(mesh_builder->materials[i].material, values[4]);
1279                 IDirect3DRMMaterial2_SetSpecular(mesh_builder->materials[i].material, values[5], values[6], values[7]);
1280                 IDirect3DRMMaterial2_SetEmissive(mesh_builder->materials[i].material, values[8], values[9], values[10]);
1281
1282                 mesh_builder->materials[i].texture = NULL;
1283
1284                 hr = IDirectXFileData_GetNextObject(data, &material_child);
1285                 if (hr == S_OK)
1286                 {
1287                     IDirectXFileData *data;
1288                     char **filename;
1289
1290                     if (FAILED(hr = IDirectXFileObject_QueryInterface(material_child,
1291                             &IID_IDirectXFileData, (void **)&data)))
1292                     {
1293                         IDirectXFileDataReference *reference;
1294
1295                         if (SUCCEEDED(IDirectXFileObject_QueryInterface(material_child,
1296                                 &IID_IDirectXFileDataReference, (void **)&reference)))
1297                         {
1298                             hr = IDirectXFileDataReference_Resolve(reference, &data);
1299                             IDirectXFileDataReference_Release(reference);
1300                         }
1301                     }
1302                     IDirectXFileObject_Release(material_child);
1303                     if (FAILED(hr))
1304                         goto end;
1305
1306                     hr = IDirectXFileData_GetType(data, &guid);
1307                     if (hr != DXFILE_OK)
1308                         goto end;
1309                     if (!IsEqualGUID(guid, &TID_D3DRMTextureFilename))
1310                     {
1311                          WARN("Not a texture filename\n");
1312                          goto end;
1313                     }
1314
1315                     size = 4;
1316                     hr = IDirectXFileData_GetData(data, NULL, &size, (void**)&filename);
1317                     if (SUCCEEDED(hr))
1318                     {
1319                         if (load_texture_proc)
1320                         {
1321                             IDirect3DRMTexture *texture;
1322
1323                             hr = load_texture_proc(*filename, arg, &texture);
1324                             if (SUCCEEDED(hr))
1325                             {
1326                                 hr = IDirect3DTexture_QueryInterface(texture, &IID_IDirect3DRMTexture3,
1327                                         (void **)&mesh_builder->materials[i].texture);
1328                                 IDirect3DTexture_Release(texture);
1329                             }
1330                         }
1331                         else
1332                         {
1333                             HANDLE file;
1334
1335                             /* If the texture file is not found, no texture is associated with the material */
1336                             file = CreateFileA(*filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
1337                             if (file != INVALID_HANDLE_VALUE)
1338                             {
1339                                 CloseHandle(file);
1340                                 if (FAILED(hr = d3drm_texture_create(&texture_object, NULL)))
1341                                 {
1342                                     IDirectXFileData_Release(data);
1343                                     goto end;
1344                                 }
1345                                 mesh_builder->materials[i].texture = &texture_object->IDirect3DRMTexture3_iface;
1346                             }
1347                         }
1348                     }
1349                     IDirectXFileData_Release(data);
1350                 }
1351                 else if (hr != DXFILEERR_NOMOREOBJECTS)
1352                 {
1353                     goto end;
1354                 }
1355                 hr = S_OK;
1356
1357                 IDirectXFileData_Release(data);
1358                 i++;
1359             }
1360             if (hr == S_OK)
1361             {
1362                 IDirectXFileObject_Release(child);
1363                 WARN("Found more sub-objects than expected\n");
1364             }
1365             else if (hr != DXFILEERR_NOMOREOBJECTS)
1366             {
1367                 goto end;
1368             }
1369             hr = S_OK;
1370         }
1371         else
1372         {
1373             FIXME("Unknown GUID %s, ignoring...\n", debugstr_guid(guid));
1374         }
1375
1376         IDirectXFileData_Release(pData2);
1377         pData2 = NULL;
1378     }
1379
1380     if (!mesh_builder->nb_normals)
1381     {
1382         /* Allocate normals, one per vertex */
1383         if (!d3drm_array_reserve((void **)&mesh_builder->normals, &mesh_builder->normals_size,
1384                 mesh_builder->nb_vertices, sizeof(*mesh_builder->normals)))
1385             goto end;
1386         memset(mesh_builder->normals, 0, mesh_builder->nb_vertices * sizeof(*mesh_builder->normals));
1387     }
1388
1389     for (i = 0; i < mesh_builder->nb_faces; i++)
1390     {
1391         DWORD j;
1392         DWORD nb_face_indexes;
1393         D3DVECTOR face_normal;
1394
1395         if (faces_vertex_idx_size < sizeof(DWORD))
1396             WARN("Not enough data to read number of indices of face %d\n", i);
1397
1398         nb_face_indexes  = *(faces_data_ptr + faces_data_size++) = *(faces_vertex_idx_ptr++);
1399         faces_vertex_idx_size--;
1400         if (faces_normal_idx_data && (*(faces_normal_idx_ptr++) != nb_face_indexes))
1401             WARN("Faces indices number mismatch\n");
1402
1403         if (faces_vertex_idx_size < (nb_face_indexes * sizeof(DWORD)))
1404             WARN("Not enough data to read all indices of face %d\n", i);
1405
1406         if (!mesh_builder->nb_normals)
1407         {
1408             /* Compute face normal */
1409             if (nb_face_indexes > 2
1410                     && faces_vertex_idx_ptr[0] < mesh_builder->nb_vertices
1411                     && faces_vertex_idx_ptr[1] < mesh_builder->nb_vertices
1412                     && faces_vertex_idx_ptr[2] < mesh_builder->nb_vertices)
1413             {
1414                 D3DVECTOR a, b;
1415
1416                 D3DRMVectorSubtract(&a, &mesh_builder->vertices[faces_vertex_idx_ptr[2]], &mesh_builder->vertices[faces_vertex_idx_ptr[1]]);
1417                 D3DRMVectorSubtract(&b, &mesh_builder->vertices[faces_vertex_idx_ptr[0]], &mesh_builder->vertices[faces_vertex_idx_ptr[1]]);
1418                 D3DRMVectorCrossProduct(&face_normal, &a, &b);
1419                 D3DRMVectorNormalize(&face_normal);
1420             }
1421             else
1422             {
1423                 face_normal.u1.x = 0.0f;
1424                 face_normal.u2.y = 0.0f;
1425                 face_normal.u3.z = 0.0f;
1426             }
1427         }
1428
1429         for (j = 0; j < nb_face_indexes; j++)
1430         {
1431             /* Copy vertex index */
1432             *(faces_data_ptr + faces_data_size++) = *faces_vertex_idx_ptr;
1433             /* Copy normal index */
1434             if (mesh_builder->nb_normals)
1435             {
1436                 /* Read from x file */
1437                 *(faces_data_ptr + faces_data_size++) = *(faces_normal_idx_ptr++);
1438             }
1439             else
1440             {
1441                 DWORD vertex_idx = *faces_vertex_idx_ptr;
1442                 if (vertex_idx >= mesh_builder->nb_vertices)
1443                 {
1444                     WARN("Found vertex index %u but only %lu vertices available => use index 0\n", vertex_idx,
1445                             mesh_builder->nb_vertices);
1446                     vertex_idx = 0;
1447                 }
1448                 *(faces_data_ptr + faces_data_size++) = vertex_idx;
1449                 /* Add face normal to vertex normal */
1450                 D3DRMVectorAdd(&mesh_builder->normals[vertex_idx], &mesh_builder->normals[vertex_idx], &face_normal);
1451             }
1452             faces_vertex_idx_ptr++;
1453         }
1454         faces_vertex_idx_size -= nb_face_indexes;
1455     }
1456
1457     /* Last DWORD must be 0 */
1458     *(faces_data_ptr + faces_data_size++) = 0;
1459
1460     /* Set size (in number of DWORD) of all faces data */
1461     mesh_builder->face_data_size = faces_data_size;
1462
1463     if (!mesh_builder->nb_normals)
1464     {
1465         /* Normalize all normals */
1466         for (i = 0; i < mesh_builder->nb_vertices; i++)
1467         {
1468             D3DRMVectorNormalize(&mesh_builder->normals[i]);
1469         }
1470         mesh_builder->nb_normals = mesh_builder->nb_vertices;
1471     }
1472
1473     /* If there is no texture coordinates, generate default texture coordinates (0.0f, 0.0f) for each vertex */
1474     if (!mesh_builder->pCoords2d)
1475     {
1476         mesh_builder->nb_coords2d = mesh_builder->nb_vertices;
1477         mesh_builder->pCoords2d = HeapAlloc(GetProcessHeap(), 0, mesh_builder->nb_coords2d * sizeof(*mesh_builder->pCoords2d));
1478         for (i = 0; i < mesh_builder->nb_coords2d; i++)
1479         {
1480             mesh_builder->pCoords2d[i].u = 0.0f;
1481             mesh_builder->pCoords2d[i].v = 0.0f;
1482         }
1483     }
1484
1485     TRACE("Mesh data loaded successfully\n");
1486
1487     ret = D3DRM_OK;
1488
1489 end:
1490
1491     HeapFree(GetProcessHeap(), 0, faces_normal_idx_data);
1492     HeapFree(GetProcessHeap(), 0, faces_vertex_idx_data);
1493
1494     return ret;
1495 }
1496
1497 static HRESULT WINAPI d3drm_mesh_builder3_Load(IDirect3DRMMeshBuilder3 *iface, void *filename,
1498         void *name, D3DRMLOADOPTIONS loadflags, D3DRMLOADTEXTURE3CALLBACK cb, void *arg)
1499 {
1500     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
1501     DXFILELOADOPTIONS load_options;
1502     IDirectXFile *dxfile = NULL;
1503     IDirectXFileEnumObject *enum_object = NULL;
1504     IDirectXFileData *data = NULL;
1505     const GUID* guid;
1506     DWORD size;
1507     struct d3drm_file_header *header;
1508     HRESULT hr;
1509     HRESULT ret = D3DRMERR_BADOBJECT;
1510
1511     TRACE("iface %p, filename %p, name %p, loadflags %#x, cb %p, arg %p.\n",
1512             iface, filename, name, loadflags, cb, arg);
1513
1514     clean_mesh_builder_data(mesh_builder);
1515
1516     if (loadflags == D3DRMLOAD_FROMMEMORY)
1517     {
1518         load_options = DXFILELOAD_FROMMEMORY;
1519     }
1520     else if (loadflags == D3DRMLOAD_FROMFILE)
1521     {
1522         load_options = DXFILELOAD_FROMFILE;
1523         TRACE("Loading from file %s\n", debugstr_a(filename));
1524     }
1525     else
1526     {
1527         FIXME("Load options %d not supported yet\n", loadflags);
1528         return E_NOTIMPL;
1529     }
1530
1531     hr = DirectXFileCreate(&dxfile);
1532     if (hr != DXFILE_OK)
1533         goto end;
1534
1535     hr = IDirectXFile_RegisterTemplates(dxfile, templates, strlen(templates));
1536     if (hr != DXFILE_OK)
1537         goto end;
1538
1539     hr = IDirectXFile_CreateEnumObject(dxfile, filename, load_options, &enum_object);
1540     if (hr != DXFILE_OK)
1541         goto end;
1542
1543     hr = IDirectXFileEnumObject_GetNextDataObject(enum_object, &data);
1544     if (hr != DXFILE_OK)
1545         goto end;
1546
1547     hr = IDirectXFileData_GetType(data, &guid);
1548     if (hr != DXFILE_OK)
1549         goto end;
1550
1551     TRACE("Found object type whose GUID = %s\n", debugstr_guid(guid));
1552
1553     if (!IsEqualGUID(guid, &TID_DXFILEHeader))
1554     {
1555         ret = D3DRMERR_BADFILE;
1556         goto end;
1557     }
1558
1559     hr = IDirectXFileData_GetData(data, NULL, &size, (void**)&header);
1560     if ((hr != DXFILE_OK) || (size != sizeof(*header)))
1561         goto end;
1562
1563     TRACE("Version is %u.%u, flags %#x.\n", header->major, header->minor, header->flags);
1564
1565     /* Version must be 1.0.x */
1566     if ((header->major != 1) || (header->minor != 0))
1567     {
1568         ret = D3DRMERR_BADFILE;
1569         goto end;
1570     }
1571
1572     IDirectXFileData_Release(data);
1573     data = NULL;
1574
1575     hr = IDirectXFileEnumObject_GetNextDataObject(enum_object, &data);
1576     if (hr != DXFILE_OK)
1577     {
1578         ret = D3DRMERR_NOTFOUND;
1579         goto end;
1580     }
1581
1582     hr = IDirectXFileData_GetType(data, &guid);
1583     if (hr != DXFILE_OK)
1584         goto end;
1585
1586     TRACE("Found object type whose GUID = %s\n", debugstr_guid(guid));
1587
1588     if (!IsEqualGUID(guid, &TID_D3DRMMesh))
1589     {
1590         ret = D3DRMERR_NOTFOUND;
1591         goto end;
1592     }
1593
1594     /* We don't care about the texture interface version since we rely on QueryInterface */
1595     hr = load_mesh_data(iface, data, (D3DRMLOADTEXTURECALLBACK)cb, arg);
1596     if (hr == S_OK)
1597         ret = D3DRM_OK;
1598
1599 end:
1600
1601     if (data)
1602         IDirectXFileData_Release(data);
1603     if (enum_object)
1604         IDirectXFileEnumObject_Release(enum_object);
1605     if (dxfile)
1606         IDirectXFile_Release(dxfile);
1607
1608     if (ret != D3DRM_OK)
1609         clean_mesh_builder_data(mesh_builder);
1610
1611     return ret;
1612 }
1613
1614 static HRESULT WINAPI d3drm_mesh_builder3_Save(IDirect3DRMMeshBuilder3 *iface,
1615         const char *filename, D3DRMXOFFORMAT format, D3DRMSAVEOPTIONS flags)
1616 {
1617     FIXME("iface %p, filename %s, format %#x, flags %#x stub!\n",
1618             iface, debugstr_a(filename), format, flags);
1619
1620     return E_NOTIMPL;
1621 }
1622
1623 static HRESULT WINAPI d3drm_mesh_builder3_Scale(IDirect3DRMMeshBuilder3 *iface,
1624         D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
1625 {
1626     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
1627     DWORD i;
1628
1629     TRACE("iface %p, sx %.8e, sy %.8e, sz %.8e.\n", iface, sx, sy, sz);
1630
1631     for (i = 0; i < mesh_builder->nb_vertices; ++i)
1632     {
1633         mesh_builder->vertices[i].u1.x *= sx;
1634         mesh_builder->vertices[i].u2.y *= sy;
1635         mesh_builder->vertices[i].u3.z *= sz;
1636     }
1637
1638     /* Normals are not affected by Scale */
1639
1640     return D3DRM_OK;
1641 }
1642
1643 static HRESULT WINAPI d3drm_mesh_builder3_Translate(IDirect3DRMMeshBuilder3 *iface,
1644         D3DVALUE tx, D3DVALUE ty, D3DVALUE tz)
1645 {
1646     FIXME("iface %p, tx %.8e, ty %.8e, tz %.8e stub!\n", iface, tx, ty, tz);
1647
1648     return E_NOTIMPL;
1649 }
1650
1651 static HRESULT WINAPI d3drm_mesh_builder3_SetColorSource(IDirect3DRMMeshBuilder3 *iface,
1652         D3DRMCOLORSOURCE source)
1653 {
1654     FIXME("iface %p, source %#x stub!\n", iface, source);
1655
1656     return E_NOTIMPL;
1657 }
1658
1659 static HRESULT WINAPI d3drm_mesh_builder3_GetBox(IDirect3DRMMeshBuilder3 *iface, D3DRMBOX *box)
1660 {
1661     FIXME("iface %p, box %p stub!\n", iface, box);
1662
1663     return E_NOTIMPL;
1664 }
1665
1666 static HRESULT WINAPI d3drm_mesh_builder3_GenerateNormals(IDirect3DRMMeshBuilder3 *iface,
1667         D3DVALUE crease, DWORD flags)
1668 {
1669     FIXME("iface %p, crease %.8e, flags %#x stub!\n", iface, crease, flags);
1670
1671     return E_NOTIMPL;
1672 }
1673
1674 static D3DRMCOLORSOURCE WINAPI d3drm_mesh_builder3_GetColorSource(IDirect3DRMMeshBuilder3 *iface)
1675 {
1676     FIXME("iface %p stub!\n", iface);
1677
1678     return E_NOTIMPL;
1679 }
1680
1681 static HRESULT WINAPI d3drm_mesh_builder3_AddMesh(IDirect3DRMMeshBuilder3 *iface, IDirect3DRMMesh *mesh)
1682 {
1683     FIXME("iface %p, mesh %p stub!\n", iface, mesh);
1684
1685     return E_NOTIMPL;
1686 }
1687
1688 static HRESULT WINAPI d3drm_mesh_builder3_AddMeshBuilder(IDirect3DRMMeshBuilder3 *iface,
1689         IDirect3DRMMeshBuilder3 *mesh_builder, DWORD flags)
1690 {
1691     FIXME("iface %p, mesh_builder %p, flags %#x stub!\n", iface, mesh_builder, flags);
1692
1693     return E_NOTIMPL;
1694 }
1695
1696 static HRESULT WINAPI d3drm_mesh_builder3_AddFrame(IDirect3DRMMeshBuilder3 *iface, IDirect3DRMFrame3 *frame)
1697 {
1698     FIXME("iface %p, frame %p stub!\n", iface, frame);
1699
1700     return E_NOTIMPL;
1701 }
1702
1703 static HRESULT WINAPI d3drm_mesh_builder3_AddFace(IDirect3DRMMeshBuilder3 *iface, IDirect3DRMFace2 *face)
1704 {
1705     FIXME("iface %p, face %p stub!\n", iface, face);
1706
1707     return E_NOTIMPL;
1708 }
1709
1710 static HRESULT WINAPI d3drm_mesh_builder3_AddFaces(IDirect3DRMMeshBuilder3 *iface,
1711         DWORD vertex_count, D3DVECTOR *vertices, DWORD normal_count, D3DVECTOR *normals,
1712         DWORD *face_data, IDirect3DRMFaceArray **array)
1713 {
1714     FIXME("iface %p, vertex_count %u, vertices %p, normal_count %u, normals %p, face_data %p array %p stub!\n",
1715             iface, vertex_count, vertices, normal_count, normals, face_data, array);
1716
1717     return E_NOTIMPL;
1718 }
1719
1720 static HRESULT WINAPI d3drm_mesh_builder3_ReserveSpace(IDirect3DRMMeshBuilder3 *iface,
1721         DWORD vertex_count, DWORD normal_count, DWORD face_count)
1722 {
1723     FIXME("iface %p, vertex_count %u, normal_count %u, face_count %u stub!\n",
1724             iface, vertex_count, normal_count, face_count);
1725
1726     return E_NOTIMPL;
1727 }
1728
1729 static HRESULT WINAPI d3drm_mesh_builder3_SetColorRGB(IDirect3DRMMeshBuilder3 *iface,
1730         D3DVALUE red, D3DVALUE green, D3DVALUE blue)
1731 {
1732     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
1733
1734     TRACE("iface %p, red %.8e, green %.8e, blue %.8e.\n", iface, red, green, blue);
1735
1736     d3drm_set_color(&mesh_builder->color, red, green, blue, 1.0f);
1737
1738     return D3DRM_OK;
1739 }
1740
1741 static HRESULT WINAPI d3drm_mesh_builder3_SetColor(IDirect3DRMMeshBuilder3 *iface, D3DCOLOR color)
1742 {
1743     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
1744
1745     TRACE("iface %p, color 0x%08x.\n", iface, color);
1746
1747     mesh_builder->color = color;
1748
1749     return D3DRM_OK;
1750 }
1751
1752 static HRESULT WINAPI d3drm_mesh_builder3_SetTexture(IDirect3DRMMeshBuilder3 *iface,
1753         IDirect3DRMTexture3 *texture)
1754 {
1755     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
1756
1757     TRACE("iface %p, texture %p.\n", iface, texture);
1758
1759     if (texture)
1760         IDirect3DRMTexture3_AddRef(texture);
1761     if (mesh_builder->texture)
1762         IDirect3DRMTexture3_Release(mesh_builder->texture);
1763     mesh_builder->texture = texture;
1764
1765     return D3DRM_OK;
1766 }
1767
1768 static HRESULT WINAPI d3drm_mesh_builder3_SetMaterial(IDirect3DRMMeshBuilder3 *iface,
1769         IDirect3DRMMaterial2 *material)
1770 {
1771     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
1772
1773     TRACE("iface %p, material %p.\n", iface, material);
1774
1775     if (material)
1776         IDirect3DRMTexture2_AddRef(material);
1777     if (mesh_builder->material)
1778         IDirect3DRMTexture2_Release(mesh_builder->material);
1779     mesh_builder->material = material;
1780
1781     return D3DRM_OK;
1782 }
1783
1784 static HRESULT WINAPI d3drm_mesh_builder3_SetTextureTopology(IDirect3DRMMeshBuilder3 *iface,
1785         BOOL wrap_u, BOOL wrap_v)
1786 {
1787     FIXME("iface %p, wrap_u %#x, wrap_v %#x stub!\n", iface, wrap_u, wrap_v);
1788
1789     return E_NOTIMPL;
1790 }
1791
1792 static HRESULT WINAPI d3drm_mesh_builder3_SetQuality(IDirect3DRMMeshBuilder3 *iface,
1793         D3DRMRENDERQUALITY quality)
1794 {
1795     FIXME("iface %p, quality %#x stub!\n", iface, quality);
1796
1797     return E_NOTIMPL;
1798 }
1799
1800 static HRESULT WINAPI d3drm_mesh_builder3_SetPerspective(IDirect3DRMMeshBuilder3 *iface,
1801         BOOL enable)
1802 {
1803     FIXME("iface %p, enable %#x stub!\n", iface, enable);
1804
1805     return E_NOTIMPL;
1806 }
1807
1808 static HRESULT WINAPI d3drm_mesh_builder3_SetVertex(IDirect3DRMMeshBuilder3 *iface,
1809         DWORD index, D3DVALUE x, D3DVALUE y, D3DVALUE z)
1810 {
1811     FIXME("iface %p, index %u, x %.8e, y %.8e, z %.8e stub!\n", iface, index, x, y, z);
1812
1813     return E_NOTIMPL;
1814 }
1815
1816 static HRESULT WINAPI d3drm_mesh_builder3_SetNormal(IDirect3DRMMeshBuilder3 *iface,
1817         DWORD index, D3DVALUE x, D3DVALUE y, D3DVALUE z)
1818 {
1819     FIXME("iface %p, index %u, x %.8e, y %.8e, z %.8e stub!\n", iface, index, x, y, z);
1820
1821     return E_NOTIMPL;
1822 }
1823
1824 static HRESULT WINAPI d3drm_mesh_builder3_SetTextureCoordinates(IDirect3DRMMeshBuilder3 *iface,
1825         DWORD index, D3DVALUE u, D3DVALUE v)
1826 {
1827     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
1828
1829     TRACE("iface %p, index %u, u %.8e, v %.8e.\n", iface, index, u, v);
1830
1831     if (index >= mesh_builder->nb_coords2d)
1832         return D3DRMERR_BADVALUE;
1833
1834     mesh_builder->pCoords2d[index].u = u;
1835     mesh_builder->pCoords2d[index].v = v;
1836
1837     return D3DRM_OK;
1838 }
1839
1840 static HRESULT WINAPI d3drm_mesh_builder3_SetVertexColor(IDirect3DRMMeshBuilder3 *iface,
1841         DWORD index, D3DCOLOR color)
1842 {
1843     FIXME("iface %p, index %u, color 0x%08x stub!\n", iface, index, color);
1844
1845     return E_NOTIMPL;
1846 }
1847
1848 static HRESULT WINAPI d3drm_mesh_builder3_SetVertexColorRGB(IDirect3DRMMeshBuilder3 *iface,
1849         DWORD index, D3DVALUE red, D3DVALUE green, D3DVALUE blue)
1850 {
1851     FIXME("iface %p, index %u, red %.8e, green %.8e, blue %.8e stub!\n",
1852             iface, index, red, green, blue);
1853
1854     return E_NOTIMPL;
1855 }
1856
1857 static HRESULT WINAPI d3drm_mesh_builder3_GetFaces(IDirect3DRMMeshBuilder3 *iface,
1858         IDirect3DRMFaceArray **array)
1859 {
1860     FIXME("iface %p, array %p stub!\n", iface, array);
1861
1862     return E_NOTIMPL;
1863 }
1864
1865 static HRESULT WINAPI d3drm_mesh_builder3_GetGeometry(IDirect3DRMMeshBuilder3 *iface,
1866         DWORD *vertex_count, D3DVECTOR *vertices, DWORD *normal_count, D3DVECTOR *normals,
1867         DWORD *face_data_size, DWORD *face_data)
1868 {
1869     FIXME("iface %p, vertex_count %p, vertices %p, normal_count %p, normals %p, "
1870             "face_data_size %p, face_data %p stub!\n",
1871             iface, vertex_count, vertices, normal_count, normals, face_data_size, face_data);
1872
1873     return E_NOTIMPL;
1874 }
1875
1876 static HRESULT WINAPI d3drm_mesh_builder3_GetTextureCoordinates(IDirect3DRMMeshBuilder3 *iface,
1877         DWORD index, D3DVALUE *u, D3DVALUE *v)
1878 {
1879     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
1880
1881     TRACE("iface %p, index %u, u %p, v %p.\n", iface, index, u, v);
1882
1883     if (index >= mesh_builder->nb_coords2d)
1884         return D3DRMERR_BADVALUE;
1885
1886     *u = mesh_builder->pCoords2d[index].u;
1887     *v = mesh_builder->pCoords2d[index].v;
1888
1889     return D3DRM_OK;
1890 }
1891
1892 static int WINAPI d3drm_mesh_builder3_AddVertex(IDirect3DRMMeshBuilder3 *iface,
1893         D3DVALUE x, D3DVALUE y, D3DVALUE z)
1894 {
1895     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
1896
1897     TRACE("iface %p, x %.8e, y %.8e, z %.8e.\n", iface, x, y, z);
1898
1899     if (!d3drm_array_reserve((void **)&mesh_builder->vertices, &mesh_builder->vertices_size,
1900             mesh_builder->nb_vertices + 1, sizeof(*mesh_builder->vertices)))
1901         return 0;
1902
1903     mesh_builder->vertices[mesh_builder->nb_vertices].u1.x = x;
1904     mesh_builder->vertices[mesh_builder->nb_vertices].u2.y = y;
1905     mesh_builder->vertices[mesh_builder->nb_vertices].u3.z = z;
1906
1907     return mesh_builder->nb_vertices++;
1908 }
1909
1910 static int WINAPI d3drm_mesh_builder3_AddNormal(IDirect3DRMMeshBuilder3 *iface,
1911         D3DVALUE x, D3DVALUE y, D3DVALUE z)
1912 {
1913     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
1914
1915     TRACE("iface %p, x %.8e, y %.8e, z %.8e.\n", iface, x, y, z);
1916
1917     if (!d3drm_array_reserve((void **)&mesh_builder->normals, &mesh_builder->normals_size,
1918             mesh_builder->nb_normals + 1, sizeof(*mesh_builder->normals)))
1919         return 0;
1920
1921     mesh_builder->normals[mesh_builder->nb_normals].u1.x = x;
1922     mesh_builder->normals[mesh_builder->nb_normals].u2.y = y;
1923     mesh_builder->normals[mesh_builder->nb_normals].u3.z = z;
1924
1925     return mesh_builder->nb_normals++;
1926 }
1927
1928 static HRESULT WINAPI d3drm_mesh_builder3_CreateFace(IDirect3DRMMeshBuilder3 *iface, IDirect3DRMFace2 **face)
1929 {
1930     struct d3drm_face *object;
1931     HRESULT hr;
1932
1933     TRACE("iface %p, face %p.\n", iface, face);
1934
1935     if (FAILED(hr = d3drm_face_create(&object)))
1936         return hr;
1937
1938     *face = &object->IDirect3DRMFace2_iface;
1939
1940     return S_OK;
1941 }
1942
1943 static D3DRMRENDERQUALITY WINAPI d3drm_mesh_builder3_GetQuality(IDirect3DRMMeshBuilder3 *iface)
1944 {
1945     FIXME("iface %p stub!\n", iface);
1946
1947     return 0;
1948 }
1949
1950 static BOOL WINAPI d3drm_mesh_builder3_GetPerspective(IDirect3DRMMeshBuilder3 *iface)
1951 {
1952     FIXME("iface %p stub!\n", iface);
1953
1954     return FALSE;
1955 }
1956
1957 static int WINAPI d3drm_mesh_builder3_GetFaceCount(IDirect3DRMMeshBuilder3 *iface)
1958 {
1959     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
1960
1961     TRACE("iface %p.\n", iface);
1962
1963     return mesh_builder->nb_faces;
1964 }
1965
1966 static int WINAPI d3drm_mesh_builder3_GetVertexCount(IDirect3DRMMeshBuilder3 *iface)
1967 {
1968     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
1969
1970     TRACE("iface %p.\n", iface);
1971
1972     return mesh_builder->nb_vertices;
1973 }
1974
1975 static D3DCOLOR WINAPI d3drm_mesh_builder3_GetVertexColor(IDirect3DRMMeshBuilder3 *iface,
1976         DWORD index)
1977 {
1978     FIXME("iface %p, index %u stub!\n", iface, index);
1979
1980     return 0;
1981 }
1982
1983 static HRESULT WINAPI d3drm_mesh_builder3_CreateMesh(IDirect3DRMMeshBuilder3 *iface, IDirect3DRMMesh **mesh)
1984 {
1985     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
1986     HRESULT hr;
1987     D3DRMGROUPINDEX group;
1988
1989     TRACE("iface %p, mesh %p.\n", iface, mesh);
1990
1991     if (!mesh)
1992         return E_POINTER;
1993
1994     hr = Direct3DRMMesh_create(mesh);
1995     if (FAILED(hr))
1996         return hr;
1997
1998     /* If there is mesh data, create a group and put data inside */
1999     if (mesh_builder->nb_vertices)
2000     {
2001         DWORD i, j;
2002         int k;
2003         D3DRMVERTEX* vertices;
2004
2005         vertices = HeapAlloc(GetProcessHeap(), 0, mesh_builder->nb_vertices * sizeof(D3DRMVERTEX));
2006         if (!vertices)
2007         {
2008             IDirect3DRMMesh_Release(*mesh);
2009             return E_OUTOFMEMORY;
2010         }
2011         for (i = 0; i < mesh_builder->nb_vertices; i++)
2012             vertices[i].position = mesh_builder->vertices[i];
2013         hr = IDirect3DRMMesh_SetVertices(*mesh, 0, 0, mesh_builder->nb_vertices, vertices);
2014         HeapFree(GetProcessHeap(), 0, vertices);
2015
2016         /* Groups are in reverse order compared to materials list in X file */
2017         for (k = mesh_builder->nb_materials - 1; k >= 0; k--)
2018         {
2019             unsigned* face_data;
2020             unsigned* out_ptr;
2021             DWORD* in_ptr = mesh_builder->pFaceData;
2022             ULONG vertex_per_face = 0;
2023             BOOL* used_vertices;
2024             unsigned nb_vertices = 0;
2025             unsigned nb_faces = 0;
2026
2027             used_vertices = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mesh_builder->face_data_size * sizeof(*used_vertices));
2028             if (!used_vertices)
2029             {
2030                 IDirect3DRMMesh_Release(*mesh);
2031                 return E_OUTOFMEMORY;
2032             }
2033
2034             face_data = HeapAlloc(GetProcessHeap(), 0, mesh_builder->face_data_size * sizeof(*face_data));
2035             if (!face_data)
2036             {
2037                 HeapFree(GetProcessHeap(), 0, used_vertices);
2038                 IDirect3DRMMesh_Release(*mesh);
2039                 return E_OUTOFMEMORY;
2040             }
2041             out_ptr = face_data;
2042
2043             /* If all faces have the same number of vertex, set vertex_per_face */
2044             for (i = 0; i < mesh_builder->nb_faces; i++)
2045             {
2046                 /* Process only faces belonging to the group */
2047                 if (mesh_builder->material_indices[i] == k)
2048                 {
2049                     if (vertex_per_face && (vertex_per_face != *in_ptr))
2050                         break;
2051                     vertex_per_face = *in_ptr;
2052                 }
2053                 in_ptr += 1 + *in_ptr * 2;
2054             }
2055             if (i != mesh_builder->nb_faces)
2056                 vertex_per_face = 0;
2057
2058             /* Put only vertex indices */
2059             in_ptr = mesh_builder->pFaceData;
2060             for (i = 0; i < mesh_builder->nb_faces; i++)
2061             {
2062                 DWORD nb_indices = *in_ptr++;
2063
2064                 /* Skip faces not belonging to the group */
2065                 if (mesh_builder->material_indices[i] != k)
2066                 {
2067                     in_ptr += 2 * nb_indices;
2068                     continue;
2069                 }
2070
2071                 /* Don't put nb indices when vertex_per_face is set */
2072                 if (vertex_per_face)
2073                     *out_ptr++ = nb_indices;
2074
2075                 for (j = 0; j < nb_indices; j++)
2076                 {
2077                     *out_ptr = *in_ptr++;
2078                     used_vertices[*out_ptr++] = TRUE;
2079                     /* Skip normal index */
2080                     in_ptr++;
2081                 }
2082
2083                 nb_faces++;
2084             }
2085
2086             for (i = 0; i < mesh_builder->nb_vertices; i++)
2087                 if (used_vertices[i])
2088                     nb_vertices++;
2089
2090             hr = IDirect3DRMMesh_AddGroup(*mesh, nb_vertices, nb_faces, vertex_per_face, face_data, &group);
2091             HeapFree(GetProcessHeap(), 0, used_vertices);
2092             HeapFree(GetProcessHeap(), 0, face_data);
2093             if (SUCCEEDED(hr))
2094                 hr = IDirect3DRMMesh_SetGroupColor(*mesh, group, mesh_builder->materials[k].color);
2095             if (SUCCEEDED(hr))
2096                 hr = IDirect3DRMMesh_SetGroupMaterial(*mesh, group,
2097                         (IDirect3DRMMaterial *)mesh_builder->materials[k].material);
2098             if (SUCCEEDED(hr) && mesh_builder->materials[k].texture)
2099             {
2100                 IDirect3DRMTexture *texture;
2101
2102                 IDirect3DRMTexture3_QueryInterface(mesh_builder->materials[k].texture,
2103                         &IID_IDirect3DRMTexture, (void **)&texture);
2104                 hr = IDirect3DRMMesh_SetGroupTexture(*mesh, group, texture);
2105                 IDirect3DRMTexture_Release(texture);
2106             }
2107             if (FAILED(hr))
2108             {
2109                 IDirect3DRMMesh_Release(*mesh);
2110                 return hr;
2111             }
2112         }
2113     }
2114
2115     return D3DRM_OK;
2116 }
2117
2118 static HRESULT WINAPI d3drm_mesh_builder3_GetFace(IDirect3DRMMeshBuilder3 *iface,
2119         DWORD index, IDirect3DRMFace2 **face)
2120 {
2121     FIXME("iface %p, index %u, face %p stub!\n", iface, index, face);
2122
2123     return E_NOTIMPL;
2124 }
2125
2126 static HRESULT WINAPI d3drm_mesh_builder3_GetVertex(IDirect3DRMMeshBuilder3 *iface,
2127         DWORD index, D3DVECTOR *vector)
2128 {
2129     FIXME("iface %p, index %u, vector %p stub!\n", iface, index, vector);
2130
2131     return E_NOTIMPL;
2132 }
2133
2134 static HRESULT WINAPI d3drm_mesh_builder3_GetNormal(IDirect3DRMMeshBuilder3 *iface,
2135         DWORD index, D3DVECTOR *vector)
2136 {
2137     FIXME("iface %p, index %u, vector %p stub!\n", iface, index, vector);
2138
2139     return E_NOTIMPL;
2140 }
2141
2142 static HRESULT WINAPI d3drm_mesh_builder3_DeleteVertices(IDirect3DRMMeshBuilder3 *iface,
2143         DWORD start_idx, DWORD count)
2144 {
2145     FIXME("iface %p, start_idx %u, count %u stub!\n", iface, start_idx, count);
2146
2147     return E_NOTIMPL;
2148 }
2149
2150 static HRESULT WINAPI d3drm_mesh_builder3_DeleteNormals(IDirect3DRMMeshBuilder3 *iface,
2151         DWORD start_idx, DWORD count)
2152 {
2153     FIXME("iface %p, start_idx %u, count %u stub!\n", iface, start_idx, count);
2154
2155     return E_NOTIMPL;
2156 }
2157
2158 static HRESULT WINAPI d3drm_mesh_builder3_DeleteFace(IDirect3DRMMeshBuilder3 *iface, IDirect3DRMFace2 *face)
2159 {
2160     FIXME("iface %p, face %p stub!\n", iface, face);
2161
2162     return E_NOTIMPL;
2163 }
2164
2165 static HRESULT WINAPI d3drm_mesh_builder3_Empty(IDirect3DRMMeshBuilder3 *iface, DWORD flags)
2166 {
2167     FIXME("iface %p, flags %#x stub!\n", iface, flags);
2168
2169     return E_NOTIMPL;
2170 }
2171
2172 static HRESULT WINAPI d3drm_mesh_builder3_Optimize(IDirect3DRMMeshBuilder3 *iface, DWORD flags)
2173 {
2174     FIXME("iface %p, flags %#x stub!\n", iface, flags);
2175
2176     return E_NOTIMPL;
2177 }
2178
2179 static HRESULT WINAPI d3drm_mesh_builder3_AddFacesIndexed(IDirect3DRMMeshBuilder3 *iface,
2180         DWORD flags, DWORD *indices, DWORD *start_idx, DWORD *count)
2181 {
2182     FIXME("iface %p, flags %#x, indices %p, start_idx %p, count %p stub!\n",
2183             iface, flags, indices, start_idx, count);
2184
2185     return E_NOTIMPL;
2186 }
2187
2188 static HRESULT WINAPI d3drm_mesh_builder3_CreateSubMesh(IDirect3DRMMeshBuilder3 *iface, IUnknown **mesh)
2189 {
2190     FIXME("iface %p, mesh %p stub!\n", iface, mesh);
2191
2192     return E_NOTIMPL;
2193 }
2194
2195 static HRESULT WINAPI d3drm_mesh_builder3_GetParentMesh(IDirect3DRMMeshBuilder3 *iface,
2196         DWORD flags, IUnknown **parent)
2197 {
2198     FIXME("iface %p, flags %#x, parent %p stub!\n", iface, flags, parent);
2199
2200     return E_NOTIMPL;
2201 }
2202
2203 static HRESULT WINAPI d3drm_mesh_builder3_GetSubMeshes(IDirect3DRMMeshBuilder3 *iface,
2204         DWORD *count, IUnknown **meshes)
2205 {
2206     FIXME("iface %p, count %p, meshes %p stub!\n", iface, count, meshes);
2207
2208     return E_NOTIMPL;
2209 }
2210
2211 static HRESULT WINAPI d3drm_mesh_builder3_DeleteSubMesh(IDirect3DRMMeshBuilder3 *iface, IUnknown *mesh)
2212 {
2213     FIXME("iface %p, mesh %p stub!\n", iface, mesh);
2214
2215     return E_NOTIMPL;
2216 }
2217
2218 static HRESULT WINAPI d3drm_mesh_builder3_Enable(IDirect3DRMMeshBuilder3 *iface, DWORD index)
2219 {
2220     FIXME("iface %p, index %u stub!\n", iface, index);
2221
2222     return E_NOTIMPL;
2223 }
2224
2225 static HRESULT WINAPI d3drm_mesh_builder3_GetEnable(IDirect3DRMMeshBuilder3 *iface, DWORD *indices)
2226 {
2227     FIXME("iface %p, indices %p stub!\n", iface, indices);
2228
2229     return E_NOTIMPL;
2230 }
2231
2232 static HRESULT WINAPI d3drm_mesh_builder3_AddTriangles(IDirect3DRMMeshBuilder3 *iface,
2233         DWORD flags, DWORD format, DWORD vertex_count, void *data)
2234 {
2235     FIXME("iface %p, flags %#x, format %#x, vertex_count %u, data %p stub!\n",
2236             iface, flags, format, vertex_count, data);
2237
2238     return E_NOTIMPL;
2239 }
2240
2241 static HRESULT WINAPI d3drm_mesh_builder3_SetVertices(IDirect3DRMMeshBuilder3 *iface,
2242         DWORD start_idx, DWORD count, D3DVECTOR *vector)
2243 {
2244     FIXME("iface %p, start_idx %u, count %u, vector %p stub!\n", iface, start_idx, count, vector);
2245
2246     return E_NOTIMPL;
2247 }
2248
2249 static HRESULT WINAPI d3drm_mesh_builder3_GetVertices(IDirect3DRMMeshBuilder3 *iface,
2250         DWORD start_idx, DWORD *vertex_count, D3DVECTOR *vertices)
2251 {
2252     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
2253     DWORD count = mesh_builder->nb_vertices - start_idx;
2254
2255     TRACE("iface %p, start_idx %u, vertex_count %p, vertices %p.\n",
2256             iface, start_idx, vertex_count, vertices);
2257
2258     if (vertex_count)
2259         *vertex_count = count;
2260     if (vertices && mesh_builder->nb_vertices)
2261         memcpy(vertices, mesh_builder->vertices + start_idx, count * sizeof(*vertices));
2262
2263     return D3DRM_OK;
2264 }
2265
2266 static HRESULT WINAPI d3drm_mesh_builder3_SetNormals(IDirect3DRMMeshBuilder3 *iface,
2267         DWORD start_idx, DWORD count, D3DVECTOR *vector)
2268 {
2269     FIXME("iface %p, start_idx %u, count %u, vector %p stub!\n",
2270             iface, start_idx, count, vector);
2271
2272     return E_NOTIMPL;
2273 }
2274
2275 static HRESULT WINAPI d3drm_mesh_builder3_GetNormals(IDirect3DRMMeshBuilder3 *iface,
2276         DWORD start_idx, DWORD *normal_count, D3DVECTOR *normals)
2277 {
2278     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
2279     DWORD count = mesh_builder->nb_normals - start_idx;
2280
2281     TRACE("iface %p, start_idx %u, normal_count %p, normals %p.\n",
2282             iface, start_idx, normal_count, normals);
2283
2284     if (normal_count)
2285         *normal_count = count;
2286     if (normals && mesh_builder->nb_normals)
2287         memcpy(normals, &mesh_builder->normals[start_idx], count * sizeof(*normals));
2288
2289     return D3DRM_OK;
2290 }
2291
2292 static int WINAPI d3drm_mesh_builder3_GetNormalCount(IDirect3DRMMeshBuilder3 *iface)
2293 {
2294     struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
2295
2296     TRACE("iface %p.\n", iface);
2297
2298     return mesh_builder->nb_normals;
2299 }
2300
2301 static const struct IDirect3DRMMeshBuilder3Vtbl d3drm_mesh_builder3_vtbl =
2302 {
2303     d3drm_mesh_builder3_QueryInterface,
2304     d3drm_mesh_builder3_AddRef,
2305     d3drm_mesh_builder3_Release,
2306     d3drm_mesh_builder3_Clone,
2307     d3drm_mesh_builder3_AddDestroyCallback,
2308     d3drm_mesh_builder3_DeleteDestroyCallback,
2309     d3drm_mesh_builder3_SetAppData,
2310     d3drm_mesh_builder3_GetAppData,
2311     d3drm_mesh_builder3_SetName,
2312     d3drm_mesh_builder3_GetName,
2313     d3drm_mesh_builder3_GetClassName,
2314     d3drm_mesh_builder3_Load,
2315     d3drm_mesh_builder3_Save,
2316     d3drm_mesh_builder3_Scale,
2317     d3drm_mesh_builder3_Translate,
2318     d3drm_mesh_builder3_SetColorSource,
2319     d3drm_mesh_builder3_GetBox,
2320     d3drm_mesh_builder3_GenerateNormals,
2321     d3drm_mesh_builder3_GetColorSource,
2322     d3drm_mesh_builder3_AddMesh,
2323     d3drm_mesh_builder3_AddMeshBuilder,
2324     d3drm_mesh_builder3_AddFrame,
2325     d3drm_mesh_builder3_AddFace,
2326     d3drm_mesh_builder3_AddFaces,
2327     d3drm_mesh_builder3_ReserveSpace,
2328     d3drm_mesh_builder3_SetColorRGB,
2329     d3drm_mesh_builder3_SetColor,
2330     d3drm_mesh_builder3_SetTexture,
2331     d3drm_mesh_builder3_SetMaterial,
2332     d3drm_mesh_builder3_SetTextureTopology,
2333     d3drm_mesh_builder3_SetQuality,
2334     d3drm_mesh_builder3_SetPerspective,
2335     d3drm_mesh_builder3_SetVertex,
2336     d3drm_mesh_builder3_SetNormal,
2337     d3drm_mesh_builder3_SetTextureCoordinates,
2338     d3drm_mesh_builder3_SetVertexColor,
2339     d3drm_mesh_builder3_SetVertexColorRGB,
2340     d3drm_mesh_builder3_GetFaces,
2341     d3drm_mesh_builder3_GetGeometry,
2342     d3drm_mesh_builder3_GetTextureCoordinates,
2343     d3drm_mesh_builder3_AddVertex,
2344     d3drm_mesh_builder3_AddNormal,
2345     d3drm_mesh_builder3_CreateFace,
2346     d3drm_mesh_builder3_GetQuality,
2347     d3drm_mesh_builder3_GetPerspective,
2348     d3drm_mesh_builder3_GetFaceCount,
2349     d3drm_mesh_builder3_GetVertexCount,
2350     d3drm_mesh_builder3_GetVertexColor,
2351     d3drm_mesh_builder3_CreateMesh,
2352     d3drm_mesh_builder3_GetFace,
2353     d3drm_mesh_builder3_GetVertex,
2354     d3drm_mesh_builder3_GetNormal,
2355     d3drm_mesh_builder3_DeleteVertices,
2356     d3drm_mesh_builder3_DeleteNormals,
2357     d3drm_mesh_builder3_DeleteFace,
2358     d3drm_mesh_builder3_Empty,
2359     d3drm_mesh_builder3_Optimize,
2360     d3drm_mesh_builder3_AddFacesIndexed,
2361     d3drm_mesh_builder3_CreateSubMesh,
2362     d3drm_mesh_builder3_GetParentMesh,
2363     d3drm_mesh_builder3_GetSubMeshes,
2364     d3drm_mesh_builder3_DeleteSubMesh,
2365     d3drm_mesh_builder3_Enable,
2366     d3drm_mesh_builder3_GetEnable,
2367     d3drm_mesh_builder3_AddTriangles,
2368     d3drm_mesh_builder3_SetVertices,
2369     d3drm_mesh_builder3_GetVertices,
2370     d3drm_mesh_builder3_SetNormals,
2371     d3drm_mesh_builder3_GetNormals,
2372     d3drm_mesh_builder3_GetNormalCount,
2373 };
2374
2375 HRESULT d3drm_mesh_builder_create(struct d3drm_mesh_builder **mesh_builder, IDirect3DRM *d3drm)
2376 {
2377     static const char classname[] = "Builder";
2378     struct d3drm_mesh_builder *object;
2379
2380     TRACE("mesh_builder %p.\n", mesh_builder);
2381
2382     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2383         return E_OUTOFMEMORY;
2384
2385     object->IDirect3DRMMeshBuilder2_iface.lpVtbl = &d3drm_mesh_builder2_vtbl;
2386     object->IDirect3DRMMeshBuilder3_iface.lpVtbl = &d3drm_mesh_builder3_vtbl;
2387     object->ref = 1;
2388     object->d3drm = d3drm;
2389     IDirect3DRM_AddRef(object->d3drm);
2390
2391     d3drm_object_init(&object->obj, classname);
2392
2393     *mesh_builder = object;
2394
2395     return S_OK;
2396 }
2397
2398 static HRESULT WINAPI d3drm_mesh_QueryInterface(IDirect3DRMMesh *iface, REFIID riid, void **out)
2399 {
2400     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
2401
2402     if (IsEqualGUID(riid, &IID_IDirect3DRMMesh)
2403             || IsEqualGUID(riid, &IID_IDirect3DRMVisual)
2404             || IsEqualGUID(riid, &IID_IDirect3DRMObject)
2405             || IsEqualGUID(riid, &IID_IUnknown))
2406     {
2407         IDirect3DRMMesh_AddRef(iface);
2408         *out = iface;
2409         return S_OK;
2410     }
2411
2412     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
2413
2414     *out = NULL;
2415     return E_NOINTERFACE;
2416 }
2417
2418 static ULONG WINAPI d3drm_mesh_AddRef(IDirect3DRMMesh *iface)
2419 {
2420     struct d3drm_mesh *mesh = impl_from_IDirect3DRMMesh(iface);
2421     ULONG refcount = InterlockedIncrement(&mesh->ref);
2422
2423     TRACE("%p increasing refcount to %u.\n", iface, refcount);
2424
2425     return refcount;
2426 }
2427
2428 static ULONG WINAPI d3drm_mesh_Release(IDirect3DRMMesh *iface)
2429 {
2430     struct d3drm_mesh *mesh = impl_from_IDirect3DRMMesh(iface);
2431     ULONG refcount = InterlockedDecrement(&mesh->ref);
2432
2433     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
2434
2435     if (!refcount)
2436     {
2437         DWORD i;
2438
2439         for (i = 0; i < mesh->nb_groups; ++i)
2440         {
2441             HeapFree(GetProcessHeap(), 0, mesh->groups[i].vertices);
2442             HeapFree(GetProcessHeap(), 0, mesh->groups[i].face_data);
2443             if (mesh->groups[i].material)
2444                 IDirect3DRMMaterial2_Release(mesh->groups[i].material);
2445             if (mesh->groups[i].texture)
2446                 IDirect3DRMTexture3_Release(mesh->groups[i].texture);
2447         }
2448         HeapFree(GetProcessHeap(), 0, mesh->groups);
2449         HeapFree(GetProcessHeap(), 0, mesh);
2450     }
2451
2452     return refcount;
2453 }
2454
2455 static HRESULT WINAPI d3drm_mesh_Clone(IDirect3DRMMesh *iface,
2456         IUnknown *outer, REFIID iid, void **out)
2457 {
2458     FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
2459
2460     return E_NOTIMPL;
2461 }
2462
2463 static HRESULT WINAPI d3drm_mesh_AddDestroyCallback(IDirect3DRMMesh *iface,
2464         D3DRMOBJECTCALLBACK cb, void *ctx)
2465 {
2466     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
2467
2468     return E_NOTIMPL;
2469 }
2470
2471 static HRESULT WINAPI d3drm_mesh_DeleteDestroyCallback(IDirect3DRMMesh *iface,
2472         D3DRMOBJECTCALLBACK cb, void *ctx)
2473 {
2474     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
2475
2476     return E_NOTIMPL;
2477 }
2478
2479 static HRESULT WINAPI d3drm_mesh_SetAppData(IDirect3DRMMesh *iface, DWORD data)
2480 {
2481     FIXME("iface %p, data %#x stub!\n", iface, data);
2482
2483     return E_NOTIMPL;
2484 }
2485
2486 static DWORD WINAPI d3drm_mesh_GetAppData(IDirect3DRMMesh *iface)
2487 {
2488     FIXME("iface %p stub!\n", iface);
2489
2490     return 0;
2491 }
2492
2493 static HRESULT WINAPI d3drm_mesh_SetName(IDirect3DRMMesh *iface, const char *name)
2494 {
2495     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
2496
2497     return E_NOTIMPL;
2498 }
2499
2500 static HRESULT WINAPI d3drm_mesh_GetName(IDirect3DRMMesh *iface, DWORD *size, char *name)
2501 {
2502     FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
2503
2504     return E_NOTIMPL;
2505 }
2506
2507 static HRESULT WINAPI d3drm_mesh_GetClassName(IDirect3DRMMesh *iface, DWORD *size, char *name)
2508 {
2509     struct d3drm_mesh *mesh = impl_from_IDirect3DRMMesh(iface);
2510
2511     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
2512
2513     return d3drm_object_get_class_name(&mesh->obj, size, name);
2514 }
2515
2516 static HRESULT WINAPI d3drm_mesh_Scale(IDirect3DRMMesh *iface,
2517         D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
2518 {
2519     FIXME("iface %p, sx %.8e, sy %.8e, sz %.8e stub!\n", iface, sx, sy, sz);
2520
2521     return E_NOTIMPL;
2522 }
2523
2524 static HRESULT WINAPI d3drm_mesh_Translate(IDirect3DRMMesh *iface,
2525         D3DVALUE tx, D3DVALUE ty, D3DVALUE tz)
2526 {
2527     FIXME("iface %p, tx %.8e, ty %.8e, tz %.8e stub!\n", iface, tx, ty, tz);
2528
2529     return E_NOTIMPL;
2530 }
2531
2532 static HRESULT WINAPI d3drm_mesh_GetBox(IDirect3DRMMesh *iface, D3DRMBOX *box)
2533 {
2534     FIXME("iface %p, box %p stub!\n", iface, box);
2535
2536     return E_NOTIMPL;
2537 }
2538
2539 static HRESULT WINAPI d3drm_mesh_AddGroup(IDirect3DRMMesh *iface, unsigned vertex_count,
2540         unsigned face_count, unsigned vertex_per_face, unsigned *face_data, D3DRMGROUPINDEX *id)
2541 {
2542     struct d3drm_mesh *mesh = impl_from_IDirect3DRMMesh(iface);
2543     struct mesh_group *group;
2544
2545     TRACE("iface %p, vertex_count %u, face_count %u, vertex_per_face %u, face_data %p, id %p.\n",
2546             iface, vertex_count, face_count, vertex_per_face, face_data, id);
2547
2548     if (!face_data || !id)
2549         return E_POINTER;
2550
2551     if ((mesh->nb_groups + 1) > mesh->groups_capacity)
2552     {
2553         struct mesh_group *groups;
2554         ULONG new_capacity;
2555
2556         if (!mesh->groups_capacity)
2557         {
2558             new_capacity = 16;
2559             groups = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(*groups));
2560         }
2561         else
2562         {
2563             new_capacity = mesh->groups_capacity * 2;
2564             groups = HeapReAlloc(GetProcessHeap(), 0, mesh->groups, new_capacity * sizeof(*groups));
2565         }
2566
2567         if (!groups)
2568             return E_OUTOFMEMORY;
2569
2570         mesh->groups_capacity = new_capacity;
2571         mesh->groups = groups;
2572     }
2573
2574     group = mesh->groups + mesh->nb_groups;
2575
2576     group->vertices = HeapAlloc(GetProcessHeap(), 0, vertex_count * sizeof(D3DRMVERTEX));
2577     if (!group->vertices)
2578         return E_OUTOFMEMORY;
2579     group->nb_vertices = vertex_count;
2580     group->nb_faces = face_count;
2581     group->vertex_per_face = vertex_per_face;
2582
2583     if (vertex_per_face)
2584     {
2585         group->face_data_size = face_count * vertex_per_face;
2586     }
2587     else
2588     {
2589         unsigned i;
2590         unsigned nb_indices;
2591         unsigned* face_data_ptr = face_data;
2592         group->face_data_size = 0;
2593
2594         for (i = 0; i < face_count; i++)
2595         {
2596             nb_indices = *face_data_ptr;
2597             group->face_data_size += nb_indices + 1;
2598             face_data_ptr += nb_indices;
2599         }
2600     }
2601
2602     group->face_data = HeapAlloc(GetProcessHeap(), 0, group->face_data_size * sizeof(unsigned));
2603     if (!group->face_data)
2604     {
2605         HeapFree(GetProcessHeap(), 0 , group->vertices);
2606         return E_OUTOFMEMORY;
2607     }
2608
2609     memcpy(group->face_data, face_data, group->face_data_size * sizeof(unsigned));
2610
2611     group->material = NULL;
2612     group->texture = NULL;
2613
2614     *id = mesh->nb_groups++;
2615
2616     return D3DRM_OK;
2617 }
2618
2619 static HRESULT WINAPI d3drm_mesh_SetVertices(IDirect3DRMMesh *iface, D3DRMGROUPINDEX group_id,
2620         unsigned int start_idx, unsigned int count, D3DRMVERTEX *values)
2621 {
2622     struct d3drm_mesh *mesh = impl_from_IDirect3DRMMesh(iface);
2623
2624     TRACE("iface %p, group_id %#x, start_idx %u, count %u, values %p.\n",
2625             iface, group_id, start_idx, count, values);
2626
2627     if (group_id >= mesh->nb_groups)
2628         return D3DRMERR_BADVALUE;
2629
2630     if ((start_idx + count - 1) >= mesh->groups[group_id].nb_vertices)
2631         return D3DRMERR_BADVALUE;
2632
2633     if (!values)
2634         return E_POINTER;
2635
2636     memcpy(mesh->groups[group_id].vertices + start_idx, values, count * sizeof(*values));
2637
2638     return D3DRM_OK;
2639 }
2640
2641 static HRESULT WINAPI d3drm_mesh_SetGroupColor(IDirect3DRMMesh *iface, D3DRMGROUPINDEX id, D3DCOLOR color)
2642 {
2643     struct d3drm_mesh *mesh = impl_from_IDirect3DRMMesh(iface);
2644
2645     TRACE("iface %p, id %#x, color 0x%08x.\n", iface, id, color);
2646
2647     if (id >= mesh->nb_groups)
2648         return D3DRMERR_BADVALUE;
2649
2650     mesh->groups[id].color = color;
2651
2652     return D3DRM_OK;
2653 }
2654
2655 static HRESULT WINAPI d3drm_mesh_SetGroupColorRGB(IDirect3DRMMesh *iface,
2656         D3DRMGROUPINDEX id, D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2657 {
2658     struct d3drm_mesh *mesh = impl_from_IDirect3DRMMesh(iface);
2659
2660     TRACE("iface %p, id %#x, red %.8e, green %.8e, blue %.8e.\n", iface, id, red, green, blue);
2661
2662     if (id >= mesh->nb_groups)
2663         return D3DRMERR_BADVALUE;
2664
2665     d3drm_set_color(&mesh->groups[id].color, red, green, blue, 1.0f);
2666
2667     return D3DRM_OK;
2668 }
2669
2670 static HRESULT WINAPI d3drm_mesh_SetGroupMapping(IDirect3DRMMesh *iface, D3DRMGROUPINDEX id, D3DRMMAPPING value)
2671 {
2672     FIXME("iface %p, id %#x, value %#x stub!\n", iface, id, value);
2673
2674     return E_NOTIMPL;
2675 }
2676
2677 static HRESULT WINAPI d3drm_mesh_SetGroupQuality(IDirect3DRMMesh *iface, D3DRMGROUPINDEX id, D3DRMRENDERQUALITY value)
2678 {
2679     FIXME("iface %p, id %#x, value %#x stub!\n", iface, id, value);
2680
2681     return E_NOTIMPL;
2682 }
2683
2684 static HRESULT WINAPI d3drm_mesh_SetGroupMaterial(IDirect3DRMMesh *iface,
2685         D3DRMGROUPINDEX id, IDirect3DRMMaterial *material)
2686 {
2687     struct d3drm_mesh *mesh = impl_from_IDirect3DRMMesh(iface);
2688
2689     TRACE("iface %p, id %#x, material %p.\n", iface, id, material);
2690
2691     if (id >= mesh->nb_groups)
2692         return D3DRMERR_BADVALUE;
2693
2694     if (mesh->groups[id].material)
2695         IDirect3DRMMaterial2_Release(mesh->groups[id].material);
2696
2697     mesh->groups[id].material = (IDirect3DRMMaterial2 *)material;
2698
2699     if (material)
2700         IDirect3DRMMaterial2_AddRef(mesh->groups[id].material);
2701
2702     return D3DRM_OK;
2703 }
2704
2705 static HRESULT WINAPI d3drm_mesh_SetGroupTexture(IDirect3DRMMesh *iface,
2706         D3DRMGROUPINDEX id, IDirect3DRMTexture *texture)
2707 {
2708     struct d3drm_mesh *mesh = impl_from_IDirect3DRMMesh(iface);
2709
2710     TRACE("iface %p, id %#x, texture %p.\n", iface, id, texture);
2711
2712     if (id >= mesh->nb_groups)
2713         return D3DRMERR_BADVALUE;
2714
2715     if (mesh->groups[id].texture)
2716         IDirect3DRMTexture3_Release(mesh->groups[id].texture);
2717
2718     if (!texture)
2719     {
2720         mesh->groups[id].texture = NULL;
2721         return D3DRM_OK;
2722     }
2723
2724     return IDirect3DRMTexture3_QueryInterface(texture, &IID_IDirect3DRMTexture, (void **)&mesh->groups[id].texture);
2725 }
2726
2727 static DWORD WINAPI d3drm_mesh_GetGroupCount(IDirect3DRMMesh *iface)
2728 {
2729     struct d3drm_mesh *mesh = impl_from_IDirect3DRMMesh(iface);
2730
2731     TRACE("iface %p.\n", iface);
2732
2733     return mesh->nb_groups;
2734 }
2735
2736 static HRESULT WINAPI d3drm_mesh_GetGroup(IDirect3DRMMesh *iface, D3DRMGROUPINDEX id, unsigned *vertex_count,
2737         unsigned *face_count, unsigned *vertex_per_face, DWORD *face_data_size, unsigned *face_data)
2738 {
2739     struct d3drm_mesh *mesh = impl_from_IDirect3DRMMesh(iface);
2740
2741     TRACE("iface %p, id %#x, vertex_count %p, face_count %p, vertex_per_face %p, face_data_size %p, face_data %p.\n",
2742             iface, id, vertex_count, face_count, vertex_per_face, face_data_size,face_data);
2743
2744     if (id >= mesh->nb_groups)
2745         return D3DRMERR_BADVALUE;
2746
2747     if (vertex_count)
2748         *vertex_count = mesh->groups[id].nb_vertices;
2749     if (face_count)
2750         *face_count = mesh->groups[id].nb_faces;
2751     if (vertex_per_face)
2752         *vertex_per_face = mesh->groups[id].vertex_per_face;
2753     if (face_data_size)
2754         *face_data_size = mesh->groups[id].face_data_size;
2755     if (face_data)
2756         memcpy(face_data, mesh->groups[id].face_data, mesh->groups[id].face_data_size * sizeof(*face_data));
2757
2758     return D3DRM_OK;
2759 }
2760
2761 static HRESULT WINAPI d3drm_mesh_GetVertices(IDirect3DRMMesh *iface,
2762         D3DRMGROUPINDEX group_id, DWORD start_idx, DWORD count, D3DRMVERTEX *vertices)
2763 {
2764     struct d3drm_mesh *mesh = impl_from_IDirect3DRMMesh(iface);
2765
2766     TRACE("iface %p, group_id %#x, start_idx %u, count %u, vertices %p.\n",
2767             iface, group_id, start_idx, count, vertices);
2768
2769     if (group_id >= mesh->nb_groups)
2770         return D3DRMERR_BADVALUE;
2771
2772     if ((start_idx + count - 1) >= mesh->groups[group_id].nb_vertices)
2773         return D3DRMERR_BADVALUE;
2774
2775     if (!vertices)
2776         return E_POINTER;
2777
2778     memcpy(vertices, mesh->groups[group_id].vertices + start_idx, count * sizeof(*vertices));
2779
2780     return D3DRM_OK;
2781 }
2782
2783 static D3DCOLOR WINAPI d3drm_mesh_GetGroupColor(IDirect3DRMMesh *iface, D3DRMGROUPINDEX id)
2784 {
2785     struct d3drm_mesh *mesh = impl_from_IDirect3DRMMesh(iface);
2786
2787     TRACE("iface %p, id %#x.\n", iface, id);
2788
2789     return mesh->groups[id].color;
2790 }
2791
2792 static D3DRMMAPPING WINAPI d3drm_mesh_GetGroupMapping(IDirect3DRMMesh *iface, D3DRMGROUPINDEX id)
2793 {
2794     FIXME("iface %p, id %#x stub!\n", iface, id);
2795
2796     return 0;
2797 }
2798 static D3DRMRENDERQUALITY WINAPI d3drm_mesh_GetGroupQuality(IDirect3DRMMesh *iface, D3DRMGROUPINDEX id)
2799 {
2800     FIXME("iface %p, id %#x stub!\n", iface, id);
2801
2802     return 0;
2803 }
2804
2805 static HRESULT WINAPI d3drm_mesh_GetGroupMaterial(IDirect3DRMMesh *iface,
2806         D3DRMGROUPINDEX id, IDirect3DRMMaterial **material)
2807 {
2808     struct d3drm_mesh *mesh = impl_from_IDirect3DRMMesh(iface);
2809
2810     TRACE("iface %p, id %#x, material %p.\n", iface, id, material);
2811
2812     if (id >= mesh->nb_groups)
2813         return D3DRMERR_BADVALUE;
2814
2815     if (!material)
2816         return E_POINTER;
2817
2818     if (mesh->groups[id].material)
2819         IDirect3DRMTexture_QueryInterface(mesh->groups[id].material, &IID_IDirect3DRMMaterial, (void **)material);
2820     else
2821         *material = NULL;
2822
2823     return D3DRM_OK;
2824 }
2825
2826 static HRESULT WINAPI d3drm_mesh_GetGroupTexture(IDirect3DRMMesh *iface,
2827         D3DRMGROUPINDEX id, IDirect3DRMTexture **texture)
2828 {
2829     struct d3drm_mesh *mesh = impl_from_IDirect3DRMMesh(iface);
2830
2831     TRACE("iface %p, id %#x, texture %p.\n", iface, id, texture);
2832
2833     if (id >= mesh->nb_groups)
2834         return D3DRMERR_BADVALUE;
2835
2836     if (!texture)
2837         return E_POINTER;
2838
2839     if (mesh->groups[id].texture)
2840         IDirect3DRMTexture_QueryInterface(mesh->groups[id].texture, &IID_IDirect3DRMTexture, (void **)texture);
2841     else
2842         *texture = NULL;
2843
2844     return D3DRM_OK;
2845 }
2846
2847 static const struct IDirect3DRMMeshVtbl d3drm_mesh_vtbl =
2848 {
2849     d3drm_mesh_QueryInterface,
2850     d3drm_mesh_AddRef,
2851     d3drm_mesh_Release,
2852     d3drm_mesh_Clone,
2853     d3drm_mesh_AddDestroyCallback,
2854     d3drm_mesh_DeleteDestroyCallback,
2855     d3drm_mesh_SetAppData,
2856     d3drm_mesh_GetAppData,
2857     d3drm_mesh_SetName,
2858     d3drm_mesh_GetName,
2859     d3drm_mesh_GetClassName,
2860     d3drm_mesh_Scale,
2861     d3drm_mesh_Translate,
2862     d3drm_mesh_GetBox,
2863     d3drm_mesh_AddGroup,
2864     d3drm_mesh_SetVertices,
2865     d3drm_mesh_SetGroupColor,
2866     d3drm_mesh_SetGroupColorRGB,
2867     d3drm_mesh_SetGroupMapping,
2868     d3drm_mesh_SetGroupQuality,
2869     d3drm_mesh_SetGroupMaterial,
2870     d3drm_mesh_SetGroupTexture,
2871     d3drm_mesh_GetGroupCount,
2872     d3drm_mesh_GetGroup,
2873     d3drm_mesh_GetVertices,
2874     d3drm_mesh_GetGroupColor,
2875     d3drm_mesh_GetGroupMapping,
2876     d3drm_mesh_GetGroupQuality,
2877     d3drm_mesh_GetGroupMaterial,
2878     d3drm_mesh_GetGroupTexture,
2879 };
2880
2881 HRESULT Direct3DRMMesh_create(IDirect3DRMMesh **mesh)
2882 {
2883     static const char classname[] = "Mesh";
2884     struct d3drm_mesh *object;
2885
2886     TRACE("mesh %p.\n", mesh);
2887
2888     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2889         return E_OUTOFMEMORY;
2890
2891     object->IDirect3DRMMesh_iface.lpVtbl = &d3drm_mesh_vtbl;
2892     object->ref = 1;
2893
2894     d3drm_object_init(&object->obj, classname);
2895
2896     *mesh = &object->IDirect3DRMMesh_iface;
2897
2898     return S_OK;
2899 }