ReactOS 0.4.17-dev-1190-g4c812f4
Macros | Functions
volume.c File Reference
#include "wine/test.h"
#include "d3dx9tex.h"
#include "d3dx9_test_images.h"
Include dependency graph for volume.c:

Go to the source code of this file.

Macros

#define COBJMACROS
 
#define check_pixel_4bpp(box, x, y, z, color)   _check_pixel_4bpp(__LINE__, box, x, y, z, color)
 
#define check_pixel_8bpp(box, x, y, z, color)   _check_pixel_8bpp(__LINE__, box, x, y, z, color)
 

Functions

static void _check_pixel_4bpp (unsigned int line, const D3DLOCKED_BOX *box, int x, int y, int z, DWORD expected_color)
 
static void _check_pixel_8bpp (unsigned int line, const D3DLOCKED_BOX *box, int x, int y, int z, uint64_t expected_color)
 
static void set_box (D3DBOX *box, UINT left, UINT top, UINT right, UINT bottom, UINT front, UINT back)
 
static void test_D3DXLoadVolumeFromMemory (IDirect3DDevice9 *device)
 
static void test_D3DXLoadVolumeFromFileInMemory (IDirect3DDevice9 *device)
 
 START_TEST (volume)
 

Macro Definition Documentation

◆ check_pixel_4bpp

#define check_pixel_4bpp (   box,
  x,
  y,
  z,
  color 
)    _check_pixel_4bpp(__LINE__, box, x, y, z, color)

Definition at line 26 of file volume.c.

◆ check_pixel_8bpp

#define check_pixel_8bpp (   box,
  x,
  y,
  z,
  color 
)    _check_pixel_8bpp(__LINE__, box, x, y, z, color)

Definition at line 33 of file volume.c.

◆ COBJMACROS

#define COBJMACROS

Definition at line 21 of file volume.c.

Function Documentation

◆ _check_pixel_4bpp()

static void _check_pixel_4bpp ( unsigned int  line,
const D3DLOCKED_BOX *  box,
int  x,
int  y,
int  z,
DWORD  expected_color 
)
inlinestatic

Definition at line 27 of file volume.c.

28{
29 DWORD color = ((DWORD *)box->pBits)[x + (y * box->RowPitch + z * box->SlicePitch) / 4];
30 ok_(__FILE__, line)(color == expected_color, "Got color 0x%08lx, expected 0x%08lx\n", color, expected_color);
31}
ok_
#define ok_(x1, x2)
Definition: atltest.h:61
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
x
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
y
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
color
GLuint color
Definition: glext.h:6243
z
GLdouble GLdouble z
Definition: glext.h:5874
box
Definition: palette.c:466
line
Definition: parser.c:49

◆ _check_pixel_8bpp()

static void _check_pixel_8bpp ( unsigned int  line,
const D3DLOCKED_BOX *  box,
int  x,
int  y,
int  z,
uint64_t  expected_color 
)
inlinestatic

Definition at line 34 of file volume.c.

35{
36 uint64_t color = ((uint64_t *)box->pBits)[x + (y * box->RowPitch + z * box->SlicePitch) / 8];
37 ok_(__FILE__, line)(color == expected_color, "Got color %#I64x, expected %#I64x.\n", color, expected_color);
38}
uint64_t
UINT64 uint64_t
Definition: types.h:77

◆ set_box()

static void set_box ( D3DBOX *  box,
UINT  left,
UINT  top,
UINT  right,
UINT  bottom,
UINT  front,
UINT  back 
)
inlinestatic

Definition at line 40 of file volume.c.

41{
42 box->Left = left;
43 box->Top = top;
44 box->Right = right;
45 box->Bottom = bottom;
46 box->Front = front;
47 box->Back = back;
48}
top
GLdouble GLdouble GLdouble GLdouble top
Definition: glext.h:10859
right
GLdouble GLdouble right
Definition: glext.h:10859
left
GLint left
Definition: glext.h:7726
bottom
GLint GLint bottom
Definition: glext.h:7726
front
static struct address_cache * front
Definition: rpcb_clnt.c:83

