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

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