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