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