ReactOS 0.4.16-dev-334-g4d9f67c
Macros | Functions | Variables
volume.c File Reference
#include "wine/test.h"
#include "d3dx9tex.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)
 

Functions

static void _check_pixel_4bpp (unsigned int line, const D3DLOCKED_BOX *box, int x, int y, int z, DWORD 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)
 

Variables

static const unsigned char dds_volume_map []
 

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 42 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 43 of file volume.c.

44{
45 DWORD color = ((DWORD *)box->pBits)[x + (y * box->RowPitch + z * box->SlicePitch) / 4];
46 ok_(__FILE__, line)(color == expected_color, "Got color 0x%08x, expected 0x%08x\n", color, expected_color);
47}
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:468
line
Definition: parser.c:49

◆ set_box()

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

Definition at line 49 of file volume.c.

50{
51 box->Left = left;
52 box->Top = top;
53 box->Right = right;
54 box->Bottom = bottom;
55 box->Front = front;
56 box->Back = back;
57}
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 266 of file volume.c.

267{
268 HWND wnd;
269 IDirect3D9 *d3d;
270 IDirect3DDevice9 *device;
271 D3DPRESENT_PARAMETERS d3dpp;
272 HRESULT hr;
273
274 if (!(wnd = CreateWindowA("static", "d3dx9_test", WS_OVERLAPPEDWINDOW, 0, 0,
275 640, 480, NULL, NULL, NULL, NULL)))
276 {
277 skip("Couldn't create application window\n");
278 return;
279 }
280 d3d = Direct3DCreate9(D3D_SDK_VERSION);
281 if (!d3d)
282 {
283 skip("Couldn't create IDirect3D9 object\n");
284 DestroyWindow(wnd);
285 return;
286 }
287
288 ZeroMemory(&d3dpp, sizeof(d3dpp));
289 d3dpp.Windowed = TRUE;
290 d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
291 hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, wnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &device);
292 if(FAILED(hr))
293 {
294 skip("Failed to create IDirect3DDevice9 object %#x\n", hr);
295 IDirect3D9_Release(d3d);
296 DestroyWindow(wnd);
297 return;
298 }
299
300 test_D3DXLoadVolumeFromMemory(device);
301 test_D3DXLoadVolumeFromFileInMemory(device);
302
303 IDirect3DDevice9_Release(device);
304 IDirect3D9_Release(d3d);
305 DestroyWindow(wnd);
306}
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:235
IDirect3D9_Release
#define IDirect3D9_Release(p)
Definition: d3d9.h:220
IDirect3DDevice9_Release
#define IDirect3DDevice9_Release(p)
Definition: d3d9.h:1508
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FAILED
#define FAILED(hr)
Definition: intsafe.h:51
test_D3DXLoadVolumeFromMemory
static void test_D3DXLoadVolumeFromMemory(IDirect3DDevice9 *device)
Definition: volume.c:59
test_D3DXLoadVolumeFromFileInMemory
static void test_D3DXLoadVolumeFromFileInMemory(IDirect3DDevice9 *device)
Definition: volume.c:214
WS_OVERLAPPEDWINDOW
#define WS_OVERLAPPEDWINDOW
Definition: pedump.c:637
D3DADAPTER_DEFAULT
#define D3DADAPTER_DEFAULT
Definition: d3d8.h:57
D3D_SDK_VERSION
#define D3D_SDK_VERSION
Definition: d3d8.h:56
D3DCREATE_SOFTWARE_VERTEXPROCESSING
#define D3DCREATE_SOFTWARE_VERTEXPROCESSING
Definition: d3d8.h:44
hr
HRESULT hr
Definition: shlfolder.c:183
_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
ZeroMemory
#define ZeroMemory
Definition: winbase.h:1737
CreateWindowA
#define CreateWindowA(a, b, c, d, e, f, g, h, i, j, k)
Definition: winuser.h:4318
DestroyWindow
BOOL WINAPI DestroyWindow(_In_ HWND)

◆ test_D3DXLoadVolumeFromFileInMemory()

static void test_D3DXLoadVolumeFromFileInMemory ( IDirect3DDevice9 *  device)
static

Definition at line 214 of file volume.c.

