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