void CDECL wined3d_resource_update(struct wined3d_device *device, struct wined3d_resource *resource, UINT sub_resource_idx, struct wined3d_box *box, const void *data, UINT row_pitch, UINT depth_pitch) { struct wined3d_buffer *buffer; BYTE *dest; if (resource->type != WINED3D_RTYPE_BUFFER) { FIXME("Unsuported resource type: %d\n", resource->type); return; } if (sub_resource_idx || box) { WARN("Subresource index and/or Box parameter is not supported for buffers\n"); return; } /* FIXME: should normally use the command stream here */ buffer = buffer_from_resource(resource); if (SUCCEEDED(wined3d_buffer_map(buffer, 0, 0, &dest, 0))) { memcpy(dest, data, buffer->desc.byte_width); /* FIXME: is row_pitch and depth_pitch used? */ wined3d_buffer_unmap(buffer); } }
/***************************************************************************** * IDirect3DVertexBuffer7::Lock * * Locks the vertex buffer and returns a pointer to the vertex data * Locking vertex buffers is similar to locking surfaces, because Windows * uses surfaces to store vertex data internally (According to the DX sdk) * * Params: * Flags: Locking flags. Relevant here are DDLOCK_READONLY, DDLOCK_WRITEONLY, * DDLOCK_DISCARDCONTENTS and DDLOCK_NOOVERWRITE. * Data: Returns a pointer to the vertex data * Size: Returns the size of the buffer if not NULL * * Returns: * D3D_OK on success * DDERR_INVALIDPARAMS if Data is NULL * D3DERR_VERTEXBUFFEROPTIMIZED if called on an optimized buffer(WineD3D) * *****************************************************************************/ static HRESULT WINAPI IDirect3DVertexBufferImpl_Lock(IDirect3DVertexBuffer7 *iface, DWORD Flags, void **Data, DWORD *Size) { IDirect3DVertexBufferImpl *This = impl_from_IDirect3DVertexBuffer7(iface); struct wined3d_resource_desc wined3d_desc; struct wined3d_resource *wined3d_resource; HRESULT hr; DWORD wined3d_flags = 0; TRACE("iface %p, flags %#x, data %p, data_size %p.\n", iface, Flags, Data, Size); /* Writeonly: Pointless. Event: Unsupported by native according to the sdk * nosyslock: Not applicable */ if(!(Flags & DDLOCK_WAIT)) wined3d_flags |= WINED3DLOCK_DONOTWAIT; if(Flags & DDLOCK_READONLY) wined3d_flags |= WINED3DLOCK_READONLY; if(Flags & DDLOCK_NOOVERWRITE) wined3d_flags |= WINED3DLOCK_NOOVERWRITE; if(Flags & DDLOCK_DISCARDCONTENTS) wined3d_flags |= WINED3DLOCK_DISCARD; wined3d_mutex_lock(); if(Size) { /* Get the size, for returning it, and for locking */ wined3d_resource = wined3d_buffer_get_resource(This->wineD3DVertexBuffer); wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); *Size = wined3d_desc.size; } hr = wined3d_buffer_map(This->wineD3DVertexBuffer, 0, 0, (BYTE **)Data, wined3d_flags); wined3d_mutex_unlock(); return hr; }
/***************************************************************************** * IDirect3DVertexBuffer7::Lock * * Locks the vertex buffer and returns a pointer to the vertex data * Locking vertex buffers is similar to locking surfaces, because Windows * uses surfaces to store vertex data internally (According to the DX sdk) * * Params: * Flags: Locking flags. Relevant here are DDLOCK_READONLY, DDLOCK_WRITEONLY, * DDLOCK_DISCARDCONTENTS and DDLOCK_NOOVERWRITE. * Data: Returns a pointer to the vertex data * Size: Returns the size of the buffer if not NULL * * Returns: * D3D_OK on success * DDERR_INVALIDPARAMS if Data is NULL * D3DERR_VERTEXBUFFEROPTIMIZED if called on an optimized buffer(WineD3D) * *****************************************************************************/ static HRESULT WINAPI d3d_vertex_buffer7_Lock(IDirect3DVertexBuffer7 *iface, DWORD flags, void **data, DWORD *data_size) { struct d3d_vertex_buffer *buffer = impl_from_IDirect3DVertexBuffer7(iface); struct wined3d_resource_desc wined3d_desc; struct wined3d_resource *wined3d_resource; HRESULT hr; DWORD wined3d_flags = 0; TRACE("iface %p, flags %#x, data %p, data_size %p.\n", iface, flags, data, data_size); /* Writeonly: Pointless. Event: Unsupported by native according to the sdk * nosyslock: Not applicable */ if (!(flags & DDLOCK_WAIT)) wined3d_flags |= WINED3D_MAP_DONOTWAIT; if (flags & DDLOCK_READONLY) wined3d_flags |= WINED3D_MAP_READONLY; if (flags & DDLOCK_NOOVERWRITE) wined3d_flags |= WINED3D_MAP_NOOVERWRITE; if (flags & DDLOCK_DISCARDCONTENTS) { wined3d_flags |= WINED3D_MAP_DISCARD; if (!buffer->dynamic) { struct wined3d_buffer *new_buffer; wined3d_mutex_lock(); hr = d3d_vertex_buffer_create_wined3d_buffer(buffer, TRUE, &new_buffer); if (SUCCEEDED(hr)) { buffer->dynamic = TRUE; wined3d_buffer_decref(buffer->wineD3DVertexBuffer); buffer->wineD3DVertexBuffer = new_buffer; } else { WARN("Failed to create a dynamic buffer\n"); } wined3d_mutex_unlock(); } } wined3d_mutex_lock(); if (data_size) { /* Get the size, for returning it, and for locking */ wined3d_resource = wined3d_buffer_get_resource(buffer->wineD3DVertexBuffer); wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); *data_size = wined3d_desc.size; } hr = wined3d_buffer_map(buffer->wineD3DVertexBuffer, 0, 0, (BYTE **)data, wined3d_flags); wined3d_mutex_unlock(); return hr; }
static HRESULT STDMETHODCALLTYPE d3d10_buffer_Map(ID3D10Buffer *iface, D3D10_MAP map_type, UINT map_flags, void **data) { struct d3d10_buffer *buffer = (struct d3d10_buffer *)iface; TRACE("iface %p, map_type %u, map_flags %#x, data %p.\n", iface, map_type, map_flags, data); if (map_type != D3D10_MAP_READ_WRITE) FIXME("Ignoring map_type %#x.\n", map_type); if (map_flags) FIXME("Ignoring map_flags %#x.\n", map_flags); return wined3d_buffer_map(buffer->wined3d_buffer, 0, 0, (BYTE **)data, 0); }
static HRESULT WINAPI d3d9_indexbuffer_Lock(IDirect3DIndexBuffer9 *iface, UINT offset, UINT size, void **data, DWORD flags) { IDirect3DIndexBuffer9Impl *buffer = impl_from_IDirect3DIndexBuffer9(iface); HRESULT hr; TRACE("iface %p, offset %u, size %u, data %p, flags %#x.\n", iface, offset, size, data, flags); wined3d_mutex_lock(); hr = wined3d_buffer_map(buffer->wineD3DIndexBuffer, offset, size, (BYTE **)data, flags); wined3d_mutex_unlock(); return hr; }
static HRESULT STDMETHODCALLTYPE d3d10_buffer_Map(ID3D10Buffer *iface, D3D10_MAP map_type, UINT map_flags, void **data) { struct d3d_buffer *buffer = impl_from_ID3D10Buffer(iface); HRESULT hr; TRACE("iface %p, map_type %u, map_flags %#x, data %p.\n", iface, map_type, map_flags, data); if (map_flags) FIXME("Ignoring map_flags %#x.\n", map_flags); wined3d_mutex_lock(); hr = wined3d_buffer_map(buffer->wined3d_buffer, 0, 0, (BYTE **)data, wined3d_map_flags_from_d3d11_map_type(map_type)); wined3d_mutex_unlock(); return hr; }