static HRESULT STDMETHODCALLTYPE d3d10_texture3d_Map(ID3D10Texture3D *iface, UINT sub_resource_idx,
D3D10_MAP map_type, UINT map_flags, D3D10_MAPPED_TEXTURE3D *mapped_texture)
{
struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);
struct wined3d_map_desc wined3d_map_desc;
HRESULT hr;
TRACE("iface %p, sub_resource_idx %u, map_type %u, map_flags %#x, mapped_texture %p.\n",
iface, sub_resource_idx, map_type, map_flags, mapped_texture);
if (map_flags)
FIXME("Ignoring map_flags %#x.\n", map_flags);
wined3d_mutex_lock();
if (SUCCEEDED(hr = wined3d_resource_map(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx,
&wined3d_map_desc, NULL, wined3d_map_flags_from_d3d11_map_type(map_type))))
{
mapped_texture->pData = wined3d_map_desc.data;
mapped_texture->RowPitch = wined3d_map_desc.row_pitch;
mapped_texture->DepthPitch = wined3d_map_desc.slice_pitch;
}
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);
struct wined3d_map_desc wined3d_map_desc;
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_resource_map(wined3d_buffer_get_resource(buffer->wined3d_buffer), 0,
&wined3d_map_desc, NULL, wined3d_map_flags_from_d3d11_map_type(map_type));
*data = wined3d_map_desc.data;
wined3d_mutex_unlock();
return hr;
}
static HRESULT WINAPI d3d8_indexbuffer_Lock(IDirect3DIndexBuffer8 *iface, UINT offset, UINT size,
BYTE **data, DWORD flags)
{
struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
struct wined3d_map_desc wined3d_map_desc;
struct wined3d_box wined3d_box = {0};
HRESULT hr;
TRACE("iface %p, offset %u, size %u, data %p, flags %#x.\n",
iface, offset, size, data, flags);
wined3d_box.left = offset;
wined3d_box.right = offset + size;
wined3d_mutex_lock();
hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->wined3d_buffer),
0, &wined3d_map_desc, &wined3d_box, wined3dmapflags_from_d3dmapflags(flags));
wined3d_mutex_unlock();
*data = wined3d_map_desc.data;
return hr;
}
static HRESULT WINAPI d3d8_volume_LockBox(IDirect3DVolume8 *iface,
D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags)
{
struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface);
struct wined3d_map_desc map_desc;
HRESULT hr;
TRACE("iface %p, locked_box %p, box %p, flags %#x.\n",
iface, locked_box, box, flags);
wined3d_mutex_lock();
if (FAILED(hr = wined3d_resource_map(wined3d_texture_get_resource(volume->wined3d_texture),
volume->sub_resource_idx, &map_desc, (const struct wined3d_box *)box, flags)))
map_desc.data = NULL;
wined3d_mutex_unlock();
locked_box->RowPitch = map_desc.row_pitch;
locked_box->SlicePitch = map_desc.slice_pitch;
locked_box->pBits = map_desc.data;
return hr;
}
static HRESULT WINAPI d3d8_surface_LockRect(IDirect3DSurface8 *iface,
D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags)
{
struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface);
struct wined3d_box box;
struct wined3d_map_desc map_desc;
HRESULT hr;
D3DRESOURCETYPE type;
TRACE("iface %p, locked_rect %p, rect %s, flags %#x.\n",
iface, locked_rect, wine_dbgstr_rect(rect), flags);
wined3d_mutex_lock();
if (surface->texture)
type = IDirect3DBaseTexture8_GetType(&surface->texture->IDirect3DBaseTexture8_iface);
else
type = D3DRTYPE_SURFACE;
if (rect)
{
D3DSURFACE_DESC desc;
IDirect3DSurface8_GetDesc(iface, &desc);
if (type != D3DRTYPE_TEXTURE
&& ((rect->left < 0)
|| (rect->top < 0)
|| (rect->left >= rect->right)
|| (rect->top >= rect->bottom)
|| (rect->right > desc.Width)
|| (rect->bottom > desc.Height)))
{
WARN("Trying to lock an invalid rectangle, returning D3DERR_INVALIDCALL\n");
wined3d_mutex_unlock();
locked_rect->Pitch = 0;
locked_rect->pBits = NULL;
return D3DERR_INVALIDCALL;
}
wined3d_box_set(&box, rect->left, rect->top, rect->right, rect->bottom, 0, 1);
}
hr = wined3d_resource_map(wined3d_texture_get_resource(surface->wined3d_texture), surface->sub_resource_idx,
&map_desc, rect ? &box : NULL, wined3dmapflags_from_d3dmapflags(flags, 0));
wined3d_mutex_unlock();
if (SUCCEEDED(hr))
{
locked_rect->Pitch = map_desc.row_pitch;
locked_rect->pBits = map_desc.data;
}
else if (type != D3DRTYPE_TEXTURE)
{
locked_rect->Pitch = 0;
locked_rect->pBits = NULL;
}
if (hr == E_INVALIDARG)
return D3DERR_INVALIDCALL;
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;
struct wined3d_map_desc wined3d_map_desc;
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->wined3d_buffer);
buffer->wined3d_buffer = 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->wined3d_buffer);
wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);
*data_size = wined3d_desc.size;
}
hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->wined3d_buffer),
0, &wined3d_map_desc, NULL, wined3d_flags);
*data = wined3d_map_desc.data;
wined3d_mutex_unlock();
return hr;
}