215{
216 HRESULT hr;
217 D3DBOX src_box;
218 IDirect3DVolume9 *volume;
219 IDirect3DVolumeTexture9 *volume_texture;
220
221 hr = IDirect3DDevice9_CreateVolumeTexture(device, 4, 4, 2, 1, D3DUSAGE_DYNAMIC, D3DFMT_DXT3, D3DPOOL_DEFAULT,
222 &volume_texture, NULL);
223 if (FAILED(hr))
224 {
225 skip("Failed to create volume texture\n");
226 return;
227 }
228
229 IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, 0, &volume);
230
231 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), NULL, D3DX_DEFAULT, 0, NULL);
232 ok(hr == D3D_OK, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
233
234 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, NULL, sizeof(dds_volume_map), NULL, D3DX_DEFAULT, 0, NULL);
235 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
236
237 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, NULL, 0, NULL, D3DX_DEFAULT, 0, NULL);
238 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
239
240 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, 0, NULL, D3DX_DEFAULT, 0, NULL);
241 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
242
243 hr = D3DXLoadVolumeFromFileInMemory(NULL, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), NULL, D3DX_DEFAULT, 0, NULL);
244 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
245
246 set_box(&src_box, 0, 0, 4, 4, 0, 2);
247 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), &src_box, D3DX_DEFAULT, 0, NULL);
248 ok(hr == D3D_OK, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
249
250 set_box(&src_box, 0, 0, 0, 0, 0, 0);
251 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), &src_box, D3DX_DEFAULT, 0, NULL);
252 ok(hr == E_FAIL, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, E_FAIL);
253
254 set_box(&src_box, 0, 0, 5, 4, 0, 2);
255 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), &src_box, D3DX_DEFAULT, 0, NULL);
256 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
257
258 set_box(&src_box, 0, 0, 4, 4, 0, 3);
259 hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), &src_box, D3DX_DEFAULT, 0, NULL);
260 ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
261
262 IDirect3DVolume9_Release(volume);
263 IDirect3DVolumeTexture9_Release(volume_texture);
264}
ok
#define ok(value,...)
Definition: atltest.h:57
D3DFMT_DXT3
@ D3DFMT_DXT3
Definition: d3d8types.h:636
D3DUSAGE_DYNAMIC
#define D3DUSAGE_DYNAMIC
Definition: d3d8types.h:99
D3DPOOL_DEFAULT
@ D3DPOOL_DEFAULT
Definition: d3d8types.h:709
IDirect3DVolumeTexture9_Release
#define IDirect3DVolumeTexture9_Release(p)
Definition: d3d9.h:1109
IDirect3DVolume9_Release
#define IDirect3DVolume9_Release(p)
Definition: d3d9.h:383
IDirect3DDevice9_CreateVolumeTexture
#define IDirect3DDevice9_CreateVolumeTexture(p, a, b, c, d, e, f, g, h, i)
Definition: d3d9.h:1531
IDirect3DVolumeTexture9_GetVolumeLevel
#define IDirect3DVolumeTexture9_GetVolumeLevel(p, a, b)
Definition: d3d9.h:1128
D3D_OK
#define D3D_OK
Definition: d3d.h:106
D3DERR_INVALIDCALL
#define D3DERR_INVALIDCALL
Definition: d3dcompiler_private.h:44
D3DX_DEFAULT
#define D3DX_DEFAULT
Definition: d3dx9.h:24
E_FAIL
#define E_FAIL
Definition: ddrawi.h:102
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:230
set_box
static void set_box(D3DBOX *box, UINT left, UINT top, UINT right, UINT bottom, UINT front, UINT back)
Definition: volume.c:49
dds_volume_map
static const unsigned char dds_volume_map[]
Definition: volume.c:26
_D3DBOX
Definition: d3d8types.h:1010

Referenced by START_TEST().

◆ test_D3DXLoadVolumeFromMemory()

static void test_D3DXLoadVolumeFromMemory ( IDirect3DDevice9 *  device)
static

Definition at line 59 of file volume.c.

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

Referenced by START_TEST().

Variable Documentation

◆ dds_volume_map

const unsigned char dds_volume_map[]
static
Initial value:
=
{
0x44,0x44,0x53,0x20,0x7c,0x00,0x00,0x00,0x07,0x10,0x8a,0x00,0x04,0x00,0x00,0x00,
0x04,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00,
0x04,0x00,0x00,0x00,0x44,0x58,0x54,0x33,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x10,0x40,0x00,
0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xef,0x87,0x0f,0x78,0x05,0x05,0x50,0x50,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xef,0x87,0x0f,0x78,0x05,0x05,0x50,0x50,
0xff,0x00,0xff,0x00,0x00,0x00,0x00,0x00,0x2f,0x7e,0xcf,0x79,0x01,0x54,0x5c,0x5c,
0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x84,0xef,0x7b,0xaa,0xab,0xab,0xab
}

Definition at line 26 of file volume.c.

Referenced by test_D3DXLoadVolumeFromFileInMemory().