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