dlls/ddraw/vertexbuffer.c

   1 /* Direct3D Vertex Buffer
   2  * Copyright (c) 2002 Lionel ULMER
   3  * Copyright (c) 2006 Stefan DÖSINGER
   4  *
   5  * This file contains the implementation of Direct3DVertexBuffer COM object
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24 #include "wine/debug.h"
  25
  26 #include <assert.h>
  27 #include <stdarg.h>
  28 #include <string.h>
  29 #include <stdlib.h>
  30
  31 #define COBJMACROS
  32
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "winerror.h"
  36 #include "wingdi.h"
  37 #include "wine/exception.h"
  38
  39 #include "ddraw.h"
  40 #include "d3d.h"
  41
  42 #include "ddraw_private.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(d3d7);
  45 WINE_DECLARE_DEBUG_CHANNEL(ddraw_thunk);
  46
  47
  48 /*****************************************************************************
  49  * IUnknown Methods
  50  *****************************************************************************/
  51
  52 /*****************************************************************************
  53  * IDirect3DVertexBuffer7::QueryInterface
  54  *
  55  * The QueryInterface Method for Vertex Buffers
  56  * For a link to QueryInterface rules, see IDirectDraw7::QueryInterface
  57  *
  58  * Params
  59  *  riid: Queryied Interface id
  60  *  obj: Address to return the interface pointer
  61  *
  62  * Returns:
  63  *  S_OK on success
  64  *  E_NOINTERFACE if the interface wasn't found
  65  *
  66  *****************************************************************************/
  67 static HRESULT WINAPI
  68 IDirect3DVertexBufferImpl_QueryInterface(IDirect3DVertexBuffer7 *iface,
  69                                          REFIID riid,
  70                                          void  **obj)
  71 {
  72     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, iface);
  73     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), obj);
  74
  75     /* By default, set the object pointer to NULL */
  76     *obj = NULL;
  77
  78     if ( IsEqualGUID( &IID_IUnknown,  riid ) )
  79     {
  80         IDirect3DVertexBuffer7_AddRef(ICOM_INTERFACE(This,IDirect3DVertexBuffer7));
  81         *obj = iface;
  82         TRACE("  Creating IUnknown interface at %p.\n", *obj);
  83         return S_OK;
  84     }
  85     if ( IsEqualGUID( &IID_IDirect3DVertexBuffer, riid ) )
  86     {
  87         IDirect3DVertexBuffer7_AddRef(ICOM_INTERFACE(This,IDirect3DVertexBuffer7));
  88         *obj = ICOM_INTERFACE(This, IDirect3DVertexBuffer);
  89         TRACE("  Creating IDirect3DVertexBuffer interface %p\n", *obj);
  90         return S_OK;
  91     }
  92     if ( IsEqualGUID( &IID_IDirect3DVertexBuffer7, riid ) )
  93     {
  94         IDirect3DVertexBuffer7_AddRef(ICOM_INTERFACE(This,IDirect3DVertexBuffer7));
  95         *obj = ICOM_INTERFACE(This, IDirect3DVertexBuffer7);
  96         TRACE("  Creating IDirect3DVertexBuffer7 interface %p\n", *obj);
  97         return S_OK;
  98     }
  99     FIXME("(%p): interface for IID %s NOT found!\n", This, debugstr_guid(riid));
 100     return E_NOINTERFACE;
 101 }
 102
 103 static HRESULT WINAPI
 104 Thunk_IDirect3DVertexBufferImpl_1_QueryInterface(IDirect3DVertexBuffer *iface,
 105                                                  REFIID riid,
 106                                                  void **obj)
 107 {
 108     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer, iface);
 109     TRACE_(ddraw_thunk)("(%p)->(%s,%p) thunking to IDirect3DVertexBuffer7 interface.\n", This, debugstr_guid(riid), obj);
 110
 111     return IDirect3DVertexBuffer7_QueryInterface(ICOM_INTERFACE(This, IDirect3DVertexBuffer7),
 112                                                  riid,
 113                                                  obj);
 114 }
 115
 116 /*****************************************************************************
 117  * IDirect3DVertexBuffer7::AddRef
 118  *
 119  * AddRef for Vertex Buffers
 120  *
 121  * Returns:
 122  *  The new refcount
 123  *
 124  *****************************************************************************/
 125 static ULONG WINAPI
 126 IDirect3DVertexBufferImpl_AddRef(IDirect3DVertexBuffer7 *iface)
 127 {
 128     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, iface);
 129     ULONG ref = InterlockedIncrement(&This->ref);
 130
 131     TRACE("(%p/%p)->() incrementing from %u.\n", This, iface, ref - 1);
 132
 133     return ref;
 134 }
 135
 136 static ULONG WINAPI
 137 Thunk_IDirect3DVertexBufferImpl_1_AddRef(IDirect3DVertexBuffer *iface)
 138 {
 139     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer, iface);
 140     TRACE_(ddraw_thunk)("(%p)->() thunking to IDirect3DVertexBuffer7 interface.\n", This);
 141
 142     return IDirect3DVertexBuffer7_AddRef(ICOM_INTERFACE(This, IDirect3DVertexBuffer7));
 143 }
 144
 145
 146 /*****************************************************************************
 147  * IDirect3DVertexBuffer7::Release
 148  *
 149  * Release for Vertex Buffers
 150  *
 151  * Returns:
 152  *  The new refcount
 153  *
 154  *****************************************************************************/
 155 static ULONG WINAPI
 156 IDirect3DVertexBufferImpl_Release(IDirect3DVertexBuffer7 *iface)
 157 {
 158     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, iface);
 159     ULONG ref = InterlockedDecrement(&This->ref);
 160
 161     TRACE("(%p)->() decrementing from %u.\n", This, ref + 1);
 162
 163     if (ref == 0)
 164     {
 165         IWineD3DVertexBuffer *curVB = NULL;
 166         UINT offset, stride;
 167
 168         EnterCriticalSection(&ddraw_cs);
 169         /* D3D7 Vertex buffers don't stay bound in the device, they are passed as a parameter
 170          * to drawPrimitiveVB. DrawPrimitiveVB sets them as the stream source in wined3d,
 171          * and they should get unset there before they are destroyed
 172          */
 173         IWineD3DDevice_GetStreamSource(This->ddraw->wineD3DDevice,
 174                                        0 /* Stream number */,
 175                                        &curVB,
 176                                        &offset,
 177                                        &stride);
 178         if(curVB == This->wineD3DVertexBuffer)
 179         {
 180             IWineD3DDevice_SetStreamSource(This->ddraw->wineD3DDevice,
 181                                         0 /* Steam number */,
 182                                         NULL /* stream data */,
 183                                         0 /* Offset */,
 184                                         0 /* stride */);
 185         }
 186         if(curVB)
 187         {
 188             IWineD3DVertexBuffer_Release(curVB); /* For the GetStreamSource */
 189         }
 190
 191         IWineD3DVertexDeclaration_Release(This->wineD3DVertexDeclaration);
 192         IWineD3DVertexBuffer_Release(This->wineD3DVertexBuffer);
 193         LeaveCriticalSection(&ddraw_cs);
 194         HeapFree(GetProcessHeap(), 0, This);
 195
 196         return 0;
 197     }
 198     return ref;
 199 }
 200
 201 static ULONG WINAPI
 202 Thunk_IDirect3DVertexBufferImpl_1_Release(IDirect3DVertexBuffer *iface)
 203 {
 204     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer, iface);
 205     TRACE_(ddraw_thunk)("(%p)->() thunking to IDirect3DVertexBuffer7 interface.\n", This);
 206
 207     return IDirect3DVertexBuffer7_Release(ICOM_INTERFACE(This, IDirect3DVertexBuffer7));
 208 }
 209
 210 /*****************************************************************************
 211  * IDirect3DVertexBuffer Methods
 212  *****************************************************************************/
 213
 214 /*****************************************************************************
 215  * IDirect3DVertexBuffer7::Lock
 216  *
 217  * Locks the vertex buffer and returns a pointer to the vertex data
 218  * Locking vertex buffers is similar to locking surfaces, because Windows
 219  * uses surfaces to store vertex data internally (According to the DX sdk)
 220  *
 221  * Params:
 222  *  Flags: Locking flags. Relevant here are DDLOCK_READONLY, DDLOCK_WRITEONLY,
 223  *         DDLOCK_DISCARDCONTENTS and DDLOCK_NOOVERWRITE.
 224  *  Data:  Returns a pointer to the vertex data
 225  *  Size:  Returns the size of the buffer if not NULL
 226  *
 227  * Returns:
 228  *  D3D_OK on success
 229  *  DDERR_INVALIDPARAMS if Data is NULL
 230  *  D3DERR_VERTEXBUFFEROPTIMIZED if called on an optimized buffer(WineD3D)
 231  *
 232  *****************************************************************************/
 233 static HRESULT WINAPI
 234 IDirect3DVertexBufferImpl_Lock(IDirect3DVertexBuffer7 *iface,
 235                                DWORD Flags,
 236                                void **Data,
 237                                DWORD *Size)
 238 {
 239     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, iface);
 240     WINED3DVERTEXBUFFER_DESC Desc;
 241     HRESULT hr;
 242     TRACE("(%p)->(%08x,%p,%p)\n", This, Flags, Data, Size);
 243
 244     EnterCriticalSection(&ddraw_cs);
 245     if(Size)
 246     {
 247         /* Get the size, for returning it, and for locking */
 248         hr = IWineD3DVertexBuffer_GetDesc(This->wineD3DVertexBuffer,
 249                                           &Desc);
 250         if(hr != D3D_OK)
 251         {
 252             ERR("(%p) IWineD3DVertexBuffer::GetDesc failed with hr=%08x\n", This, hr);
 253             LeaveCriticalSection(&ddraw_cs);
 254             return hr;
 255         }
 256         *Size = Desc.Size;
 257     }
 258
 259     hr = IWineD3DVertexBuffer_Lock(This->wineD3DVertexBuffer,
 260                                    0 /* OffsetToLock */,
 261                                    0 /* SizeToLock, 0 == Full lock */,
 262                                    (BYTE **) Data,
 263                                    Flags);
 264     LeaveCriticalSection(&ddraw_cs);
 265     return hr;
 266 }
 267
 268 static HRESULT WINAPI
 269 Thunk_IDirect3DVertexBufferImpl_1_Lock(IDirect3DVertexBuffer *iface,
 270                                        DWORD Flags,
 271                                        void **Data,
 272                                        DWORD *Size)
 273 {
 274     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer, iface);
 275     TRACE_(ddraw_thunk)("(%p)->(%08x,%p,%p) thunking to IDirect3DVertexBuffer7 interface.\n", This, Flags, Data, Size);
 276
 277     return IDirect3DVertexBuffer7_Lock(ICOM_INTERFACE(This, IDirect3DVertexBuffer7),
 278                                        Flags,
 279                                        Data,
 280                                        Size);
 281 }
 282
 283 /*****************************************************************************
 284  * IDirect3DVertexBuffer7::Unlock
 285  *
 286  * Unlocks a vertex Buffer
 287  *
 288  * Returns:
 289  *  D3D_OK on success
 290  *
 291  *****************************************************************************/
 292 static HRESULT WINAPI
 293 IDirect3DVertexBufferImpl_Unlock(IDirect3DVertexBuffer7 *iface)
 294 {
 295     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, iface);
 296     HRESULT hr;
 297     TRACE("(%p)->()\n", This);
 298
 299     EnterCriticalSection(&ddraw_cs);
 300     hr = IWineD3DVertexBuffer_Unlock(This->wineD3DVertexBuffer);
 301     LeaveCriticalSection(&ddraw_cs);
 302
 303     return hr;
 304 }
 305
 306 static HRESULT WINAPI
 307 Thunk_IDirect3DVertexBufferImpl_1_Unlock(IDirect3DVertexBuffer *iface)
 308 {
 309     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer, iface);
 310     TRACE_(ddraw_thunk)("(%p)->() thunking to IDirect3DVertexBuffer7 interface.\n", This);
 311
 312     return IDirect3DVertexBuffer7_Unlock(ICOM_INTERFACE(This, IDirect3DVertexBuffer7));
 313 }
 314
 315
 316 /*****************************************************************************
 317  * IDirect3DVertexBuffer7::ProcessVertices
 318  *
 319  * Processes untransformed Vertices into a transformed or optimized vertex
 320  * buffer. It can also perform other operations, such as lighting or clipping
 321  *
 322  * Params
 323  *  VertexOp: Operation(s) to perform: D3DVOP_CLIP, _EXTENTS, _LIGHT, _TRANSFORM
 324  *  DestIndex: Index in the destination buffer(This), where the vertices are
 325  *             placed
 326  *  Count: Number of Vertices in the Source buffer to process
 327  *  SrcBuffer: Source vertex buffer
 328  *  SrcIndex: Index of the first vertex in the src buffer to process
 329  *  D3DDevice: Device to use for transformation
 330  *  Flags: 0 for default, D3DPV_DONOTCOPYDATA to prevent copying
 331  *         unchaned vertices
 332  *
 333  * Returns:
 334  *  D3D_OK on success
 335  *  DDERR_INVALIDPARAMS If D3DVOP_TRANSFORM wasn't passed
 336  *
 337  *****************************************************************************/
 338 static HRESULT WINAPI
 339 IDirect3DVertexBufferImpl_ProcessVertices(IDirect3DVertexBuffer7 *iface,
 340                                           DWORD VertexOp,
 341                                           DWORD DestIndex,
 342                                           DWORD Count,
 343                                           IDirect3DVertexBuffer7 *SrcBuffer,
 344                                           DWORD SrcIndex,
 345                                           IDirect3DDevice7 *D3DDevice,
 346                                           DWORD Flags)
 347 {
 348     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, iface);
 349     IDirect3DVertexBufferImpl *Src = ICOM_OBJECT(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, SrcBuffer);
 350     IDirect3DDeviceImpl *D3D = ICOM_OBJECT(IDirect3DDeviceImpl, IDirect3DDevice7, D3DDevice);
 351     BOOL oldClip, doClip;
 352     HRESULT hr;
 353     WINED3DVERTEXBUFFER_DESC Desc;
 354
 355     TRACE("(%p)->(%08x,%d,%d,%p,%d,%p,%08x)\n", This, VertexOp, DestIndex, Count, Src, SrcIndex, D3D, Flags);
 356
 357     /* Vertex operations:
 358      * D3DVOP_CLIP: Clips vertices outside the viewing frustrum. Needs clipping information
 359      * in the vertex buffer (Buffer may not be created with D3DVBCAPS_DONOTCLIP)
 360      * D3DVOP_EXTENTS: Causes the screen extents to be updated when rendering the vertices
 361      * D3DVOP_LIGHT: Lights the vertices
 362      * D3DVOP_TRANSFORM: Transform the vertices. This flag is necessary
 363      *
 364      * WineD3D only transforms and clips the vertices by now, so EXTENTS and LIGHT
 365      * are not implemented. Clipping is disabled ATM, because of unsure conditions.
 366      */
 367     if( !(VertexOp & D3DVOP_TRANSFORM) ) return DDERR_INVALIDPARAMS;
 368
 369     EnterCriticalSection(&ddraw_cs);
 370     /* WineD3D doesn't know d3d7 vertex operation, it uses
 371      * render states instead. Set the render states according to
 372      * the vertex ops
 373      */
 374     doClip = VertexOp & D3DVOP_CLIP ? TRUE : FALSE;
 375     IWineD3DDevice_GetRenderState(D3D->wineD3DDevice,
 376                                   WINED3DRS_CLIPPING,
 377                                   (DWORD *) &oldClip);
 378     if(doClip != oldClip)
 379     {
 380         IWineD3DDevice_SetRenderState(D3D->wineD3DDevice,
 381                                       WINED3DRS_CLIPPING,
 382                                       doClip);
 383     }
 384
 385     IWineD3DVertexBuffer_GetDesc(Src->wineD3DVertexBuffer,
 386                                  &Desc);
 387     IWineD3DDevice_SetStreamSource(D3D->wineD3DDevice,
 388                                    0, /* Stream No */
 389                                    Src->wineD3DVertexBuffer,
 390                                    0, /* Offset */
 391                                    get_flexible_vertex_size(Desc.FVF));
 392     IWineD3DDevice_SetVertexDeclaration(D3D->wineD3DDevice,
 393                                         Src->wineD3DVertexDeclaration);
 394     hr = IWineD3DDevice_ProcessVertices(D3D->wineD3DDevice,
 395                                         SrcIndex,
 396                                         DestIndex,
 397                                         Count,
 398                                         This->wineD3DVertexBuffer,
 399                                         NULL /* Output vdecl */,
 400                                         Flags);
 401
 402     /* Restore the states if needed */
 403     if(doClip != oldClip)
 404         IWineD3DDevice_SetRenderState(D3D->wineD3DDevice,
 405                                       WINED3DRS_CLIPPING,
 406                                       oldClip);
 407     LeaveCriticalSection(&ddraw_cs);
 408     return hr;
 409 }
 410
 411 static HRESULT WINAPI
 412 Thunk_IDirect3DVertexBufferImpl_1_ProcessVertices(IDirect3DVertexBuffer *iface,
 413                                                   DWORD VertexOp,
 414                                                   DWORD DestIndex,
 415                                                   DWORD Count,
 416                                                   IDirect3DVertexBuffer *SrcBuffer,
 417                                                   DWORD SrcIndex,
 418                                                   IDirect3DDevice3 *D3DDevice,
 419                                                   DWORD Flags)
 420 {
 421     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer, iface);
 422     IDirect3DVertexBufferImpl *Src = ICOM_OBJECT(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer, SrcBuffer);
 423     IDirect3DDeviceImpl *D3D = ICOM_OBJECT(IDirect3DDeviceImpl, IDirect3DDevice3, D3DDevice);
 424
 425     TRACE_(ddraw_thunk)("(%p)->(%08x,%08x,%08x,%p,%08x,%p,%08x) thunking to IDirect3DVertexBuffer7 interface.\n", This, VertexOp, DestIndex, Count, Src, SrcIndex, D3D, Flags);
 426
 427     return IDirect3DVertexBuffer7_ProcessVertices(ICOM_INTERFACE(This, IDirect3DVertexBuffer7),
 428                                                   VertexOp,
 429                                                   DestIndex,
 430                                                   Count,
 431                                                   ICOM_INTERFACE(Src, IDirect3DVertexBuffer7),
 432                                                   SrcIndex,
 433                                                   ICOM_INTERFACE(D3D, IDirect3DDevice7),
 434                                                   Flags);
 435 }
 436
 437 /*****************************************************************************
 438  * IDirect3DVertexBuffer7::GetVertexBufferDesc
 439  *
 440  * Returns the description of a vertex buffer
 441  *
 442  * Params:
 443  *  Desc: Address to write the description to
 444  *
 445  * Returns
 446  *  DDERR_INVALIDPARAMS if Desc is NULL
 447  *  D3D_OK on success
 448  *
 449  *****************************************************************************/
 450 static HRESULT WINAPI
 451 IDirect3DVertexBufferImpl_GetVertexBufferDesc(IDirect3DVertexBuffer7 *iface,
 452                                               D3DVERTEXBUFFERDESC *Desc)
 453 {
 454     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, iface);
 455     WINED3DVERTEXBUFFER_DESC WDesc;
 456     HRESULT hr;
 457     TRACE("(%p)->(%p)\n", This, Desc);
 458
 459     if(!Desc) return DDERR_INVALIDPARAMS;
 460
 461     EnterCriticalSection(&ddraw_cs);
 462     hr = IWineD3DVertexBuffer_GetDesc(This->wineD3DVertexBuffer,
 463                                       &WDesc);
 464     if(hr != D3D_OK)
 465     {
 466         ERR("(%p) IWineD3DVertexBuffer::GetDesc failed with hr=%08x\n", This, hr);
 467         LeaveCriticalSection(&ddraw_cs);
 468         return hr;
 469     }
 470
 471     /* Now fill the Desc structure */
 472     Desc->dwCaps = This->Caps;
 473     Desc->dwFVF = WDesc.FVF;
 474     Desc->dwNumVertices = WDesc.Size / get_flexible_vertex_size(WDesc.FVF);
 475     LeaveCriticalSection(&ddraw_cs);
 476
 477     return D3D_OK;
 478 }
 479
 480 static HRESULT WINAPI
 481 Thunk_IDirect3DVertexBufferImpl_1_GetVertexBufferDesc(IDirect3DVertexBuffer *iface,
 482                                                       D3DVERTEXBUFFERDESC *Desc)
 483 {
 484     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer, iface);
 485     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DVertexBuffer7 interface.\n", This, Desc);
 486
 487     return IDirect3DVertexBuffer7_GetVertexBufferDesc(ICOM_INTERFACE(This, IDirect3DVertexBuffer7),
 488                                                       Desc);
 489 }
 490
 491
 492 /*****************************************************************************
 493  * IDirect3DVertexBuffer7::Optimize
 494  *
 495  * Converts an unoptimized vertex buffer into an optimized buffer
 496  *
 497  * Params:
 498  *  D3DDevice: Device for which this buffer is optimized
 499  *  Flags: Not used, should be set to 0
 500  *
 501  * Returns
 502  *  D3D_OK, because it's a stub
 503  *
 504  *****************************************************************************/
 505 static HRESULT WINAPI
 506 IDirect3DVertexBufferImpl_Optimize(IDirect3DVertexBuffer7 *iface,
 507                                    IDirect3DDevice7 *D3DDevice,
 508                                    DWORD Flags)
 509 {
 510     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, iface);
 511     IDirect3DDeviceImpl *D3D = ICOM_OBJECT(IDirect3DDeviceImpl, IDirect3DDevice7, D3DDevice);
 512     FIXME("(%p)->(%p,%08x): stub!\n", This, D3D, Flags);
 513
 514     /* We could forward this call to WineD3D and take advantage
 515      * of it once we use OpenGL vertex buffers
 516      */
 517     EnterCriticalSection(&ddraw_cs);
 518     This->Caps |= D3DVBCAPS_OPTIMIZED;
 519     LeaveCriticalSection(&ddraw_cs);
 520
 521     return DD_OK;
 522 }
 523
 524 static HRESULT WINAPI
 525 Thunk_IDirect3DVertexBufferImpl_1_Optimize(IDirect3DVertexBuffer *iface,
 526                                            IDirect3DDevice3 *D3DDevice,
 527                                            DWORD Flags)
 528 {
 529     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer, iface);
 530     IDirect3DDeviceImpl *D3D = ICOM_OBJECT(IDirect3DDeviceImpl, IDirect3DDevice3, D3DDevice);
 531     TRACE_(ddraw_thunk)("(%p)->(%p,%08x) thunking to IDirect3DVertexBuffer7 interface.\n", This, D3D, Flags);
 532
 533     return IDirect3DVertexBuffer7_Optimize(ICOM_INTERFACE(This, IDirect3DVertexBuffer7),
 534                                            ICOM_INTERFACE(D3D, IDirect3DDevice7),
 535                                            Flags);
 536 }
 537
 538 /*****************************************************************************
 539  * IDirect3DVertexBuffer7::ProcessVerticesStrided
 540  *
 541  * This method processes untransformed strided vertices into a processed
 542  * or optimized vertex buffer.
 543  *
 544  * For more details on the parameters, see
 545  * IDirect3DVertexBuffer7::ProcessVertices
 546  *
 547  * Params:
 548  *  VertexOp: Operations to perform
 549  *  DestIndex: Destination index to write the vertices to
 550  *  Count: Number of input vertices
 551  *  StrideData: Array containing the input vertices
 552  *  VertexTypeDesc: Vertex Description or source index?????????
 553  *  D3DDevice: IDirect3DDevice7 to use for processing
 554  *  Flags: Can be D3DPV_DONOTCOPYDATA to avoid copying unmodified vertices
 555  *
 556  * Returns
 557  *  D3D_OK on success, or DDERR_*
 558  *
 559  *****************************************************************************/
 560 static HRESULT WINAPI
 561 IDirect3DVertexBufferImpl_ProcessVerticesStrided(IDirect3DVertexBuffer7 *iface,
 562                                                  DWORD VertexOp,
 563                                                  DWORD DestIndex,
 564                                                  DWORD Count,
 565                                                  D3DDRAWPRIMITIVESTRIDEDDATA *StrideData,
 566                                                  DWORD VertexTypeDesc,
 567                                                  IDirect3DDevice7 *D3DDevice,
 568                                                  DWORD Flags)
 569 {
 570     ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, iface);
 571     IDirect3DDeviceImpl *D3D = ICOM_OBJECT(IDirect3DDeviceImpl, IDirect3DDevice7, D3DDevice);
 572     FIXME("(%p)->(%08x,%08x,%08x,%p,%08x,%p,%08x): stub!\n", This, VertexOp, DestIndex, Count, StrideData, VertexTypeDesc, D3D, Flags);
 573     return DD_OK;
 574 }
 575
 576 /*****************************************************************************
 577  * The VTables
 578  *****************************************************************************/
 579
 580 const IDirect3DVertexBuffer7Vtbl IDirect3DVertexBuffer7_Vtbl =
 581 {
 582     /*** IUnknown Methods ***/
 583     IDirect3DVertexBufferImpl_QueryInterface,
 584     IDirect3DVertexBufferImpl_AddRef,
 585     IDirect3DVertexBufferImpl_Release,
 586     /*** IDirect3DVertexBuffer Methods ***/
 587     IDirect3DVertexBufferImpl_Lock,
 588     IDirect3DVertexBufferImpl_Unlock,
 589     IDirect3DVertexBufferImpl_ProcessVertices,
 590     IDirect3DVertexBufferImpl_GetVertexBufferDesc,
 591     IDirect3DVertexBufferImpl_Optimize,
 592     /*** IDirect3DVertexBuffer7 Methods ***/
 593     IDirect3DVertexBufferImpl_ProcessVerticesStrided
 594 };
 595
 596 const IDirect3DVertexBufferVtbl IDirect3DVertexBuffer1_Vtbl =
 597 {
 598     /*** IUnknown Methods ***/
 599     Thunk_IDirect3DVertexBufferImpl_1_QueryInterface,
 600     Thunk_IDirect3DVertexBufferImpl_1_AddRef,
 601     Thunk_IDirect3DVertexBufferImpl_1_Release,
 602     /*** IDirect3DVertexBuffer Methods ***/
 603     Thunk_IDirect3DVertexBufferImpl_1_Lock,
 604     Thunk_IDirect3DVertexBufferImpl_1_Unlock,
 605     Thunk_IDirect3DVertexBufferImpl_1_ProcessVertices,
 606     Thunk_IDirect3DVertexBufferImpl_1_GetVertexBufferDesc,
 607     Thunk_IDirect3DVertexBufferImpl_1_Optimize
 608 };