dlls/ddraw/vertexbuffer.c

   1 /* Direct3D Vertex Buffer
   2  * Copyright (c) 2002 Lionel ULMER
   3  * Copyright (c) 2006 Stefan DÖSINGER
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "config.h"
  21 #include "wine/port.h"
  22
  23 #include "ddraw_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
  26
  27 static inline struct d3d_vertex_buffer *impl_from_IDirect3DVertexBuffer7(IDirect3DVertexBuffer7 *iface)
  28 {
  29     return CONTAINING_RECORD(iface, struct d3d_vertex_buffer, IDirect3DVertexBuffer7_iface);
  30 }
  31
  32 /*****************************************************************************
  33  * IUnknown Methods
  34  *****************************************************************************/
  35
  36 static HRESULT WINAPI d3d_vertex_buffer7_QueryInterface(IDirect3DVertexBuffer7 *iface, REFIID riid, void  **obj)
  37 {
  38     struct d3d_vertex_buffer *buffer = impl_from_IDirect3DVertexBuffer7(iface);
  39
  40     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), obj);
  41
  42     *obj = NULL;
  43
  44     if (IsEqualGUID(&IID_IUnknown, riid))
  45     {
  46         IDirect3DVertexBuffer7_AddRef(iface);
  47         *obj = iface;
  48         return S_OK;
  49     }
  50     if (IsEqualGUID(&IID_IDirect3DVertexBuffer7, riid) && buffer->version == 7)
  51     {
  52         IDirect3DVertexBuffer7_AddRef(iface);
  53         *obj = iface;
  54         return S_OK;
  55     }
  56     if (IsEqualGUID(&IID_IDirect3DVertexBuffer, riid) && buffer->version == 3)
  57     {
  58         IDirect3DVertexBuffer7_AddRef(iface);
  59         *obj = iface;
  60         return S_OK;
  61     }
  62
  63     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  64     return E_NOINTERFACE;
  65 }
  66
  67 static ULONG WINAPI d3d_vertex_buffer7_AddRef(IDirect3DVertexBuffer7 *iface)
  68 {
  69     struct d3d_vertex_buffer *buffer = impl_from_IDirect3DVertexBuffer7(iface);
  70     ULONG ref = InterlockedIncrement(&buffer->ref);
  71
  72     TRACE("%p increasing refcount to %u.\n", buffer, ref);
  73
  74     return ref;
  75 }
  76
  77 static ULONG WINAPI d3d_vertex_buffer7_Release(IDirect3DVertexBuffer7 *iface)
  78 {
  79     struct d3d_vertex_buffer *buffer = impl_from_IDirect3DVertexBuffer7(iface);
  80     ULONG ref = InterlockedDecrement(&buffer->ref);
  81
  82     TRACE("%p decreasing refcount to %u.\n", buffer, ref);
  83
  84     if (!ref)
  85     {
  86         struct wined3d_buffer *vb = NULL;
  87         UINT offset, stride;
  88
  89         /* D3D7 vertex buffers don't stay bound in the device, they are passed
  90          * as a parameter to DrawPrimitiveVB. DrawPrimitiveVB sets them as the
  91          * stream source in wined3d and they should get unset there before
  92          * they are destroyed. */
  93         wined3d_mutex_lock();
  94         wined3d_device_get_stream_source(buffer->ddraw->wined3d_device, 0, &vb, &offset, &stride);
  95         if (vb == buffer->wined3d_buffer)
  96             wined3d_device_set_stream_source(buffer->ddraw->wined3d_device, 0, NULL, 0, 0);
  97
  98         wined3d_vertex_declaration_decref(buffer->wined3d_declaration);
  99         wined3d_buffer_decref(buffer->wined3d_buffer);
 100         wined3d_mutex_unlock();
 101
 102         if (buffer->version == 7)
 103             IDirectDraw7_Release(&buffer->ddraw->IDirectDraw7_iface);
 104
 105         HeapFree(GetProcessHeap(), 0, buffer);
 106     }
 107
 108     return ref;
 109 }
 110
 111 /*****************************************************************************
 112  * IDirect3DVertexBuffer Methods
 113  *****************************************************************************/
 114
 115 static HRESULT d3d_vertex_buffer_create_wined3d_buffer(struct d3d_vertex_buffer *buffer, BOOL dynamic,
 116         struct wined3d_buffer **wined3d_buffer)
 117 {
 118     struct wined3d_buffer_desc desc;
 119
 120     desc.byte_width = buffer->size;
 121     desc.usage = WINED3DUSAGE_STATICDECL;
 122     if (buffer->Caps & D3DVBCAPS_WRITEONLY)
 123         desc.usage |= WINED3DUSAGE_WRITEONLY;
 124     if (dynamic)
 125         desc.usage |= WINED3DUSAGE_DYNAMIC;
 126     desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER;
 127     if (buffer->Caps & D3DVBCAPS_SYSTEMMEMORY)
 128         desc.access = WINED3D_RESOURCE_ACCESS_CPU | WINED3D_RESOURCE_ACCESS_MAP;
 129     else
 130         desc.access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP;
 131     desc.misc_flags = 0;
 132     desc.structure_byte_stride = 0;
 133
 134     return wined3d_buffer_create(buffer->ddraw->wined3d_device, &desc,
 135             NULL, buffer, &ddraw_null_wined3d_parent_ops, wined3d_buffer);
 136 }
 137
 138 /*****************************************************************************
 139  * IDirect3DVertexBuffer7::Lock
 140  *
 141  * Locks the vertex buffer and returns a pointer to the vertex data
 142  * Locking vertex buffers is similar to locking surfaces, because Windows
 143  * uses surfaces to store vertex data internally (According to the DX sdk)
 144  *
 145  * Params:
 146  *  Flags: Locking flags. Relevant here are DDLOCK_READONLY, DDLOCK_WRITEONLY,
 147  *         DDLOCK_DISCARDCONTENTS and DDLOCK_NOOVERWRITE.
 148  *  Data:  Returns a pointer to the vertex data
 149  *  Size:  Returns the size of the buffer if not NULL
 150  *
 151  * Returns:
 152  *  D3D_OK on success
 153  *  DDERR_INVALIDPARAMS if Data is NULL
 154  *  D3DERR_VERTEXBUFFEROPTIMIZED if called on an optimized buffer(WineD3D)
 155  *
 156  *****************************************************************************/
 157 static HRESULT WINAPI d3d_vertex_buffer7_Lock(IDirect3DVertexBuffer7 *iface,
 158         DWORD flags, void **data, DWORD *data_size)
 159 {
 160     struct d3d_vertex_buffer *buffer = impl_from_IDirect3DVertexBuffer7(iface);
 161     struct wined3d_resource_desc wined3d_desc;
 162     struct wined3d_resource *wined3d_resource;
 163     struct wined3d_map_desc wined3d_map_desc;
 164     HRESULT hr;
 165     DWORD wined3d_flags = 0;
 166
 167     TRACE("iface %p, flags %#x, data %p, data_size %p.\n", iface, flags, data, data_size);
 168
 169     if (buffer->version != 7)
 170         flags &= ~(DDLOCK_NOOVERWRITE | DDLOCK_DISCARDCONTENTS);
 171
 172     /* Writeonly: Pointless. Event: Unsupported by native according to the sdk
 173      * nosyslock: Not applicable
 174      */
 175     if (!(flags & DDLOCK_WAIT))
 176         wined3d_flags |= WINED3D_MAP_DONOTWAIT;
 177     if (flags & DDLOCK_READONLY)
 178         wined3d_flags |= WINED3D_MAP_READONLY;
 179     if (flags & DDLOCK_NOOVERWRITE)
 180         wined3d_flags |= WINED3D_MAP_NOOVERWRITE;
 181     if (flags & DDLOCK_DISCARDCONTENTS)
 182     {
 183         wined3d_flags |= WINED3D_MAP_DISCARD;
 184
 185         if (!buffer->dynamic)
 186         {
 187             struct wined3d_buffer *new_buffer;
 188             wined3d_mutex_lock();
 189             hr = d3d_vertex_buffer_create_wined3d_buffer(buffer, TRUE, &new_buffer);
 190             if (SUCCEEDED(hr))
 191             {
 192                 buffer->dynamic = TRUE;
 193                 wined3d_buffer_decref(buffer->wined3d_buffer);
 194                 buffer->wined3d_buffer = new_buffer;
 195             }
 196             else
 197             {
 198                 WARN("Failed to create a dynamic buffer\n");
 199             }
 200             wined3d_mutex_unlock();
 201         }
 202     }
 203
 204     wined3d_mutex_lock();
 205     if (data_size)
 206     {
 207         /* Get the size, for returning it, and for locking */
 208         wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 209         wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);
 210         *data_size = wined3d_desc.size;
 211     }
 212
 213     hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->wined3d_buffer),
 214             0, &wined3d_map_desc, NULL, wined3d_flags);
 215     *data = wined3d_map_desc.data;
 216
 217     wined3d_mutex_unlock();
 218
 219     return hr;
 220 }
 221
 222 /*****************************************************************************
 223  * IDirect3DVertexBuffer7::Unlock
 224  *
 225  * Unlocks a vertex Buffer
 226  *
 227  * Returns:
 228  *  D3D_OK on success
 229  *
 230  *****************************************************************************/
 231 static HRESULT WINAPI d3d_vertex_buffer7_Unlock(IDirect3DVertexBuffer7 *iface)
 232 {
 233     struct d3d_vertex_buffer *buffer = impl_from_IDirect3DVertexBuffer7(iface);
 234
 235     TRACE("iface %p.\n", iface);
 236
 237     wined3d_mutex_lock();
 238     wined3d_resource_unmap(wined3d_buffer_get_resource(buffer->wined3d_buffer), 0);
 239     wined3d_mutex_unlock();
 240
 241     return D3D_OK;
 242 }
 243
 244 /*****************************************************************************
 245  * IDirect3DVertexBuffer7::ProcessVertices
 246  *
 247  * Processes untransformed Vertices into a transformed or optimized vertex
 248  * buffer. It can also perform other operations, such as lighting or clipping
 249  *
 250  * Params
 251  *  VertexOp: Operation(s) to perform: D3DVOP_CLIP, _EXTENTS, _LIGHT, _TRANSFORM
 252  *  DestIndex: Index in the destination buffer(This), where the vertices are
 253  *             placed
 254  *  Count: Number of Vertices in the Source buffer to process
 255  *  SrcBuffer: Source vertex buffer
 256  *  SrcIndex: Index of the first vertex in the src buffer to process
 257  *  D3DDevice: Device to use for transformation
 258  *  Flags: 0 for default, D3DPV_DONOTCOPYDATA to prevent copying
 259  *         unchanged vertices
 260  *
 261  * Returns:
 262  *  D3D_OK on success
 263  *  DDERR_INVALIDPARAMS If D3DVOP_TRANSFORM wasn't passed
 264  *
 265  *****************************************************************************/
 266 static HRESULT WINAPI d3d_vertex_buffer7_ProcessVertices(IDirect3DVertexBuffer7 *iface,
 267         DWORD vertex_op, DWORD dst_idx, DWORD count, IDirect3DVertexBuffer7 *src_buffer,
 268         DWORD src_idx, IDirect3DDevice7 *device, DWORD flags)
 269 {
 270     struct d3d_vertex_buffer *dst_buffer_impl = impl_from_IDirect3DVertexBuffer7(iface);
 271     struct d3d_vertex_buffer *src_buffer_impl = unsafe_impl_from_IDirect3DVertexBuffer7(src_buffer);
 272     struct d3d_device *device_impl = dst_buffer_impl->version == 7
 273             ? unsafe_impl_from_IDirect3DDevice7(device)
 274             : unsafe_impl_from_IDirect3DDevice3((IDirect3DDevice3 *)device);
 275     BOOL oldClip, doClip;
 276     HRESULT hr;
 277
 278     TRACE("iface %p, vertex_op %#x, dst_idx %u, count %u, src_buffer %p, src_idx %u, device %p, flags %#x.\n",
 279             iface, vertex_op, dst_idx, count, src_buffer, src_idx, device, flags);
 280
 281     /* Vertex operations:
 282      * D3DVOP_CLIP: Clips vertices outside the viewing frustrum. Needs clipping information
 283      * in the vertex buffer (Buffer may not be created with D3DVBCAPS_DONOTCLIP)
 284      * D3DVOP_EXTENTS: Causes the screen extents to be updated when rendering the vertices
 285      * D3DVOP_LIGHT: Lights the vertices
 286      * D3DVOP_TRANSFORM: Transform the vertices. This flag is necessary
 287      *
 288      * WineD3D only transforms and clips the vertices by now, so EXTENTS and LIGHT
 289      * are not implemented. Clipping is disabled ATM, because of unsure conditions.
 290      */
 291     if (!(vertex_op & D3DVOP_TRANSFORM))
 292         return DDERR_INVALIDPARAMS;
 293
 294     wined3d_mutex_lock();
 295
 296     /* WineD3D doesn't know d3d7 vertex operation, it uses
 297      * render states instead. Set the render states according to
 298      * the vertex ops
 299      */
 300     doClip = !!(vertex_op & D3DVOP_CLIP);
 301     oldClip = wined3d_device_get_render_state(device_impl->wined3d_device, WINED3D_RS_CLIPPING);
 302     if (doClip != oldClip)
 303         wined3d_device_set_render_state(device_impl->wined3d_device, WINED3D_RS_CLIPPING, doClip);
 304
 305     wined3d_device_set_stream_source(device_impl->wined3d_device,
 306             0, src_buffer_impl->wined3d_buffer, 0, get_flexible_vertex_size(src_buffer_impl->fvf));
 307     wined3d_device_set_vertex_declaration(device_impl->wined3d_device, src_buffer_impl->wined3d_declaration);
 308     hr = wined3d_device_process_vertices(device_impl->wined3d_device, src_idx, dst_idx,
 309             count, dst_buffer_impl->wined3d_buffer, NULL, flags, dst_buffer_impl->fvf);
 310
 311     /* Restore the states if needed */
 312     if (doClip != oldClip)
 313         wined3d_device_set_render_state(device_impl->wined3d_device, WINED3D_RS_CLIPPING, oldClip);
 314
 315     wined3d_mutex_unlock();
 316
 317     return hr;
 318 }
 319
 320 /*****************************************************************************
 321  * IDirect3DVertexBuffer7::GetVertexBufferDesc
 322  *
 323  * Returns the description of a vertex buffer
 324  *
 325  * Params:
 326  *  Desc: Address to write the description to
 327  *
 328  * Returns
 329  *  DDERR_INVALIDPARAMS if Desc is NULL
 330  *  D3D_OK on success
 331  *
 332  *****************************************************************************/
 333 static HRESULT WINAPI d3d_vertex_buffer7_GetVertexBufferDesc(IDirect3DVertexBuffer7 *iface, D3DVERTEXBUFFERDESC *desc)
 334 {
 335     struct d3d_vertex_buffer *buffer = impl_from_IDirect3DVertexBuffer7(iface);
 336     struct wined3d_resource_desc wined3d_desc;
 337     struct wined3d_resource *wined3d_resource;
 338
 339     TRACE("iface %p, desc %p.\n", iface, desc);
 340
 341     if (!desc) return DDERR_INVALIDPARAMS;
 342
 343     wined3d_mutex_lock();
 344     wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
 345     wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);
 346     wined3d_mutex_unlock();
 347
 348     /* Now fill the desc structure */
 349     desc->dwCaps = buffer->Caps;
 350     desc->dwFVF = buffer->fvf;
 351     desc->dwNumVertices = wined3d_desc.size / get_flexible_vertex_size(buffer->fvf);
 352
 353     return D3D_OK;
 354 }
 355
 356 /*****************************************************************************
 357  * IDirect3DVertexBuffer7::Optimize
 358  *
 359  * Converts an unoptimized vertex buffer into an optimized buffer
 360  *
 361  * Params:
 362  *  D3DDevice: Device for which this buffer is optimized
 363  *  Flags: Not used, should be set to 0
 364  *
 365  * Returns
 366  *  D3D_OK, because it's a stub
 367  *
 368  *****************************************************************************/
 369 static HRESULT WINAPI d3d_vertex_buffer7_Optimize(IDirect3DVertexBuffer7 *iface,
 370         IDirect3DDevice7 *device, DWORD flags)
 371 {
 372     struct d3d_vertex_buffer *buffer = impl_from_IDirect3DVertexBuffer7(iface);
 373     static BOOL hide = FALSE;
 374
 375     TRACE("iface %p, device %p, flags %#x.\n", iface, device, flags);
 376
 377     if (!hide)
 378     {
 379         FIXME("iface %p, device %p, flags %#x stub!\n", iface, device, flags);
 380         hide = TRUE;
 381     }
 382
 383     /* We could forward this call to WineD3D and take advantage
 384      * of it once we use OpenGL vertex buffers
 385      */
 386     wined3d_mutex_lock();
 387     buffer->Caps |= D3DVBCAPS_OPTIMIZED;
 388     wined3d_mutex_unlock();
 389
 390     return DD_OK;
 391 }
 392
 393 /*****************************************************************************
 394  * IDirect3DVertexBuffer7::ProcessVerticesStrided
 395  *
 396  * This method processes untransformed strided vertices into a processed
 397  * or optimized vertex buffer.
 398  *
 399  * For more details on the parameters, see
 400  * IDirect3DVertexBuffer7::ProcessVertices
 401  *
 402  * Params:
 403  *  VertexOp: Operations to perform
 404  *  DestIndex: Destination index to write the vertices to
 405  *  Count: Number of input vertices
 406  *  StrideData: Array containing the input vertices
 407  *  VertexTypeDesc: Vertex Description or source index?????????
 408  *  D3DDevice: IDirect3DDevice7 to use for processing
 409  *  Flags: Can be D3DPV_DONOTCOPYDATA to avoid copying unmodified vertices
 410  *
 411  * Returns
 412  *  D3D_OK on success, or DDERR_*
 413  *
 414  *****************************************************************************/
 415 static HRESULT WINAPI d3d_vertex_buffer7_ProcessVerticesStrided(IDirect3DVertexBuffer7 *iface,
 416         DWORD vertex_op, DWORD dst_idx, DWORD count, D3DDRAWPRIMITIVESTRIDEDDATA *data,
 417         DWORD fvf, IDirect3DDevice7 *device, DWORD flags)
 418 {
 419     FIXME("iface %p, vertex_op %#x, dst_idx %u, count %u, data %p, fvf %#x, device %p, flags %#x stub!\n",
 420             iface, vertex_op, dst_idx, count, data, fvf, device, flags);
 421
 422     return DD_OK;
 423 }
 424
 425 /*****************************************************************************
 426  * The VTables
 427  *****************************************************************************/
 428
 429 static const struct IDirect3DVertexBuffer7Vtbl d3d_vertex_buffer7_vtbl =
 430 {
 431     d3d_vertex_buffer7_QueryInterface,
 432     d3d_vertex_buffer7_AddRef,
 433     d3d_vertex_buffer7_Release,
 434     d3d_vertex_buffer7_Lock,
 435     d3d_vertex_buffer7_Unlock,
 436     d3d_vertex_buffer7_ProcessVertices,
 437     d3d_vertex_buffer7_GetVertexBufferDesc,
 438     d3d_vertex_buffer7_Optimize,
 439     d3d_vertex_buffer7_ProcessVerticesStrided,
 440 };
 441
 442 HRESULT d3d_vertex_buffer_create(struct d3d_vertex_buffer **vertex_buf,
 443         struct ddraw *ddraw, D3DVERTEXBUFFERDESC *desc)
 444 {
 445     struct d3d_vertex_buffer *buffer;
 446     HRESULT hr = D3D_OK;
 447
 448     TRACE("Vertex buffer description:\n");
 449     TRACE("    dwSize %u\n", desc->dwSize);
 450     TRACE("    dwCaps %#x\n", desc->dwCaps);
 451     TRACE("    FVF %#x\n", desc->dwFVF);
 452     TRACE("    dwNumVertices %u\n", desc->dwNumVertices);
 453
 454     buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*buffer));
 455     if (!buffer)
 456         return DDERR_OUTOFMEMORY;
 457
 458     buffer->IDirect3DVertexBuffer7_iface.lpVtbl = &d3d_vertex_buffer7_vtbl;
 459     buffer->ref = 1;
 460     buffer->version = ddraw->d3dversion;
 461     if (buffer->version == 7)
 462         IDirectDraw7_AddRef(&ddraw->IDirectDraw7_iface);
 463     buffer->ddraw = ddraw;
 464     buffer->Caps = desc->dwCaps;
 465     buffer->fvf = desc->dwFVF;
 466     buffer->size = get_flexible_vertex_size(desc->dwFVF) * desc->dwNumVertices;
 467
 468     wined3d_mutex_lock();
 469
 470     if (FAILED(hr = d3d_vertex_buffer_create_wined3d_buffer(buffer, FALSE, &buffer->wined3d_buffer)))
 471     {
 472         WARN("Failed to create wined3d vertex buffer, hr %#x.\n", hr);
 473         if (hr == WINED3DERR_INVALIDCALL)
 474             hr = DDERR_INVALIDPARAMS;
 475         goto end;
 476     }
 477
 478     if (!(buffer->wined3d_declaration = ddraw_find_decl(ddraw, desc->dwFVF)))
 479     {
 480         ERR("Failed to find vertex declaration for fvf %#x.\n", desc->dwFVF);
 481         wined3d_buffer_decref(buffer->wined3d_buffer);
 482         hr = DDERR_INVALIDPARAMS;
 483         goto end;
 484     }
 485     wined3d_vertex_declaration_incref(buffer->wined3d_declaration);
 486
 487 end:
 488     wined3d_mutex_unlock();
 489     if (hr == D3D_OK)
 490         *vertex_buf = buffer;
 491     else
 492         HeapFree(GetProcessHeap(), 0, buffer);
 493
 494     return hr;
 495 }
 496
 497 struct d3d_vertex_buffer *unsafe_impl_from_IDirect3DVertexBuffer7(IDirect3DVertexBuffer7 *iface)
 498 {
 499     if (!iface)
 500         return NULL;
 501     assert(iface->lpVtbl == &d3d_vertex_buffer7_vtbl);
 502
 503     return impl_from_IDirect3DVertexBuffer7(iface);
 504 }