Referenced by test_D3DXLoadVolumeFromFileInMemory(), and test_D3DXLoadVolumeFromMemory().

◆ START_TEST()

START_TEST ( volume  )

Definition at line 395 of file volume.c.

396{
397 HWND wnd;
398 IDirect3D9 *d3d;
399 IDirect3DDevice9 *device;
400 D3DPRESENT_PARAMETERS d3dpp;
401 HRESULT hr;
402
403 if (!(wnd = CreateWindowA("static", "d3dx9_test", WS_OVERLAPPEDWINDOW, 0, 0,
404 640, 480, NULL, NULL, NULL, NULL)))
405 {
406 skip("Couldn't create application window\n");
407 return;
408 }
409 d3d = Direct3DCreate9(D3D_SDK_VERSION);
410 if (!d3d)
411 {
412 skip("Couldn't create IDirect3D9 object\n");
413 DestroyWindow(wnd);
414 return;
415 }
416
417 ZeroMemory(&d3dpp, sizeof(d3dpp));
418 d3dpp.Windowed = TRUE;
419 d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
420 hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, wnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &device);
421 if(FAILED(hr))
422 {
423 skip("Failed to create IDirect3DDevice9 object %#lx\n", hr);
424 IDirect3D9_Release(d3d);
425 DestroyWindow(wnd);
426 return;
427 }
428
429 test_D3DXLoadVolumeFromMemory(device);
430 test_D3DXLoadVolumeFromFileInMemory(device);
431
432 IDirect3DDevice9_Release(device);
433 IDirect3D9_Release(d3d);
434 DestroyWindow(wnd);
435}
skip
#define skip(...)
Definition: atltest.h:64
D3DSWAPEFFECT_DISCARD
@ D3DSWAPEFFECT_DISCARD
Definition: d3d8types.h:851
D3DDEVTYPE_HAL
@ D3DDEVTYPE_HAL
Definition: d3d8types.h:576
Direct3DCreate9
IDirect3D9 *WINAPI Direct3DCreate9(UINT SDKVersion)
Definition: d3d9.c:57
IDirect3D9_CreateDevice
#define IDirect3D9_CreateDevice(p, a, b, c, d, e, f)
Definition: d3d9.h:224
IDirect3D9_Release
#define IDirect3D9_Release(p)
Definition: d3d9.h:209
IDirect3DDevice9_Release
#define IDirect3DDevice9_Release(p)
Definition: d3d9.h:1336
hr
HRESULT hr
Definition: delayimp.cpp:582
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
IDirect3DDevice9
DWORD IDirect3DDevice9
Definition: dxva2api.idl:22
FAILED
#define FAILED(hr)
Definition: intsafe.h:51
ZeroMemory
#define ZeroMemory
Definition: minwinbase.h:31
test_D3DXLoadVolumeFromMemory
static void test_D3DXLoadVolumeFromMemory(IDirect3DDevice9 *device)
Definition: volume.c:50
test_D3DXLoadVolumeFromFileInMemory
static void test_D3DXLoadVolumeFromFileInMemory(IDirect3DDevice9 *device)
Definition: volume.c:216
WS_OVERLAPPEDWINDOW
#define WS_OVERLAPPEDWINDOW
Definition: pedump.c:637
CreateWindowA
#define CreateWindowA(a, b, c, d, e, f, g, h, i, j, k)
Definition: winuser.h:4469
DestroyWindow
BOOL WINAPI DestroyWindow(_In_ HWND)
D3DADAPTER_DEFAULT
#define D3DADAPTER_DEFAULT
Definition: d3d8.h:53
D3D_SDK_VERSION
#define D3D_SDK_VERSION
Definition: d3d8.h:52
D3DCREATE_SOFTWARE_VERTEXPROCESSING
#define D3DCREATE_SOFTWARE_VERTEXPROCESSING
Definition: d3d8.h:40
_D3DPRESENT_PARAMETERS_
Definition: d3d8types.h:1120
_D3DPRESENT_PARAMETERS_::SwapEffect
D3DSWAPEFFECT SwapEffect
Definition: d3d8types.h:1128
_D3DPRESENT_PARAMETERS_::Windowed
BOOL Windowed
Definition: d3d8types.h:1130
device
Definition: devices.h:37

