git.oblomov.eu Git - wine/blob - dlls/d3drm/meshbuilder.c

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