static HRESULT WINAPI IDirect3DVolumeTexture9Impl_UnlockBox(IDirect3DVolumeTexture9 *iface, UINT level)
{
IDirect3DVolumeTexture9Impl *texture = (IDirect3DVolumeTexture9Impl *)iface;
struct wined3d_resource *sub_resource;
HRESULT hr;
TRACE("iface %p, level %u.\n", iface, level);
wined3d_mutex_lock();
if (!(sub_resource = IWineD3DBaseTexture_GetSubResource(texture->wined3d_texture, level)))
hr = D3DERR_INVALIDCALL;
else
hr = IDirect3DVolume9_UnlockBox((IDirect3DVolume9 *)wined3d_resource_get_parent(sub_resource));
wined3d_mutex_unlock();
return hr;
}
HRESULT WINAPI D3DXLoadVolumeFromVolume(IDirect3DVolume9 *dst_volume,
const PALETTEENTRY *dst_palette,
const D3DBOX *dst_box,
IDirect3DVolume9 *src_volume,
const PALETTEENTRY *src_palette,
const D3DBOX *src_box,
DWORD filter,
D3DCOLOR color_key)
{
HRESULT hr;
D3DBOX box;
D3DVOLUME_DESC desc;
D3DLOCKED_BOX locked_box;
TRACE("(%p, %p, %p, %p, %p, %p, %#x, %#x)\n",
dst_volume, dst_palette, dst_box, src_volume, src_palette, src_box,
filter, color_key);
if (!dst_volume || !src_volume) return D3DERR_INVALIDCALL;
IDirect3DVolume9_GetDesc(src_volume, &desc);
if (!src_box)
{
box.Left = box.Top = 0;
box.Right = desc.Width;
box.Bottom = desc.Height;
box.Front = 0;
box.Back = desc.Depth;
}
else box = *src_box;
hr = IDirect3DVolume9_LockBox(src_volume, &locked_box, NULL, D3DLOCK_READONLY);
if (FAILED(hr)) return hr;
hr = D3DXLoadVolumeFromMemory(dst_volume, dst_palette, dst_box,
locked_box.pBits, desc.Format, locked_box.RowPitch, locked_box.SlicePitch,
src_palette, &box, filter, color_key);
IDirect3DVolume9_UnlockBox(src_volume);
return hr;
}
static HRESULT WINAPI d3d9_texture_3d_UnlockBox(IDirect3DVolumeTexture9 *iface, UINT level)
{
struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
struct wined3d_resource *sub_resource;
struct d3d9_volume *volume_impl;
HRESULT hr;
TRACE("iface %p, level %u.\n", iface, level);
wined3d_mutex_lock();
if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
hr = D3DERR_INVALIDCALL;
else
{
volume_impl = wined3d_resource_get_parent(sub_resource);
hr = IDirect3DVolume9_UnlockBox(&volume_impl->IDirect3DVolume9_iface);
}
wined3d_mutex_unlock();
return hr;
}
HRESULT WINAPI D3DXLoadVolumeFromMemory(IDirect3DVolume9 *dst_volume,
const PALETTEENTRY *dst_palette,
const D3DBOX *dst_box,
const void *src_memory,
D3DFORMAT src_format,
UINT src_row_pitch,
UINT src_slice_pitch,
const PALETTEENTRY *src_palette,
const D3DBOX *src_box,
DWORD filter,
D3DCOLOR color_key)
{
HRESULT hr;
D3DVOLUME_DESC desc;
D3DLOCKED_BOX locked_box;
struct volume dst_size, src_size;
const struct pixel_format_desc *src_format_desc, *dst_format_desc;
TRACE("(%p, %p, %p, %p, %#x, %u, %u, %p, %p, %x, %x)\n", dst_volume, dst_palette, dst_box,
src_memory, src_format, src_row_pitch, src_slice_pitch, src_palette, src_box,
filter, color_key);
if (!dst_volume || !src_memory || !src_box) return D3DERR_INVALIDCALL;
if (src_format == D3DFMT_UNKNOWN
|| src_box->Left >= src_box->Right
|| src_box->Top >= src_box->Bottom
|| src_box->Front >= src_box->Back)
return E_FAIL;
if (filter == D3DX_DEFAULT)
filter = D3DX_FILTER_TRIANGLE | D3DX_FILTER_DITHER;
IDirect3DVolume9_GetDesc(dst_volume, &desc);
src_size.width = src_box->Right - src_box->Left;
src_size.height = src_box->Bottom - src_box->Top;
src_size.depth = src_box->Back - src_box->Front;
if (!dst_box)
{
dst_size.width = desc.Width;
dst_size.height = desc.Height;
dst_size.depth = desc.Depth;
}
else
{
if (dst_box->Left >= dst_box->Right || dst_box->Right > desc.Width)
return D3DERR_INVALIDCALL;
if (dst_box->Top >= dst_box->Bottom || dst_box->Bottom > desc.Height)
return D3DERR_INVALIDCALL;
if (dst_box->Front >= dst_box->Back || dst_box->Back > desc.Depth)
return D3DERR_INVALIDCALL;
dst_size.width = dst_box->Right - dst_box->Left;
dst_size.height = dst_box->Bottom - dst_box->Top;
dst_size.depth = dst_box->Back - dst_box->Front;
}
src_format_desc = get_format_info(src_format);
if (src_format_desc->type == FORMAT_UNKNOWN)
return E_NOTIMPL;
dst_format_desc = get_format_info(desc.Format);
if (dst_format_desc->type == FORMAT_UNKNOWN)
return E_NOTIMPL;
if (desc.Format == src_format
&& dst_size.width == src_size.width
&& dst_size.height == src_size.height
&& dst_size.depth == src_size.depth
&& color_key == 0)
{
const BYTE *src_addr;
if (src_box->Left & (src_format_desc->block_width - 1)
|| src_box->Top & (src_format_desc->block_height - 1)
|| (src_box->Right & (src_format_desc->block_width - 1)
&& src_size.width != desc.Width)
|| (src_box->Bottom & (src_format_desc->block_height - 1)
&& src_size.height != desc.Height))
{
FIXME("Source box (%u, %u, %u, %u) is misaligned\n",
src_box->Left, src_box->Top, src_box->Right, src_box->Bottom);
return E_NOTIMPL;
}
src_addr = src_memory;
src_addr += src_box->Front * src_slice_pitch;
src_addr += (src_box->Top / src_format_desc->block_height) * src_row_pitch;
src_addr += (src_box->Left / src_format_desc->block_width) * src_format_desc->block_byte_count;
hr = IDirect3DVolume9_LockBox(dst_volume, &locked_box, dst_box, 0);
if (FAILED(hr)) return hr;
copy_pixels(src_addr, src_row_pitch, src_slice_pitch,
locked_box.pBits, locked_box.RowPitch, locked_box.SlicePitch,
&dst_size, dst_format_desc);
IDirect3DVolume9_UnlockBox(dst_volume);
}
else
{
const BYTE *src_addr;
if (((src_format_desc->type != FORMAT_ARGB) && (src_format_desc->type != FORMAT_INDEX)) ||
(dst_format_desc->type != FORMAT_ARGB))
{
FIXME("Pixel format conversion is not implemented %#x -> %#x\n",
src_format_desc->format, dst_format_desc->format);
return E_NOTIMPL;
}
src_addr = src_memory;
src_addr += src_box->Front * src_slice_pitch;
src_addr += src_box->Top * src_row_pitch;
src_addr += src_box->Left * src_format_desc->bytes_per_pixel;
hr = IDirect3DVolume9_LockBox(dst_volume, &locked_box, dst_box, 0);
if (FAILED(hr)) return hr;
if ((filter & 0xf) == D3DX_FILTER_NONE)
{
convert_argb_pixels(src_memory, src_row_pitch, src_slice_pitch, &src_size, src_format_desc,
locked_box.pBits, locked_box.RowPitch, locked_box.SlicePitch, &dst_size, dst_format_desc, color_key,
src_palette);
}
else
{
if ((filter & 0xf) != D3DX_FILTER_POINT)
FIXME("Unhandled filter %#x.\n", filter);
point_filter_argb_pixels(src_addr, src_row_pitch, src_slice_pitch, &src_size, src_format_desc,
locked_box.pBits, locked_box.RowPitch, locked_box.SlicePitch, &dst_size, dst_format_desc, color_key,
src_palette);
}
IDirect3DVolume9_UnlockBox(dst_volume);
}
return D3D_OK;
}
static void test_D3DXLoadVolumeFromMemory(IDirect3DDevice9 *device)
{
int i, x, y, z;
HRESULT hr;
D3DBOX src_box, dst_box;
D3DLOCKED_BOX locked_box;
IDirect3DVolume9 *volume;
IDirect3DVolumeTexture9 *volume_texture;
const DWORD pixels[] = { 0xc3394cf0, 0x235ae892, 0x09b197fd, 0x8dc32bf6,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0xffffffff, 0x00000000, 0xffffffff, 0x00000000 };
hr = IDirect3DDevice9_CreateVolumeTexture(device, 256, 256, 4, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT,
&volume_texture, NULL);
if (FAILED(hr))
{
skip("Failed to create volume texture\n");
return;
}
IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, 0, &volume);
set_box(&src_box, 0, 0, 4, 1, 0, 4);
set_box(&dst_box, 0, 0, 4, 1, 0, 4);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
IDirect3DVolume9_LockBox(volume, &locked_box, &dst_box, D3DLOCK_READONLY);
for (i = 0; i < 16; i++) check_pixel_4bpp(&locked_box, i % 4, 0, i / 4, pixels[i]);
IDirect3DVolume9_UnlockBox(volume);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_UNKNOWN, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == E_FAIL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, E_FAIL);
hr = D3DXLoadVolumeFromMemory(volume, NULL, NULL, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, NULL, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, NULL, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
set_box(&src_box, 0, 0, 4, 4, 0, 1);
set_box(&dst_box, 0, 0, 4, 4, 0, 1);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, sizeof(pixels), NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
IDirect3DVolume9_LockBox(volume, &locked_box, &dst_box, D3DLOCK_READONLY);
for (i = 0; i < 16; i++) check_pixel_4bpp(&locked_box, i % 4, i / 4, 0, pixels[i]);
IDirect3DVolume9_UnlockBox(volume);
hr = D3DXLoadVolumeFromMemory(volume, NULL, NULL, pixels, D3DFMT_A8R8G8B8, 16, sizeof(pixels), NULL, &src_box, D3DX_FILTER_NONE, 0);
ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
IDirect3DVolume9_LockBox(volume, &locked_box, NULL, D3DLOCK_READONLY);
for (i = 0; i < 16; i++) check_pixel_4bpp(&locked_box, i % 4, i / 4, 0, pixels[i]);
for (z = 0; z < 4; z++)
{
for (y = 0; y < 256; y++)
{
for (x = 0; x < 256; x++)
if (z != 0 || y >= 4 || x >= 4) check_pixel_4bpp(&locked_box, x, y, z, 0);
}
}
IDirect3DVolume9_UnlockBox(volume);
set_box(&src_box, 0, 0, 2, 2, 1, 2);
set_box(&dst_box, 0, 0, 2, 2, 0, 1);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 8, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
IDirect3DVolume9_LockBox(volume, &locked_box, &dst_box, D3DLOCK_READONLY);
for (i = 0; i < 4; i++) check_pixel_4bpp(&locked_box, i % 2, i / 2, 0, pixels[i + 4]);
IDirect3DVolume9_UnlockBox(volume);
set_box(&src_box, 0, 0, 2, 2, 2, 3);
set_box(&dst_box, 0, 0, 2, 2, 1, 2);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 8, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
IDirect3DVolume9_LockBox(volume, &locked_box, &dst_box, D3DLOCK_READONLY);
for (i = 0; i < 4; i++) check_pixel_4bpp(&locked_box, i % 2, i / 2, 0, pixels[i + 8]);
IDirect3DVolume9_UnlockBox(volume);
set_box(&src_box, 0, 0, 4, 1, 0, 4);
set_box(&dst_box, -1, -1, 3, 0, 0, 4);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
set_box(&dst_box, 254, 254, 258, 255, 0, 4);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
set_box(&dst_box, 4, 1, 0, 0, 0, 4);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
set_box(&dst_box, 0, 0, 0, 0, 0, 0);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
set_box(&dst_box, 0, 0, 0, 0, 0, 1);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
set_box(&dst_box, 300, 300, 300, 300, 0, 0);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
IDirect3DVolume9_Release(volume);
IDirect3DVolumeTexture9_Release(volume_texture);
hr = IDirect3DDevice9_CreateVolumeTexture(device, 256, 256, 4, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &volume_texture, NULL);
if (FAILED(hr))
{
skip("Failed to create volume texture\n");
return;
}
IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, 0, &volume);
set_box(&src_box, 0, 0, 4, 1, 0, 4);
set_box(&dst_box, 0, 0, 4, 1, 0, 4);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
IDirect3DVolume9_Release(volume);
IDirect3DVolumeTexture9_Release(volume_texture);
hr = IDirect3DDevice9_CreateVolumeTexture(device, 8, 8, 1, 1, D3DUSAGE_DYNAMIC, D3DFMT_DXT1, D3DPOOL_DEFAULT, &volume_texture, NULL);
if (FAILED(hr))
{
skip("Failed to create volume texture\n");
return;
}
IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, 0, &volume);
set_box(&src_box, 1, 1, 7, 7, 0, 1);
set_box(&dst_box, 1, 1, 7, 7, 0, 1);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 32, NULL, &src_box, D3DX_DEFAULT, 0);
todo_wine ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
IDirect3DVolume9_Release(volume);
IDirect3DVolumeTexture9_Release(volume_texture);
}