◆ test_D3DXLoadVolumeFromFileInMemory()

static void test_D3DXLoadVolumeFromFileInMemory ( IDirect3DDevice9 *  device)
static

Definition at line 216 of file volume.c.

217{
218 HRESULT hr;
219 D3DBOX src_box;
220 uint32_t x, y, z, i;
221 D3DVOLUME_DESC desc;
222 D3DXIMAGE_INFO img_info;
223 IDirect3DVolume9 *volume;
224 D3DLOCKED_BOX locked_box;
225 struct volume_readback volume_rb;
226 IDirect3DVolumeTexture9 *volume_texture;
227 static const uint32_t bmp_32bpp_4_4_argb_expected[] =
228 {
229 0xffff0000, 0xff00ff00, 0xff0000ff, 0xff000000,
230 };
231
232 hr = IDirect3DDevice9_CreateVolumeTexture(device, 4, 4, 2, 1, D3DUSAGE_DYNAMIC, D3DFMT_DXT3, D3DPOOL_DEFAULT,
233 &volume_texture, NULL);
234 if (FAILED(hr))
235 {
236 skip("Failed to create volume texture\n");
237 return;
238 }
239
240 IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, 0, &volume);
241
242 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), NULL, D3DX_DEFAULT, 0, NULL);
243 ok(hr == D3D_OK, "D3DXLoadVolumeFromFileInMemory returned %#lx, expected %#lx\n", hr, D3D_OK);
244
245 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, NULL, sizeof(dds_volume_map), NULL, D3DX_DEFAULT, 0, NULL);
246 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#lx, expected %#lx\n", hr, D3DERR_INVALIDCALL);
247
248 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, NULL, 0, NULL, D3DX_DEFAULT, 0, NULL);
249 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#lx, expected %#lx\n", hr, D3DERR_INVALIDCALL);
250
251 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, 0, NULL, D3DX_DEFAULT, 0, NULL);
252 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#lx, expected %#lx\n", hr, D3DERR_INVALIDCALL);
253
254 hr = D3DXLoadVolumeFromFileInMemory(NULL, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), NULL, D3DX_DEFAULT, 0, NULL);
255 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#lx, expected %#lx\n", hr, D3DERR_INVALIDCALL);
256
257 set_box(&src_box, 0, 0, 4, 4, 0, 2);
258 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), &src_box, D3DX_DEFAULT, 0, NULL);
259 ok(hr == D3D_OK, "D3DXLoadVolumeFromFileInMemory returned %#lx, expected %#lx\n", hr, D3D_OK);
260
261 set_box(&src_box, 0, 0, 0, 0, 0, 0);
262 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), &src_box, D3DX_DEFAULT, 0, NULL);
263 ok(hr == E_FAIL, "D3DXLoadVolumeFromFileInMemory returned %#lx, expected %#lx\n", hr, E_FAIL);
264
265 set_box(&src_box, 0, 0, 5, 4, 0, 2);
266 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), &src_box, D3DX_DEFAULT, 0, NULL);
267 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#lx, expected %#lx\n", hr, D3DERR_INVALIDCALL);
268
269 set_box(&src_box, 0, 0, 4, 4, 0, 3);
270 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), &src_box, D3DX_DEFAULT, 0, NULL);
271 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#lx, expected %#lx\n", hr, D3DERR_INVALIDCALL);
272
273 IDirect3DVolume9_Release(volume);
274 IDirect3DVolumeTexture9_Release(volume_texture);
275
276 /* Load 2D DDS image into a volume. */
277 hr = IDirect3DDevice9_CreateVolumeTexture(device, 8, 8, 8, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT,
278 &volume_texture, NULL);
279 ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
280
281 IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, 0, &volume);
282 for (i = 0; i < ARRAY_SIZE(test_filter_values); ++i)
283 {
284 winetest_push_context("Filter %d (%#x)", i, test_filter_values[i].filter);
285
286 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_24bit_8_8, sizeof(dds_24bit_8_8), NULL,
287 test_filter_values[i].filter, 0, NULL);
288 ok(hr == test_filter_values[i].expected_hr, "Unexpected hr %#lx.\n", hr);
289
290 winetest_pop_context();
291 }
292
293 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_24bit_8_8, sizeof(dds_24bit_8_8), NULL,
294 D3DX_FILTER_POINT, 0, &img_info);
295 ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
296 check_image_info(&img_info, 8, 8, 1, 4, D3DFMT_R8G8B8, D3DRTYPE_TEXTURE, D3DXIFF_DDS, FALSE);
297
298 IDirect3DVolumeTexture9_GetLevelDesc(volume_texture, 0, &desc);
299 get_texture_volume_readback(device, volume_texture, 0, &volume_rb);
300 for (z = 0; z < desc.Depth; ++z)
301 {
302 for (y = 0; y < desc.Height; ++y)
303 {
304 for (x = 0; x < desc.Width; ++x)
305 {
306 check_volume_readback_pixel_4bpp(&volume_rb, x, y, z, 0xffff0000, FALSE);
307 }
308 }
309 }
310 release_volume_readback(&volume_rb);
311
312 IDirect3DVolume9_Release(volume);
313 IDirect3DVolumeTexture9_Release(volume_texture);
314
315 /* Load a BMP image into a volume. */
316 hr = IDirect3DDevice9_CreateVolumeTexture(device, 4, 4, 4, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT,
317 &volume_texture, NULL);
318 ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
319
320 IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, 0, &volume);
321 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, bmp_32bpp_4_4_argb, sizeof(bmp_32bpp_4_4_argb), NULL,
322 D3DX_FILTER_POINT, 0, &img_info);
323 ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
324 check_image_info(&img_info, 4, 4, 1, 1, D3DFMT_A8R8G8B8, D3DRTYPE_TEXTURE, D3DXIFF_BMP, FALSE);
325
326 IDirect3DVolumeTexture9_GetLevelDesc(volume_texture, 0, &desc);
327 get_texture_volume_readback(device, volume_texture, 0, &volume_rb);
328 for (z = 0; z < desc.Depth; ++z)
329 {
330 for (y = 0; y < desc.Height; ++y)
331 {
332 const uint32_t *expected_color = &bmp_32bpp_4_4_argb_expected[(y < (desc.Height / 2)) ? 0 : 2];
333
334 for (x = 0; x < desc.Width; ++x)
335 {
336 if (x < (desc.Width / 2))
337 check_volume_readback_pixel_4bpp(&volume_rb, x, y, z, expected_color[0], FALSE);
338 else
339 check_volume_readback_pixel_4bpp(&volume_rb, x, y, z, expected_color[1], FALSE);
340 }
341 }
342 }
343 release_volume_readback(&volume_rb);
344
345 IDirect3DVolume9_Release(volume);
346 IDirect3DVolumeTexture9_Release(volume_texture);
347
348 /* PNG tests. */
349 hr = IDirect3DDevice9_CreateVolumeTexture(device, 2, 2, 2, 1, D3DUSAGE_DYNAMIC, D3DFMT_A16B16G16R16, D3DPOOL_DEFAULT,
350 &volume_texture, NULL);
351 if (FAILED(hr))
352 {
353 skip("Failed to create volume texture\n");
354 return;
355 }
356
357 IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, 0, &volume);
358
359 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, png_2_2_48bpp_rgb, sizeof(png_2_2_48bpp_rgb), NULL,
360 D3DX_FILTER_POINT, 0, NULL);
361 ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
362
363 IDirect3DVolume9_LockBox(volume, &locked_box, NULL, D3DLOCK_READONLY);
364
365 for (i = 0; i < 2; ++i)
366 {
367 check_pixel_8bpp(&locked_box, 0, 0, i, 0xffff202010100000);
368 check_pixel_8bpp(&locked_box, 1, 0, i, 0xffff505040403030);
369 check_pixel_8bpp(&locked_box, 0, 1, i, 0xffff808070706060);
370 check_pixel_8bpp(&locked_box, 1, 1, i, 0xffffb0b0a0a09090);
371 }
372
373 IDirect3DVolume9_UnlockBox(volume);
374
375 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, png_2_2_64bpp_rgba, sizeof(png_2_2_64bpp_rgba), NULL,
376 D3DX_FILTER_POINT, 0, NULL);
377 ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
378
379 IDirect3DVolume9_LockBox(volume, &locked_box, NULL, D3DLOCK_READONLY);
380
381 for (i = 0; i < 2; ++i)
382 {
383 check_pixel_8bpp(&locked_box, 0, 0, i, 0x3030202010100000);
384 check_pixel_8bpp(&locked_box, 1, 0, i, 0x7070606050504040);
385 check_pixel_8bpp(&locked_box, 0, 1, i, 0xb0b0a0a090908080);
386 check_pixel_8bpp(&locked_box, 1, 1, i, 0xf0f0e0e0d0d0c0c0);
387 }
388
389 IDirect3DVolume9_UnlockBox(volume);
390
391 IDirect3DVolume9_Release(volume);
392 IDirect3DVolumeTexture9_Release(volume_texture);
393}
ok
#define ok(value,...)
Definition: atltest.h:57
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
D3DERR_INVALIDCALL
#define D3DERR_INVALIDCALL
Definition: d3d10_private.h:42
D3DFMT_R8G8B8
@ D3DFMT_R8G8B8
Definition: d3d8types.h:603
D3DFMT_A8R8G8B8
@ D3DFMT_A8R8G8B8
Definition: d3d8types.h:604
D3DFMT_DXT3
@ D3DFMT_DXT3
Definition: d3d8types.h:636
D3DUSAGE_DYNAMIC
#define D3DUSAGE_DYNAMIC
Definition: d3d8types.h:99
D3DRTYPE_TEXTURE
@ D3DRTYPE_TEXTURE
Definition: d3d8types.h:812
D3DPOOL_DEFAULT
@ D3DPOOL_DEFAULT
Definition: d3d8types.h:709
D3DLOCK_READONLY
#define D3DLOCK_READONLY
Definition: d3d8types.h:69
IDirect3DVolumeTexture9_GetLevelDesc
#define IDirect3DVolumeTexture9_GetLevelDesc(p, a, b)
Definition: d3d9.h:955
IDirect3DVolumeTexture9_Release
#define IDirect3DVolumeTexture9_Release(p)
Definition: d3d9.h:937
IDirect3DVolume9_UnlockBox
#define IDirect3DVolume9_UnlockBox(p)
Definition: d3d9.h:286
IDirect3DVolume9_LockBox
#define IDirect3DVolume9_LockBox(p, a, b, c)
Definition: d3d9.h:285
IDirect3DVolume9_Release
#define IDirect3DVolume9_Release(p)
Definition: d3d9.h:277
IDirect3DDevice9_CreateVolumeTexture
#define IDirect3DDevice9_CreateVolumeTexture(p, a, b, c, d, e, f, g, h, i)
Definition: d3d9.h:1359
IDirect3DVolumeTexture9_GetVolumeLevel
#define IDirect3DVolumeTexture9_GetVolumeLevel(p, a, b)
Definition: d3d9.h:956
D3DFMT_A16B16G16R16
@ D3DFMT_A16B16G16R16
Definition: d3d9types.h:806
D3D_OK
#define D3D_OK
Definition: d3d.h:106
check_volume_readback_pixel_4bpp
#define check_volume_readback_pixel_4bpp(rb, x, y, z, color, todo)
Definition: d3dx9_test_images.h:900
bmp_32bpp_4_4_argb
static const uint8_t bmp_32bpp_4_4_argb[]
Definition: d3dx9_test_images.h:115
check_image_info
#define check_image_info(info, width, height, depth, mip_levels, format, resource_type, image_file_format, wine_todo)
Definition: d3dx9_test_images.h:775
dds_24bit_8_8
static const uint8_t dds_24bit_8_8[]
Definition: d3dx9_test_images.h:671
get_texture_volume_readback
#define get_texture_volume_readback(device, volume_tex, mip_level, rb)
Definition: d3dx9_test_images.h:837
png_2_2_64bpp_rgba
static const uint8_t png_2_2_64bpp_rgba[]
Definition: d3dx9_test_images.h:155
png_2_2_48bpp_rgb
static const uint8_t png_2_2_48bpp_rgb[]
Definition: d3dx9_test_images.h:145
dds_volume_map
static const uint8_t dds_volume_map[]
Definition: d3dx9_test_images.h:549
test_filter_values
static const struct @1926 test_filter_values[]
release_volume_readback
#define release_volume_readback(rb)
Definition: d3dx9_test_images.h:825
expected_hr
HRESULT expected_hr
Definition: d3dx9_test_images.h:29
E_FAIL
#define E_FAIL
Definition: ddrawi.h:102
FALSE
#define FALSE
Definition: types.h:117
uint32_t
UINT32 uint32_t
Definition: types.h:75
D3DXLoadVolumeFromFileInMemory
HRESULT WINAPI D3DXLoadVolumeFromFileInMemory(IDirect3DVolume9 *dst_volume, const PALETTEENTRY *dst_palette, const D3DBOX *dst_box, const void *src_data, UINT src_data_size, const D3DBOX *src_box, DWORD filter, D3DCOLOR color_key, D3DXIMAGE_INFO *src_info)
Definition: volume.c:179
D3DXIFF_DDS
@ D3DXIFF_DDS
Definition: dx8vb.idl:66
D3DXIFF_BMP
@ D3DXIFF_BMP
Definition: dx8vb.idl:62
D3DX_DEFAULT
#define D3DX_DEFAULT
Definition: d3dx9.h:24
D3DX_FILTER_POINT
#define D3DX_FILTER_POINT
Definition: d3dx9tex.h:28
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
winetest_pop_context
void __cdecl void __cdecl void __cdecl void __cdecl void __cdecl void winetest_pop_context(void)
winetest_push_context
void __cdecl void __cdecl void __cdecl void __cdecl void __cdecl winetest_push_context(const char *fmt,...) __WINE_PRINTF_ATTR(1
Definition: test.h:539
desc
D3D11_SHADER_VARIABLE_DESC desc
Definition: reflection.c:1683
set_box
static void set_box(D3DBOX *box, UINT left, UINT top, UINT right, UINT bottom, UINT front, UINT back)
Definition: volume.c:40
check_pixel_8bpp
#define check_pixel_8bpp(box, x, y, z, color)
Definition: volume.c:33
_D3DBOX
Definition: d3d8types.h:1010
_D3DLOCKED_BOX
Definition: d3d8types.h:1089
_D3DVOLUME_DESC
Definition: d3d8types.h:1205
_D3DXIMAGE_INFO
Definition: d3dx9tex.h:77
filter
Definition: filter.c:165
volume_readback
Definition: d3dx9_test_images.h:810
volume_readback::locked_box
D3DLOCKED_BOX locked_box
Definition: d3dx9_test_images.h:812

Referenced by START_TEST().

◆ test_D3DXLoadVolumeFromMemory()

static void test_D3DXLoadVolumeFromMemory ( IDirect3DDevice9 *  device)
static

Definition at line 50 of file volume.c.

51{
52 int i, x, y, z;
53 HRESULT hr;
54 D3DBOX src_box, dst_box;
55 D3DLOCKED_BOX locked_box;
56 IDirect3DVolume9 *volume;
57 IDirect3DVolumeTexture9 *volume_texture;
58 const DWORD pixels[] = { 0xc3394cf0, 0x235ae892, 0x09b197fd, 0x8dc32bf6,
59 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
60 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
61 0xffffffff, 0x00000000, 0xffffffff, 0x00000000 };
62
63 hr = IDirect3DDevice9_CreateVolumeTexture(device, 256, 256, 4, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT,
64 &volume_texture, NULL);
65 if (FAILED(hr))
66 {
67 skip("Failed to create volume texture.\n");
68 return;
69 }
70
71 IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, 0, &volume);
72
73 set_box(&src_box, 0, 0, 4, 1, 0, 4);
74 set_box(&dst_box, 0, 0, 4, 1, 0, 4);
75
76 hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
77 if (FAILED(hr))
78 {
79 win_skip("D3DXLoadVolumeFromMemory failed with error %#lx, skipping some tests.\n", hr);
80 return;
81 }
82
83 IDirect3DVolume9_LockBox(volume, &locked_box, &dst_box, D3DLOCK_READONLY);
84 for (i = 0; i < 16; i++) check_pixel_4bpp(&locked_box, i % 4, 0, i / 4, pixels[i]);
85 IDirect3DVolume9_UnlockBox(volume);
86
87 hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_UNKNOWN, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
88 ok(hr == E_FAIL, "D3DXLoadVolumeFromMemory returned %#lx, expected %#lx\n", hr, E_FAIL);
89
90 hr = D3DXLoadVolumeFromMemory(volume, NULL, NULL, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
91 ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#lx, expected %#lx\n", hr, D3D_OK);
92
93 hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, NULL, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
94 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#lx, expected %#lx\n", hr, D3DERR_INVALIDCALL);
95
96 hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, NULL, D3DX_DEFAULT, 0);
97 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#lx, expected %#lx\n", hr, D3DERR_INVALIDCALL);
98
99 set_box(&src_box, 0, 0, 4, 4, 0, 1);
100 set_box(&dst_box, 0, 0, 4, 4, 0, 1);
101 hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, sizeof(pixels), NULL, &src_box, D3DX_DEFAULT, 0);
102 ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#lx, expected %#lx\n", hr, D3D_OK);
103
104 IDirect3DVolume9_LockBox(volume, &locked_box, &dst_box, D3DLOCK_READONLY);
105 for (i = 0; i < 16; i++) check_pixel_4bpp(&locked_box, i % 4, i / 4, 0, pixels[i]);
106 IDirect3DVolume9_UnlockBox(volume);
107
108 hr = D3DXLoadVolumeFromMemory(volume, NULL, NULL, pixels, D3DFMT_A8R8G8B8, 16, sizeof(pixels), NULL, &src_box, D3DX_FILTER_NONE, 0);
109 ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#lx, expected %#lx\n", hr, D3D_OK);
110
111 IDirect3DVolume9_LockBox(volume, &locked_box, NULL, D3DLOCK_READONLY);
112 for (i = 0; i < 16; i++) check_pixel_4bpp(&locked_box, i % 4, i / 4, 0, pixels[i]);
113 for (z = 0; z < 4; z++)
114 {
115 for (y = 0; y < 256; y++)
116 {
117 for (x = 0; x < 256; x++)
118 if (z != 0 || y >= 4 || x >= 4) check_pixel_4bpp(&locked_box, x, y, z, 0);
119 }
120 }
121 IDirect3DVolume9_UnlockBox(volume);
122
123 set_box(&src_box, 0, 0, 2, 2, 1, 2);
124 set_box(&dst_box, 0, 0, 2, 2, 0, 1);
125 hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 8, 16, NULL, &src_box, D3DX_DEFAULT, 0);
126 ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#lx, expected %#lx\n", hr, D3D_OK);
127
128 IDirect3DVolume9_LockBox(volume, &locked_box, &dst_box, D3DLOCK_READONLY);
129 for (i = 0; i < 4; i++) check_pixel_4bpp(&locked_box, i % 2, i / 2, 0, pixels[i + 4]);
130 IDirect3DVolume9_UnlockBox(volume);
131
132 set_box(&src_box, 0, 0, 2, 2, 2, 3);
133 set_box(&dst_box, 0, 0, 2, 2, 1, 2);
134 hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 8, 16, NULL, &src_box, D3DX_DEFAULT, 0);
135 ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#lx, expected %#lx\n", hr, D3D_OK);
136
137 IDirect3DVolume9_LockBox(volume, &locked_box, &dst_box, D3DLOCK_READONLY);
138 for (i = 0; i < 4; i++) check_pixel_4bpp(&locked_box, i % 2, i / 2, 0, pixels[i + 8]);
139 IDirect3DVolume9_UnlockBox(volume);
140
141 set_box(&src_box, 0, 0, 4, 1, 0, 4);
142
143 set_box(&dst_box, -1, -1, 3, 0, 0, 4);
144 hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
145 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#lx, expected %#lx\n", hr, D3DERR_INVALIDCALL);
146
147 set_box(&dst_box, 254, 254, 258, 255, 0, 4);
148 hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
149 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#lx, expected %#lx\n", hr, D3DERR_INVALIDCALL);
150
151 set_box(&dst_box, 4, 1, 0, 0, 0, 4);
152 hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
153 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#lx, expected %#lx\n", hr, D3DERR_INVALIDCALL);
154
155 set_box(&dst_box, 0, 0, 0, 0, 0, 0);
156 hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
157 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#lx, expected %#lx\n", hr, D3DERR_INVALIDCALL);
158
159 set_box(&dst_box, 0, 0, 0, 0, 0, 1);
160 hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
161 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#lx, expected %#lx\n", hr, D3DERR_INVALIDCALL);
162
163 set_box(&dst_box, 300, 300, 300, 300, 0, 0);
164 hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
165 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#lx, expected %#lx\n", hr, D3DERR_INVALIDCALL);
166
167 IDirect3DVolume9_Release(volume);
168 IDirect3DVolumeTexture9_Release(volume_texture);
169
170 hr = IDirect3DDevice9_CreateVolumeTexture(device, 256, 256, 4, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &volume_texture, NULL);
171 if (FAILED(hr))
172 {
173 skip("Failed to create volume texture\n");
174 return;
175 }
176
177 IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, 0, &volume);
178
179 set_box(&src_box, 0, 0, 4, 1, 0, 4);
180 set_box(&dst_box, 0, 0, 4, 1, 0, 4);
181 hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
182 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#lx, expected %#lx\n", hr, D3DERR_INVALIDCALL);
183
184 IDirect3DVolume9_Release(volume);
185 IDirect3DVolumeTexture9_Release(volume_texture);
186
187 hr = IDirect3DDevice9_CreateVolumeTexture(device, 8, 8, 1, 1, D3DUSAGE_DYNAMIC, D3DFMT_DXT1, D3DPOOL_DEFAULT, &volume_texture, NULL);
188 if (FAILED(hr))
189 {
190 skip("Failed to create volume texture\n");
191 return;
192 }
193
194 IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, 0, &volume);
195
196 set_box(&src_box, 1, 1, 7, 7, 0, 1);
197 set_box(&dst_box, 1, 1, 7, 7, 0, 1);
198 hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 32, NULL, &src_box, D3DX_DEFAULT, 0);
199 ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#lx, expected %#lx\n", hr, D3D_OK);
200
201 for (i = 0; i < ARRAY_SIZE(test_filter_values); ++i)
202 {
203 winetest_push_context("Filter %d (%#x)", i, test_filter_values[i].filter);
204
205 hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 32, NULL, &src_box,
206 test_filter_values[i].filter, 0);
207 ok(hr == test_filter_values[i].expected_hr, "Unexpected hr %#lx.\n", hr);
208
209 winetest_pop_context();
210 }
211
212 IDirect3DVolume9_Release(volume);
213 IDirect3DVolumeTexture9_Release(volume_texture);
214}
D3DFMT_DXT1
@ D3DFMT_DXT1
Definition: d3d8types.h:634
D3DFMT_UNKNOWN
@ D3DFMT_UNKNOWN
Definition: d3d8types.h:601
D3DXLoadVolumeFromMemory
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)
Definition: volume.c:146
D3DX_FILTER_NONE
#define D3DX_FILTER_NONE
Definition: d3dx9tex.h:27
pixels
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: gl.h:1546
win_skip
#define win_skip
Definition: minitest.h:67
check_pixel_4bpp
#define check_pixel_4bpp(box, x, y, z, color)
Definition: volume.c:26

Referenced by START_TEST().