system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-10-06 08:54:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

d3d8: Build without -DWINE_NO_LONG_TYPES.

Browse source
This commit is contained in:
Zebediah Figura 2022-09-17 23:32:00 -05:00 committed by Alexandre Julliard
parent 11f00e8457
commit 52c35814be
10 changed files with 159 additions and 165 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
dlls/d3d8/Makefile.in
View file

@ -1,4 +1,3 @@
EXTRADEFS = -DWINE_NO_LONG_TYPES
MODULE = d3d8.dll
IMPORTLIB = d3d8
IMPORTS = dxguid uuid wined3d

24
dlls/d3d8/buffer.c
View file

@ -49,7 +49,7 @@ static ULONG WINAPI d3d8_vertexbuffer_AddRef(IDirect3DVertexBuffer8 *iface)
struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
ULONG refcount = InterlockedIncrement(&buffer->resource.refcount);
TRACE("%p increasing refcount to %u.\n", iface, refcount);
TRACE("%p increasing refcount to %lu.\n", iface, refcount);
if (refcount == 1)
{
@ -68,7 +68,7 @@ static ULONG WINAPI d3d8_vertexbuffer_Release(IDirect3DVertexBuffer8 *iface)
struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
ULONG refcount = InterlockedDecrement(&buffer->resource.refcount);
TRACE("%p decreasing refcount to %u.\n", iface, refcount);
TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
if (!refcount)
{
@ -106,7 +106,7 @@ static HRESULT WINAPI d3d8_vertexbuffer_SetPrivateData(IDirect3DVertexBuffer8 *i
REFGUID guid, const void *data, DWORD data_size, DWORD flags)
{
struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface);
TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
TRACE("iface %p, guid %s, data %p, data_size %lu, flags %#lx.\n",
iface, debugstr_guid(guid), data, data_size, flags);
return d3d8_resource_set_private_data(&buffer->resource, guid, data, data_size, flags);
@ -136,7 +136,7 @@ static DWORD WINAPI d3d8_vertexbuffer_SetPriority(IDirect3DVertexBuffer8 *iface,
struct wined3d_resource *resource;
DWORD previous;
TRACE("iface %p, priority %u.\n", iface, priority);
TRACE("iface %p, priority %lu.\n", iface, priority);
wined3d_mutex_lock();
resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
@ -189,7 +189,7 @@ static HRESULT WINAPI d3d8_vertexbuffer_Lock(IDirect3DVertexBuffer8 *iface, UINT
struct wined3d_box wined3d_box = {0};
HRESULT hr;
TRACE("iface %p, offset %u, size %u, data %p, flags %#x.\n",
TRACE("iface %p, offset %u, size %u, data %p, flags %#lx.\n",
iface, offset, size, data, flags);
wined3d_box.left = offset;
@ -324,7 +324,7 @@ HRESULT vertexbuffer_init(struct d3d8_vertexbuffer *buffer, struct d3d8_device *
wined3d_mutex_unlock();
if (FAILED(hr))
{
WARN("Failed to create wined3d buffer, hr %#x.\n", hr);
WARN("Failed to create wined3d buffer, hr %#lx.\n", hr);
return hr;
}
@ -372,7 +372,7 @@ static ULONG WINAPI d3d8_indexbuffer_AddRef(IDirect3DIndexBuffer8 *iface)
struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
ULONG refcount = InterlockedIncrement(&buffer->resource.refcount);
TRACE("%p increasing refcount to %u.\n", iface, refcount);
TRACE("%p increasing refcount to %lu.\n", iface, refcount);
if (refcount == 1)
{
@ -388,7 +388,7 @@ static ULONG WINAPI d3d8_indexbuffer_Release(IDirect3DIndexBuffer8 *iface)
struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
ULONG refcount = InterlockedDecrement(&buffer->resource.refcount);
TRACE("%p decreasing refcount to %u.\n", iface, refcount);
TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
if (!refcount)
{
@ -422,7 +422,7 @@ static HRESULT WINAPI d3d8_indexbuffer_SetPrivateData(IDirect3DIndexBuffer8 *ifa
REFGUID guid, const void *data, DWORD data_size, DWORD flags)
{
struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface);
TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
TRACE("iface %p, guid %s, data %p, data_size %lu, flags %#lx.\n",
iface, debugstr_guid(guid), data, data_size, flags);
return d3d8_resource_set_private_data(&buffer->resource, guid, data, data_size, flags);
@ -452,7 +452,7 @@ static DWORD WINAPI d3d8_indexbuffer_SetPriority(IDirect3DIndexBuffer8 *iface, D
struct wined3d_resource *resource;
DWORD previous;
TRACE("iface %p, priority %u.\n", iface, priority);
TRACE("iface %p, priority %lu.\n", iface, priority);
wined3d_mutex_lock();
resource = wined3d_buffer_get_resource(buffer->wined3d_buffer);
@ -505,7 +505,7 @@ static HRESULT WINAPI d3d8_indexbuffer_Lock(IDirect3DIndexBuffer8 *iface, UINT o
struct wined3d_box wined3d_box = {0};
HRESULT hr;
TRACE("iface %p, offset %u, size %u, data %p, flags %#x.\n",
TRACE("iface %p, offset %u, size %u, data %p, flags %#lx.\n",
iface, offset, size, data, flags);
wined3d_box.left = offset;
@ -624,7 +624,7 @@ HRESULT indexbuffer_init(struct d3d8_indexbuffer *buffer, struct d3d8_device *de
wined3d_mutex_unlock();
if (FAILED(hr))
{
WARN("Failed to create wined3d buffer, hr %#x.\n", hr);
WARN("Failed to create wined3d buffer, hr %#lx.\n", hr);
return hr;
}

186
dlls/d3d8/device.c
View file

@ -251,7 +251,7 @@ static enum wined3d_swap_interval wined3dswapinterval_from_d3d(DWORD interval)
case D3DPRESENT_INTERVAL_FOUR:
return WINED3D_SWAP_INTERVAL_FOUR;
default:
FIXME("Unhandled presentation interval %#x.\n", interval);
FIXME("Unhandled presentation interval %#lx.\n", interval);
case D3DPRESENT_INTERVAL_DEFAULT:
return WINED3D_SWAP_INTERVAL_DEFAULT;
}
@ -313,7 +313,7 @@ static BOOL wined3d_swapchain_desc_from_d3d8(struct wined3d_swapchain_desc *swap
swapchain_desc->auto_restore_display_mode = TRUE;
if (present_parameters->Flags & ~D3DPRESENTFLAGS_MASK)
FIXME("Unhandled flags %#x.\n", present_parameters->Flags & ~D3DPRESENTFLAGS_MASK);
FIXME("Unhandled flags %#lx.\n", present_parameters->Flags & ~D3DPRESENTFLAGS_MASK);
return TRUE;
}
@ -478,7 +478,7 @@ static DWORD d3d8_allocate_handle(struct d3d8_handle_table *t, void *object, enu
entry = t->free_entries;
if (entry->type != D3D8_HANDLE_FREE)
{
ERR("Handle %u(%p) is in the free list, but has type %#x.\n", index, entry, entry->type);
ERR("Handle %lu(%p) is in the free list, but has type %#x.\n", index, entry, entry->type);
return D3D8_INVALID_HANDLE;
}
t->free_entries = entry->object;
@ -517,14 +517,14 @@ static void *d3d8_free_handle(struct d3d8_handle_table *t, DWORD handle, enum d3
if (handle == D3D8_INVALID_HANDLE || handle >= t->entry_count)
{
WARN("Invalid handle %u passed.\n", handle);
WARN("Invalid handle %lu passed.\n", handle);
return NULL;
}
entry = &t->entries[handle];
if (entry->type != type)
{
WARN("Handle %u(%p) is not of type %#x.\n", handle, entry, type);
WARN("Handle %lu(%p) is not of type %#x.\n", handle, entry, type);
return NULL;
}
@ -542,14 +542,14 @@ static void *d3d8_get_object(struct d3d8_handle_table *t, DWORD handle, enum d3d
if (handle == D3D8_INVALID_HANDLE || handle >= t->entry_count)
{
WARN("Invalid handle %u passed.\n", handle);
WARN("Invalid handle %lu passed.\n", handle);
return NULL;
}
entry = &t->entries[handle];
if (entry->type != type)
{
WARN("Handle %u(%p) is not of type %#x.\n", handle, entry, type);
WARN("Handle %lu(%p) is not of type %#x.\n", handle, entry, type);
return NULL;
}
@ -591,7 +591,7 @@ static ULONG WINAPI d3d8_device_AddRef(IDirect3DDevice8 *iface)
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
ULONG ref = InterlockedIncrement(&device->ref);
TRACE("%p increasing refcount to %u.\n", iface, ref);
TRACE("%p increasing refcount to %lu.\n", iface, ref);
return ref;
}
@ -606,7 +606,7 @@ static ULONG WINAPI d3d8_device_Release(IDirect3DDevice8 *iface)
ref = InterlockedDecrement(&device->ref);
TRACE("%p decreasing refcount to %u.\n", iface, ref);
TRACE("%p decreasing refcount to %lu.\n", iface, ref);
if (!ref)
{
@ -651,7 +651,7 @@ static HRESULT WINAPI d3d8_device_TestCooperativeLevel(IDirect3DDevice8 *iface)
TRACE("iface %p.\n", iface);
TRACE("device state: %#x.\n", device->device_state);
TRACE("device state: %#lx.\n", device->device_state);
switch (device->device_state)
{
@ -683,7 +683,7 @@ static HRESULT WINAPI d3d8_device_ResourceManagerDiscardBytes(IDirect3DDevice8 *
{
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
TRACE("iface %p, byte_count %u.\n", iface, byte_count);
TRACE("iface %p, byte_count %lu.\n", iface, byte_count);
if (byte_count)
FIXME("Byte count ignored.\n");
@ -787,14 +787,14 @@ static HRESULT WINAPI d3d8_device_SetCursorProperties(IDirect3DDevice8 *iface,
if (FAILED(hr = IDirect3DSurface8_GetDesc(bitmap, &surface_desc)))
{
WARN("Failed to get surface description, hr %#x.\n", hr);
WARN("Failed to get surface description, hr %#lx.\n", hr);
return hr;
}
if (FAILED(hr = IDirect3D8_GetAdapterDisplayMode(&device->d3d_parent->IDirect3D8_iface,
device->adapter_ordinal, &mode)))
{
WARN("Failed to get device display mode, hr %#x.\n", hr);
WARN("Failed to get device display mode, hr %#lx.\n", hr);
return hr;
}
@ -817,7 +817,7 @@ static void WINAPI d3d8_device_SetCursorPosition(IDirect3DDevice8 *iface, UINT x
{
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
TRACE("iface %p, x %u, y %u, flags %#x.\n", iface, x, y, flags);
TRACE("iface %p, x %u, y %u, flags %#lx.\n", iface, x, y, flags);
wined3d_mutex_lock();
wined3d_device_set_cursor_position(device->wined3d_device, x, y, flags);
@ -1059,7 +1059,7 @@ static void WINAPI d3d8_device_SetGammaRamp(IDirect3DDevice8 *iface, DWORD flags
{
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
TRACE("iface %p, flags %#x, ramp %p.\n", iface, flags, ramp);
TRACE("iface %p, flags %#lx, ramp %p.\n", iface, flags, ramp);
/* Note: D3DGAMMARAMP is compatible with struct wined3d_gamma_ramp. */
wined3d_mutex_lock();
@ -1087,7 +1087,7 @@ static HRESULT WINAPI d3d8_device_CreateTexture(IDirect3DDevice8 *iface,
struct d3d8_texture *object;
HRESULT hr;
TRACE("iface %p, width %u, height %u, levels %u, usage %#x, format %#x, pool %#x, texture %p.\n",
TRACE("iface %p, width %u, height %u, levels %u, usage %#lx, format %#x, pool %#x, texture %p.\n",
iface, width, height, levels, usage, format, pool, texture);
if (!format)
@ -1100,7 +1100,7 @@ static HRESULT WINAPI d3d8_device_CreateTexture(IDirect3DDevice8 *iface,
hr = d3d8_texture_2d_init(object, device, width, height, levels, usage, format, pool);
if (FAILED(hr))
{
WARN("Failed to initialize texture, hr %#x.\n", hr);
WARN("Failed to initialize texture, hr %#lx.\n", hr);
heap_free(object);
return hr;
}
@ -1119,7 +1119,7 @@ static HRESULT WINAPI d3d8_device_CreateVolumeTexture(IDirect3DDevice8 *iface,
struct d3d8_texture *object;
HRESULT hr;
TRACE("iface %p, width %u, height %u, depth %u, levels %u, usage %#x, format %#x, pool %#x, texture %p.\n",
TRACE("iface %p, width %u, height %u, depth %u, levels %u, usage %#lx, format %#x, pool %#x, texture %p.\n",
iface, width, height, depth, levels, usage, format, pool, texture);
if (!format)
@ -1132,7 +1132,7 @@ static HRESULT WINAPI d3d8_device_CreateVolumeTexture(IDirect3DDevice8 *iface,
hr = d3d8_texture_3d_init(object, device, width, height, depth, levels, usage, format, pool);
if (FAILED(hr))
{
WARN("Failed to initialize volume texture, hr %#x.\n", hr);
WARN("Failed to initialize volume texture, hr %#lx.\n", hr);
heap_free(object);
return hr;
}
@ -1150,7 +1150,7 @@ static HRESULT WINAPI d3d8_device_CreateCubeTexture(IDirect3DDevice8 *iface, UIN
struct d3d8_texture *object;
HRESULT hr;
TRACE("iface %p, edge_length %u, levels %u, usage %#x, format %#x, pool %#x, texture %p.\n",
TRACE("iface %p, edge_length %u, levels %u, usage %#lx, format %#x, pool %#x, texture %p.\n",
iface, edge_length, levels, usage, format, pool, texture);
if (!format)
@ -1163,7 +1163,7 @@ static HRESULT WINAPI d3d8_device_CreateCubeTexture(IDirect3DDevice8 *iface, UIN
hr = d3d8_texture_cube_init(object, device, edge_length, levels, usage, format, pool);
if (FAILED(hr))
{
WARN("Failed to initialize cube texture, hr %#x.\n", hr);
WARN("Failed to initialize cube texture, hr %#lx.\n", hr);
heap_free(object);
return hr;
}
@ -1181,7 +1181,7 @@ static HRESULT WINAPI d3d8_device_CreateVertexBuffer(IDirect3DDevice8 *iface, UI
struct d3d8_vertexbuffer *object;
HRESULT hr;
TRACE("iface %p, size %u, usage %#x, fvf %#x, pool %#x, buffer %p.\n",
TRACE("iface %p, size %u, usage %#lx, fvf %#lx, pool %#x, buffer %p.\n",
iface, size, usage, fvf, pool, buffer);
if (!(object = heap_alloc_zero(sizeof(*object))))
@ -1190,7 +1190,7 @@ static HRESULT WINAPI d3d8_device_CreateVertexBuffer(IDirect3DDevice8 *iface, UI
hr = vertexbuffer_init(object, device, size, usage, fvf, pool);
if (FAILED(hr))
{
WARN("Failed to initialize vertex buffer, hr %#x.\n", hr);
WARN("Failed to initialize vertex buffer, hr %#lx.\n", hr);
heap_free(object);
return hr;
}
@ -1208,7 +1208,7 @@ static HRESULT WINAPI d3d8_device_CreateIndexBuffer(IDirect3DDevice8 *iface, UIN
struct d3d8_indexbuffer *object;
HRESULT hr;
TRACE("iface %p, size %u, usage %#x, format %#x, pool %#x, buffer %p.\n",
TRACE("iface %p, size %u, usage %#lx, format %#x, pool %#x, buffer %p.\n",
iface, size, usage, format, pool, buffer);
if (!(object = heap_alloc_zero(sizeof(*object))))
@ -1217,7 +1217,7 @@ static HRESULT WINAPI d3d8_device_CreateIndexBuffer(IDirect3DDevice8 *iface, UIN
hr = indexbuffer_init(object, device, size, usage, format, pool);
if (FAILED(hr))
{
WARN("Failed to initialize index buffer, hr %#x.\n", hr);
WARN("Failed to initialize index buffer, hr %#lx.\n", hr);
heap_free(object);
return hr;
}
@ -1259,7 +1259,7 @@ static HRESULT d3d8_device_create_surface(struct d3d8_device *device, enum wined
1, 1, 0, NULL, NULL, &d3d8_null_wined3d_parent_ops, &texture)))
{
wined3d_mutex_unlock();
WARN("Failed to create texture, hr %#x.\n", hr);
WARN("Failed to create texture, hr %#lx.\n", hr);
return hr;
}
@ -1654,12 +1654,12 @@ static HRESULT WINAPI d3d8_device_Clear(IDirect3DDevice8 *iface, DWORD rect_coun
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
HRESULT hr;
TRACE("iface %p, rect_count %u, rects %p, flags %#x, color 0x%08x, z %.8e, stencil %u.\n",
TRACE("iface %p, rect_count %lu, rects %p, flags %#lx, color 0x%08lx, z %.8e, stencil %lu.\n",
iface, rect_count, rects, flags, color, z, stencil);
if (rect_count && !rects)
{
WARN("count %u with NULL rects.\n", rect_count);
WARN("count %lu with NULL rects.\n", rect_count);
rect_count = 0;
}
@ -1812,7 +1812,7 @@ static HRESULT WINAPI d3d8_device_SetLight(IDirect3DDevice8 *iface, DWORD index,
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
HRESULT hr;
TRACE("iface %p, index %u, light %p.\n", iface, index, light);
TRACE("iface %p, index %lu, light %p.\n", iface, index, light);
/* Note: D3DLIGHT8 is compatible with struct wined3d_light. */
wined3d_mutex_lock();
@ -1828,7 +1828,7 @@ static HRESULT WINAPI d3d8_device_GetLight(IDirect3DDevice8 *iface, DWORD index,
BOOL enabled;
HRESULT hr;
TRACE("iface %p, index %u, light %p.\n", iface, index, light);
TRACE("iface %p, index %lu, light %p.\n", iface, index, light);
/* Note: D3DLIGHT8 is compatible with struct wined3d_light. */
wined3d_mutex_lock();
@ -1843,7 +1843,7 @@ static HRESULT WINAPI d3d8_device_LightEnable(IDirect3DDevice8 *iface, DWORD ind
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
HRESULT hr;
TRACE("iface %p, index %u, enable %#x.\n", iface, index, enable);
TRACE("iface %p, index %lu, enable %#x.\n", iface, index, enable);
wined3d_mutex_lock();
hr = wined3d_stateblock_set_light_enable(device->update_state, index, enable);
@ -1858,7 +1858,7 @@ static HRESULT WINAPI d3d8_device_GetLightEnable(IDirect3DDevice8 *iface, DWORD
struct wined3d_light light;
HRESULT hr;
TRACE("iface %p, index %u, enabled %p.\n", iface, index, enabled);
TRACE("iface %p, index %lu, enabled %p.\n", iface, index, enabled);
wined3d_mutex_lock();
hr = wined3d_stateblock_get_light(device->state, index, &light, enabled);
@ -1872,7 +1872,7 @@ static HRESULT WINAPI d3d8_device_SetClipPlane(IDirect3DDevice8 *iface, DWORD in
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
HRESULT hr;
TRACE("iface %p, index %u, plane %p.\n", iface, index, plane);
TRACE("iface %p, index %lu, plane %p.\n", iface, index, plane);
wined3d_mutex_lock();
hr = wined3d_stateblock_set_clip_plane(device->update_state, index, (const struct wined3d_vec4 *)plane);
@ -1885,11 +1885,11 @@ static HRESULT WINAPI d3d8_device_GetClipPlane(IDirect3DDevice8 *iface, DWORD in
{
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
TRACE("iface %p, index %u, plane %p.\n", iface, index, plane);
TRACE("iface %p, index %lu, plane %p.\n", iface, index, plane);
if (index >= device->max_user_clip_planes)
{
TRACE("Plane %u requested, but only %u planes are supported.\n", index, device->max_user_clip_planes);
TRACE("Plane %lu requested, but only %u planes are supported.\n", index, device->max_user_clip_planes);
return WINED3DERR_INVALIDCALL;
}
@ -1933,7 +1933,7 @@ static HRESULT WINAPI d3d8_device_SetRenderState(IDirect3DDevice8 *iface,
{
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
TRACE("iface %p, state %#x, value %#x.\n", iface, state, value);
TRACE("iface %p, state %#x, value %#lx.\n", iface, state, value);
wined3d_mutex_lock();
wined3d_stateblock_set_render_state(device->update_state, wined3d_render_state_from_d3d(state), value);
@ -2026,7 +2026,7 @@ static HRESULT WINAPI d3d8_device_EndStateBlock(IDirect3DDevice8 *iface, DWORD *
}
++*token;
TRACE("Returning %#x (%p).\n", *token, stateblock);
TRACE("Returning %#lx (%p).\n", *token, stateblock);
return D3D_OK;
}
@ -2041,7 +2041,7 @@ static HRESULT WINAPI d3d8_device_ApplyStateBlock(IDirect3DDevice8 *iface, DWORD
struct wined3d_buffer *wined3d_buffer;
unsigned int i;
TRACE("iface %p, token %#x.\n", iface, token);
TRACE("iface %p, token %#lx.\n", iface, token);
if (!token)
return D3D_OK;
@ -2056,7 +2056,7 @@ static HRESULT WINAPI d3d8_device_ApplyStateBlock(IDirect3DDevice8 *iface, DWORD
stateblock = d3d8_get_object(&device->handle_table, token - 1, D3D8_HANDLE_SB);
if (!stateblock)
{
WARN("Invalid handle (%#x) passed.\n", token);
WARN("Invalid handle (%#lx) passed.\n", token);
wined3d_mutex_unlock();
return D3DERR_INVALIDCALL;
}
@ -2083,7 +2083,7 @@ static HRESULT WINAPI d3d8_device_CaptureStateBlock(IDirect3DDevice8 *iface, DWO
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
struct wined3d_stateblock *stateblock;
TRACE("iface %p, token %#x.\n", iface, token);
TRACE("iface %p, token %#lx.\n", iface, token);
wined3d_mutex_lock();
if (device->recording)
@ -2095,7 +2095,7 @@ static HRESULT WINAPI d3d8_device_CaptureStateBlock(IDirect3DDevice8 *iface, DWO
stateblock = d3d8_get_object(&device->handle_table, token - 1, D3D8_HANDLE_SB);
if (!stateblock)
{
WARN("Invalid handle (%#x) passed.\n", token);
WARN("Invalid handle (%#lx) passed.\n", token);
wined3d_mutex_unlock();
return D3DERR_INVALIDCALL;
}
@ -2110,14 +2110,14 @@ static HRESULT WINAPI d3d8_device_DeleteStateBlock(IDirect3DDevice8 *iface, DWOR
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
struct wined3d_stateblock *stateblock;
TRACE("iface %p, token %#x.\n", iface, token);
TRACE("iface %p, token %#lx.\n", iface, token);
wined3d_mutex_lock();
stateblock = d3d8_free_handle(&device->handle_table, token - 1, D3D8_HANDLE_SB);
if (!stateblock)
{
WARN("Invalid handle (%#x) passed.\n", token);
WARN("Invalid handle (%#lx) passed.\n", token);
wined3d_mutex_unlock();
return D3DERR_INVALIDCALL;
}
@ -2159,7 +2159,7 @@ static HRESULT WINAPI d3d8_device_CreateStateBlock(IDirect3DDevice8 *iface,
if (FAILED(hr))
{
wined3d_mutex_unlock();
ERR("Failed to create the state block, hr %#x\n", hr);
ERR("Failed to create the state block, hr %#lx.\n", hr);
return hr;
}
@ -2176,7 +2176,7 @@ static HRESULT WINAPI d3d8_device_CreateStateBlock(IDirect3DDevice8 *iface,
}
++*handle;
TRACE("Returning %#x (%p).\n", *handle, stateblock);
TRACE("Returning %#lx (%p).\n", *handle, stateblock);
return hr;
}
@ -2216,14 +2216,14 @@ static HRESULT WINAPI d3d8_device_GetTexture(IDirect3DDevice8 *iface, DWORD stag
struct wined3d_texture *wined3d_texture;
struct d3d8_texture *texture_impl;
TRACE("iface %p, stage %u, texture %p.\n", iface, stage, texture);
TRACE("iface %p, stage %lu, texture %p.\n", iface, stage, texture);
if (!texture)
return D3DERR_INVALIDCALL;
if (stage >= WINED3D_MAX_FRAGMENT_SAMPLERS)
{
WARN("Ignoring invalid stage %u.\n", stage);
WARN("Ignoring invalid stage %lu.\n", stage);
*texture = NULL;
return D3D_OK;
}
@ -2249,7 +2249,7 @@ static HRESULT WINAPI d3d8_device_SetTexture(IDirect3DDevice8 *iface, DWORD stag
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
struct d3d8_texture *texture_impl;
TRACE("iface %p, stage %u, texture %p.\n", iface, stage, texture);
TRACE("iface %p, stage %lu, texture %p.\n", iface, stage, texture);
texture_impl = unsafe_impl_from_IDirect3DBaseTexture8(texture);
@ -2310,7 +2310,7 @@ static HRESULT WINAPI d3d8_device_GetTextureStageState(IDirect3DDevice8 *iface,
const struct wined3d_stateblock_state *device_state;
const struct tss_lookup *l;
TRACE("iface %p, stage %u, state %#x, value %p.\n", iface, stage, state, value);
TRACE("iface %p, stage %lu, state %#x, value %p.\n", iface, stage, state, value);
if (state >= ARRAY_SIZE(tss_lookup))
{
@ -2337,7 +2337,7 @@ static HRESULT WINAPI d3d8_device_SetTextureStageState(IDirect3DDevice8 *iface,
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
const struct tss_lookup *l;
TRACE("iface %p, stage %u, state %#x, value %#x.\n", iface, stage, type, value);
TRACE("iface %p, stage %lu, state %#x, value %#lx.\n", iface, stage, type, value);
if (type >= ARRAY_SIZE(tss_lookup))
{
@ -2375,7 +2375,7 @@ static HRESULT WINAPI d3d8_device_ValidateDevice(IDirect3DDevice8 *iface, DWORD
static HRESULT WINAPI d3d8_device_GetInfo(IDirect3DDevice8 *iface,
DWORD info_id, void *info, DWORD info_size)
{
TRACE("iface %p, info_id %#x, info %p, info_size %u.\n", iface, info_id, info, info_size);
TRACE("iface %p, info_id %#lx, info %p, info_size %lu.\n", iface, info_id, info, info_size);
if (info_id < 4)
return E_FAIL;
@ -2480,7 +2480,7 @@ static HRESULT d3d8_device_upload_sysmem_index_buffer(struct d3d8_device *device
wined3d_box_set(&box, src_offset, 0, buffer_size, 1, 0, 1);
if (FAILED(hr = wined3d_resource_map(index_buffer, 0, &map_desc, &box, WINED3D_MAP_READ)))
{
ERR("Failed to map index buffer, hr %#x.\n", hr);
ERR("Failed to map index buffer, hr %#lx.\n", hr);
return hr;
}
wined3d_streaming_buffer_upload(device->wined3d_device, &device->index_buffer,
@ -2683,7 +2683,7 @@ static HRESULT WINAPI d3d8_device_ProcessVertices(IDirect3DDevice8 *iface, UINT
unsigned int i, map;
HRESULT hr;
TRACE("iface %p, src_start_idx %u, dst_idx %u, vertex_count %u, dst_buffer %p, flags %#x.\n",
TRACE("iface %p, src_start_idx %u, dst_idx %u, vertex_count %u, dst_buffer %p, flags %#lx.\n",
iface, src_start_idx, dst_idx, vertex_count, dst_buffer, flags);
wined3d_mutex_lock();
@ -2737,7 +2737,7 @@ static HRESULT WINAPI d3d8_device_CreateVertexShader(IDirect3DDevice8 *iface,
DWORD handle;
HRESULT hr;
TRACE("iface %p, declaration %p, byte_code %p, shader %p, usage %#x.\n",
TRACE("iface %p, declaration %p, byte_code %p, shader %p, usage %#lx.\n",
iface, declaration, byte_code, shader, usage);
if (!(object = heap_alloc_zero(sizeof(*object))))
@ -2762,7 +2762,7 @@ static HRESULT WINAPI d3d8_device_CreateVertexShader(IDirect3DDevice8 *iface,
hr = d3d8_vertex_shader_init(object, device, declaration, byte_code, shader_handle, usage);
if (FAILED(hr))
{
WARN("Failed to initialize vertex shader, hr %#x.\n", hr);
WARN("Failed to initialize vertex shader, hr %#lx.\n", hr);
wined3d_mutex_lock();
d3d8_free_handle(&device->handle_table, handle, D3D8_HANDLE_VS);
wined3d_mutex_unlock();
@ -2771,7 +2771,7 @@ static HRESULT WINAPI d3d8_device_CreateVertexShader(IDirect3DDevice8 *iface,
return hr;
}
TRACE("Created vertex shader %p (handle %#x).\n", object, shader_handle);
TRACE("Created vertex shader %p (handle %#lx).\n", object, shader_handle);
*shader = shader_handle;
return D3D_OK;
@ -2784,7 +2784,7 @@ static struct d3d8_vertex_declaration *d3d8_device_get_fvf_declaration(struct d3
int p, low, high; /* deliberately signed */
HRESULT hr;
TRACE("Searching for declaration for fvf %08x... ", fvf);
TRACE("Searching for declaration for fvf %#lx... ", fvf);
low = 0;
high = device->numConvertedDecls - 1;
@ -2811,7 +2811,7 @@ static struct d3d8_vertex_declaration *d3d8_device_get_fvf_declaration(struct d3
if (FAILED(hr = d3d8_vertex_declaration_init_fvf(d3d8_declaration, device, fvf)))
{
WARN("Failed to initialize vertex declaration, hr %#x.\n", hr);
WARN("Failed to initialize vertex declaration, hr %#lx.\n", hr);
heap_free(d3d8_declaration);
return NULL;
}
@ -2846,11 +2846,11 @@ static HRESULT WINAPI d3d8_device_SetVertexShader(IDirect3DDevice8 *iface, DWORD
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
struct d3d8_vertex_shader *shader_impl;
TRACE("iface %p, shader %#x.\n", iface, shader);
TRACE("iface %p, shader %#lx.\n", iface, shader);
if (VS_HIGHESTFIXEDFXF >= shader)
{
TRACE("Setting FVF, %#x\n", shader);
TRACE("Setting FVF, %#lx\n", shader);
wined3d_mutex_lock();
wined3d_stateblock_set_vertex_declaration(device->update_state,
@ -2866,7 +2866,7 @@ static HRESULT WINAPI d3d8_device_SetVertexShader(IDirect3DDevice8 *iface, DWORD
wined3d_mutex_lock();
if (!(shader_impl = d3d8_get_object(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS)))
{
WARN("Invalid handle (%#x) passed.\n", shader);
WARN("Invalid handle (%#lx) passed.\n", shader);
wined3d_mutex_unlock();
return D3DERR_INVALIDCALL;
@ -2900,7 +2900,7 @@ static HRESULT WINAPI d3d8_device_GetVertexShader(IDirect3DDevice8 *iface, DWORD
}
wined3d_mutex_unlock();
TRACE("Returning %#x.\n", *shader);
TRACE("Returning %#lx.\n", *shader);
return D3D_OK;
}
@ -2910,12 +2910,12 @@ static HRESULT WINAPI d3d8_device_DeleteVertexShader(IDirect3DDevice8 *iface, DW
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
struct d3d8_vertex_shader *shader_impl;
TRACE("iface %p, shader %#x.\n", iface, shader);
TRACE("iface %p, shader %#lx.\n", iface, shader);
wined3d_mutex_lock();
if (!(shader_impl = d3d8_free_handle(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS)))
{
WARN("Invalid handle (%#x) passed.\n", shader);
WARN("Invalid handle (%#lx) passed.\n", shader);
wined3d_mutex_unlock();
return D3DERR_INVALIDCALL;
@ -2938,12 +2938,12 @@ static HRESULT WINAPI d3d8_device_SetVertexShaderConstant(IDirect3DDevice8 *ifac
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
HRESULT hr;
TRACE("iface %p, start_register %u, data %p, count %u.\n",
TRACE("iface %p, start_register %lu, data %p, count %lu.\n",
iface, start_register, data, count);
if (start_register + count > D3D8_MAX_VERTEX_SHADER_CONSTANTF)
{
WARN("Trying to access %u constants, but d3d8 only supports %u\n",
WARN("Trying to access %lu constants, but d3d8 only supports %u.\n",
start_register + count, D3D8_MAX_VERTEX_SHADER_CONSTANTF);
return D3DERR_INVALIDCALL;
}
@ -2961,14 +2961,14 @@ static HRESULT WINAPI d3d8_device_GetVertexShaderConstant(IDirect3DDevice8 *ifac
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
const struct wined3d_vec4 *src;
TRACE("iface %p, start_idx %u, constants %p, count %u.\n", iface, start_idx, constants, count);
TRACE("iface %p, start_idx %lu, constants %p, count %lu.\n", iface, start_idx, constants, count);
if (!constants)
return D3DERR_INVALIDCALL;
if (!wined3d_bound_range(start_idx, count, device->vs_uniform_count))
{
WARN("Trying to access %u constants, but d3d8 only supports %u.\n",
WARN("Trying to access %lu constants, but d3d8 only supports %u.\n",
start_idx + count, device->vs_uniform_count);
return D3DERR_INVALIDCALL;
}
@ -2988,8 +2988,7 @@ static HRESULT WINAPI d3d8_device_GetVertexShaderDeclaration(IDirect3DDevice8 *i
struct d3d8_vertex_declaration *declaration;
struct d3d8_vertex_shader *shader_impl;
TRACE("iface %p, shader %#x, data %p, data_size %p.\n",
iface, shader, data, data_size);
TRACE("iface %p, shader %#lx, data %p, data_size %p.\n", iface, shader, data, data_size);
wined3d_mutex_lock();
shader_impl = d3d8_get_object(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS);
@ -2997,7 +2996,7 @@ static HRESULT WINAPI d3d8_device_GetVertexShaderDeclaration(IDirect3DDevice8 *i
if (!shader_impl)
{
WARN("Invalid handle (%#x) passed.\n", shader);
WARN("Invalid handle (%#lx) passed.\n", shader);
return D3DERR_INVALIDCALL;
}
declaration = shader_impl->vertex_declaration;
@ -3026,13 +3025,12 @@ static HRESULT WINAPI d3d8_device_GetVertexShaderFunction(IDirect3DDevice8 *ifac
struct d3d8_vertex_shader *shader_impl = NULL;
HRESULT hr;
TRACE("iface %p, shader %#x, data %p, data_size %p.\n",
iface, shader, data, data_size);
TRACE("iface %p, shader %#lx, data %p, data_size %p.\n", iface, shader, data, data_size);
wined3d_mutex_lock();
if (!(shader_impl = d3d8_get_object(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS)))
{
WARN("Invalid handle (%#x) passed.\n", shader);
WARN("Invalid handle (%#lx) passed.\n", shader);
wined3d_mutex_unlock();
return D3DERR_INVALIDCALL;
@ -3045,7 +3043,7 @@ static HRESULT WINAPI d3d8_device_GetVertexShaderFunction(IDirect3DDevice8 *ifac
return D3D_OK;
}
hr = wined3d_shader_get_byte_code(shader_impl->wined3d_shader, data, data_size);
hr = wined3d_shader_get_byte_code(shader_impl->wined3d_shader, data, (unsigned int *)data_size);
wined3d_mutex_unlock();
return hr;
@ -3145,7 +3143,7 @@ static HRESULT WINAPI d3d8_device_CreatePixelShader(IDirect3DDevice8 *iface,
hr = d3d8_pixel_shader_init(object, device, byte_code, shader_handle);
if (FAILED(hr))
{
WARN("Failed to initialize pixel shader, hr %#x.\n", hr);
WARN("Failed to initialize pixel shader, hr %#lx.\n", hr);
wined3d_mutex_lock();
d3d8_free_handle(&device->handle_table, handle, D3D8_HANDLE_PS);
wined3d_mutex_unlock();
@ -3154,7 +3152,7 @@ static HRESULT WINAPI d3d8_device_CreatePixelShader(IDirect3DDevice8 *iface,
return hr;
}
TRACE("Created pixel shader %p (handle %#x).\n", object, shader_handle);
TRACE("Created pixel shader %p (handle %#lx).\n", object, shader_handle);
*shader = shader_handle;
return D3D_OK;
@ -3165,7 +3163,7 @@ static HRESULT WINAPI d3d8_device_SetPixelShader(IDirect3DDevice8 *iface, DWORD
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
struct d3d8_pixel_shader *shader_impl;
TRACE("iface %p, shader %#x.\n", iface, shader);
TRACE("iface %p, shader %#lx.\n", iface, shader);
wined3d_mutex_lock();
@ -3178,7 +3176,7 @@ static HRESULT WINAPI d3d8_device_SetPixelShader(IDirect3DDevice8 *iface, DWORD
if (!(shader_impl = d3d8_get_object(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_PS)))
{
WARN("Invalid handle (%#x) passed.\n", shader);
WARN("Invalid handle (%#lx) passed.\n", shader);
wined3d_mutex_unlock();
return D3DERR_INVALIDCALL;
}
@ -3213,7 +3211,7 @@ static HRESULT WINAPI d3d8_device_GetPixelShader(IDirect3DDevice8 *iface, DWORD
}
wined3d_mutex_unlock();
TRACE("Returning %#x.\n", *shader);
TRACE("Returning %#lx.\n", *shader);
return D3D_OK;
}
@ -3223,13 +3221,13 @@ static HRESULT WINAPI d3d8_device_DeletePixelShader(IDirect3DDevice8 *iface, DWO
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
struct d3d8_pixel_shader *shader_impl;
TRACE("iface %p, shader %#x.\n", iface, shader);
TRACE("iface %p, shader %#lx.\n", iface, shader);
wined3d_mutex_lock();
if (!(shader_impl = d3d8_free_handle(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_PS)))
{
WARN("Invalid handle (%#x) passed.\n", shader);
WARN("Invalid handle (%#lx) passed.\n", shader);
wined3d_mutex_unlock();
return D3DERR_INVALIDCALL;
}
@ -3250,8 +3248,7 @@ static HRESULT WINAPI d3d8_device_SetPixelShaderConstant(IDirect3DDevice8 *iface
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
HRESULT hr;
TRACE("iface %p, start_register %u, data %p, count %u.\n",
iface, start_register, data, count);
TRACE("iface %p, start_register %lu, data %p, count %lu.\n", iface, start_register, data, count);
wined3d_mutex_lock();
hr = wined3d_stateblock_set_ps_consts_f(device->update_state, start_register, count, data);
@ -3266,7 +3263,7 @@ static HRESULT WINAPI d3d8_device_GetPixelShaderConstant(IDirect3DDevice8 *iface
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
const struct wined3d_vec4 *src;
TRACE("iface %p, start_idx %u, constants %p, count %u.\n", iface, start_idx, constants, count);
TRACE("iface %p, start_idx %lu, constants %p, count %lu.\n", iface, start_idx, constants, count);
if (!constants || !wined3d_bound_range(start_idx, count, D3D8_MAX_PIXEL_SHADER_CONSTANTF))
return WINED3DERR_INVALIDCALL;
@ -3286,19 +3283,18 @@ static HRESULT WINAPI d3d8_device_GetPixelShaderFunction(IDirect3DDevice8 *iface
struct d3d8_pixel_shader *shader_impl = NULL;
HRESULT hr;
TRACE("iface %p, shader %#x, data %p, data_size %p.\n",
iface, shader, data, data_size);
TRACE("iface %p, shader %#lx, data %p, data_size %p.\n", iface, shader, data, data_size);
wined3d_mutex_lock();
if (!(shader_impl = d3d8_get_object(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_PS)))
{
WARN("Invalid handle (%#x) passed.\n", shader);
WARN("Invalid handle (%#lx) passed.\n", shader);
wined3d_mutex_unlock();
return D3DERR_INVALIDCALL;
}
hr = wined3d_shader_get_byte_code(shader_impl->wined3d_shader, data, data_size);
hr = wined3d_shader_get_byte_code(shader_impl->wined3d_shader, data, (unsigned int *)data_size);
wined3d_mutex_unlock();
return hr;
@ -3583,13 +3579,13 @@ static HRESULT CDECL device_parent_create_swapchain_texture(struct wined3d_devic
struct d3d8_surface *d3d_surface;
HRESULT hr;
TRACE("device_parent %p, container_parent %p, desc %p, texture flags %#x, texture %p.\n",
TRACE("device_parent %p, container_parent %p, desc %p, texture flags %#lx, texture %p.\n",
device_parent, container_parent, desc, texture_flags, texture);
if (FAILED(hr = wined3d_texture_create(device->wined3d_device, desc, 1, 1, texture_flags,
NULL, &device->IDirect3DDevice8_iface, &d3d8_null_wined3d_parent_ops, texture)))
{
WARN("Failed to create texture, hr %#x.\n", hr);
WARN("Failed to create texture, hr %#lx.\n", hr);
return hr;
}
@ -3670,7 +3666,7 @@ HRESULT device_init(struct d3d8_device *device, struct d3d8 *parent, struct wine
focus_window, flags, 4, feature_levels, ARRAY_SIZE(feature_levels),
&device->device_parent, &device->wined3d_device)))
{
WARN("Failed to create wined3d device, hr %#x.\n", hr);
WARN("Failed to create wined3d device, hr %#lx.\n", hr);
wined3d_mutex_unlock();
heap_free(device->handle_table.entries);
return hr;
@ -3683,7 +3679,7 @@ HRESULT device_init(struct d3d8_device *device, struct d3d8 *parent, struct wine
if (FAILED(hr = wined3d_stateblock_create(device->wined3d_device, NULL, WINED3D_SBT_PRIMARY, &device->state)))
{
ERR("Failed to create primary stateblock, hr %#x.\n", hr);
ERR("Failed to create primary stateblock, hr %#lx.\n", hr);
wined3d_device_decref(device->wined3d_device);
wined3d_mutex_unlock();
return hr;
@ -3700,7 +3696,7 @@ HRESULT device_init(struct d3d8_device *device, struct d3d8 *parent, struct wine
focus_window = parameters->hDeviceWindow;
if (FAILED(hr = wined3d_device_acquire_focus_window(device->wined3d_device, focus_window)))
{
ERR("Failed to acquire focus window, hr %#x.\n", hr);
ERR("Failed to acquire focus window, hr %#lx.\n", hr);
wined3d_device_decref(device->wined3d_device);
wined3d_mutex_unlock();
heap_free(device->handle_table.entries);
@ -3724,7 +3720,7 @@ HRESULT device_init(struct d3d8_device *device, struct d3d8 *parent, struct wine
if (FAILED(hr = d3d8_swapchain_create(device, &swapchain_desc,
wined3dswapinterval_from_d3d(parameters->FullScreen_PresentationInterval), &d3d_swapchain)))
{
WARN("Failed to create implicit swapchain, hr %#x.\n", hr);
WARN("Failed to create implicit swapchain, hr %#lx.\n", hr);
wined3d_device_release_focus_window(device->wined3d_device);
wined3d_device_decref(device->wined3d_device);
wined3d_mutex_unlock();

16
dlls/d3d8/directx.c
View file

@ -52,7 +52,7 @@ static ULONG WINAPI d3d8_AddRef(IDirect3D8 *iface)
struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
ULONG refcount = InterlockedIncrement(&d3d8->refcount);
TRACE("%p increasing refcount to %u.\n", iface, refcount);
TRACE("%p increasing refcount to %lu.\n", iface, refcount);
return refcount;
}
@ -62,7 +62,7 @@ static ULONG WINAPI d3d8_Release(IDirect3D8 *iface)
struct d3d8 *d3d8 = impl_from_IDirect3D8(iface);
ULONG refcount = InterlockedDecrement(&d3d8->refcount);
TRACE("%p decreasing refcount to %u.\n", iface, refcount);
TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
if (!refcount)
{
@ -109,7 +109,7 @@ static HRESULT WINAPI d3d8_GetAdapterIdentifier(IDirect3D8 *iface, UINT adapter,
unsigned int output_idx;
HRESULT hr;
TRACE("iface %p, adapter %u, flags %#x, identifier %p.\n",
TRACE("iface %p, adapter %u, flags %#lx, identifier %p.\n",
iface, adapter, flags, identifier);
output_idx = adapter;
@ -253,7 +253,7 @@ static HRESULT WINAPI d3d8_CheckDeviceFormat(IDirect3D8 *iface, UINT adapter, D3
unsigned int output_idx;
HRESULT hr;
TRACE("iface %p, adapter %u, device_type %#x, adapter_format %#x, usage %#x, resource_type %#x, format %#x.\n",
TRACE("iface %p, adapter %u, device_type %#x, adapter_format %#x, usage %#lx, resource_type %#x, format %#x.\n",
iface, adapter, device_type, adapter_format, usage, resource_type, format);
output_idx = adapter;
@ -299,7 +299,7 @@ static HRESULT WINAPI d3d8_CheckDeviceFormat(IDirect3D8 *iface, UINT adapter, D3
wined3d_adapter = wined3d_output_get_adapter(d3d8->wined3d_outputs[output_idx]);
if (format == D3DFMT_RESZ && resource_type == D3DRTYPE_SURFACE && usage == D3DUSAGE_RENDERTARGET)
{
DWORD levels;
unsigned int levels;
hr = wined3d_check_device_multisample_type(wined3d_adapter, wined3d_device_type_from_d3d(device_type),
WINED3DFMT_D24_UNORM_S8_UINT, FALSE, WINED3D_MULTISAMPLE_NON_MASKABLE, &levels);
@ -414,7 +414,7 @@ static HMONITOR WINAPI d3d8_GetAdapterMonitor(IDirect3D8 *iface, UINT adapter)
if (FAILED(hr))
{
WARN("Failed to get output desc, hr %#x.\n", hr);
WARN("Failed to get output desc, hr %#lx.\n", hr);
return NULL;
}
@ -429,7 +429,7 @@ static HRESULT WINAPI d3d8_CreateDevice(IDirect3D8 *iface, UINT adapter,
struct d3d8_device *object;
HRESULT hr;
TRACE("iface %p, adapter %u, device_type %#x, focus_window %p, flags %#x, parameters %p, device %p.\n",
TRACE("iface %p, adapter %u, device_type %#x, focus_window %p, flags %#lx, parameters %p, device %p.\n",
iface, adapter, device_type, focus_window, flags, parameters, device);
if (!(object = heap_alloc_zero(sizeof(*object))))
@ -438,7 +438,7 @@ static HRESULT WINAPI d3d8_CreateDevice(IDirect3D8 *iface, UINT adapter,
hr = device_init(object, d3d8, d3d8->wined3d, adapter, device_type, focus_window, flags, parameters);
if (FAILED(hr))
{
WARN("Failed to initialize device, hr %#x.\n", hr);
WARN("Failed to initialize device, hr %#lx.\n", hr);
heap_free(object);
return hr;
}

12
dlls/d3d8/shader.c
View file

@ -55,7 +55,7 @@ static HRESULT d3d8_vertexshader_create_vertexdeclaration(struct d3d8_device *de
struct d3d8_vertex_declaration *object;
HRESULT hr;
TRACE("device %p, declaration %p, shader_handle %#x, decl_ptr %p.\n",
TRACE("device %p, declaration %p, shader_handle %#lx, decl_ptr %p.\n",
device, declaration, shader_handle, decl_ptr);
if (!(object = heap_alloc_zero(sizeof(*object))))
@ -64,7 +64,7 @@ static HRESULT d3d8_vertexshader_create_vertexdeclaration(struct d3d8_device *de
hr = d3d8_vertex_declaration_init(object, device, declaration, shader_handle);
if (FAILED(hr))
{
WARN("Failed to initialize vertex declaration, hr %#x.\n", hr);
WARN("Failed to initialize vertex declaration, hr %#lx.\n", hr);
heap_free(object);
return hr;
}
@ -103,7 +103,7 @@ HRESULT d3d8_vertex_shader_init(struct d3d8_vertex_shader *shader, struct d3d8_d
hr = d3d8_vertexshader_create_vertexdeclaration(device, declaration, shader_handle, &shader->vertex_declaration);
if (FAILED(hr))
{
WARN("Failed to create vertex declaration, hr %#x.\n", hr);
WARN("Failed to create vertex declaration, hr %#lx.\n", hr);
return hr;
}
@ -112,7 +112,7 @@ HRESULT d3d8_vertex_shader_init(struct d3d8_vertex_shader *shader, struct d3d8_d
struct wined3d_shader_desc desc;
if (usage)
FIXME("Usage %#x not implemented.\n", usage);
FIXME("Usage %#lx not implemented.\n", usage);
desc.byte_code = byte_code;
desc.byte_code_size = ~(size_t)0;
@ -123,7 +123,7 @@ HRESULT d3d8_vertex_shader_init(struct d3d8_vertex_shader *shader, struct d3d8_d
wined3d_mutex_unlock();
if (FAILED(hr))
{
WARN("Failed to create wined3d vertex shader, hr %#x.\n", hr);
WARN("Failed to create wined3d vertex shader, hr %#lx.\n", hr);
d3d8_vertex_declaration_destroy(shader->vertex_declaration);
return hr;
}
@ -170,7 +170,7 @@ HRESULT d3d8_pixel_shader_init(struct d3d8_pixel_shader *shader, struct d3d8_dev
wined3d_mutex_unlock();
if (FAILED(hr))
{
WARN("Failed to create wined3d pixel shader, hr %#x.\n", hr);
WARN("Failed to create wined3d pixel shader, hr %#lx.\n", hr);
return hr;
}

10
dlls/d3d8/surface.c
View file

@ -60,7 +60,7 @@ static ULONG WINAPI d3d8_surface_AddRef(IDirect3DSurface8 *iface)
}
refcount = InterlockedIncrement(&surface->resource.refcount);
TRACE("%p increasing refcount to %u.\n", iface, refcount);
TRACE("%p increasing refcount to %lu.\n", iface, refcount);
if (refcount == 1)
{
@ -94,7 +94,7 @@ static ULONG WINAPI d3d8_surface_Release(IDirect3DSurface8 *iface)
}
refcount = InterlockedDecrement(&surface->resource.refcount);
TRACE("%p decreasing refcount to %u.\n", iface, refcount);
TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
if (!refcount)
{
@ -132,7 +132,7 @@ static HRESULT WINAPI d3d8_surface_SetPrivateData(IDirect3DSurface8 *iface, REFG
const void *data, DWORD data_size, DWORD flags)
{
struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface);
TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
TRACE("iface %p, guid %s, data %p, data_size %lu, flags %#lx.\n",
iface, debugstr_guid(guid), data, data_size, flags);
return d3d8_resource_set_private_data(&surface->resource, guid, data, data_size, flags);
@ -205,7 +205,7 @@ static HRESULT WINAPI d3d8_surface_LockRect(IDirect3DSurface8 *iface,
HRESULT hr;
D3DRESOURCETYPE type;
TRACE("iface %p, locked_rect %p, rect %s, flags %#x.\n",
TRACE("iface %p, locked_rect %p, rect %s, flags %#lx.\n",
iface, locked_rect, wine_dbgstr_rect(rect), flags);
wined3d_mutex_lock();
@ -376,7 +376,7 @@ struct wined3d_rendertarget_view *d3d8_surface_acquire_rendertarget_view(struct
if (FAILED(hr = wined3d_rendertarget_view_create_from_sub_resource(surface->wined3d_texture,
surface->sub_resource_idx, surface, &d3d8_view_wined3d_parent_ops, &surface->wined3d_rtv)))
{
ERR("Failed to create rendertarget view, hr %#x.\n", hr);
ERR("Failed to create rendertarget view, hr %#lx.\n", hr);
d3d8_surface_Release(&surface->IDirect3DSurface8_iface);
return NULL;
}

8
dlls/d3d8/swapchain.c
View file

@ -50,7 +50,7 @@ static ULONG WINAPI d3d8_swapchain_AddRef(IDirect3DSwapChain8 *iface)
struct d3d8_swapchain *swapchain = impl_from_IDirect3DSwapChain8(iface);
ULONG ref = InterlockedIncrement(&swapchain->refcount);
TRACE("%p increasing refcount to %u.\n", iface, ref);
TRACE("%p increasing refcount to %lu.\n", iface, ref);
if (ref == 1)
{
@ -67,7 +67,7 @@ static ULONG WINAPI d3d8_swapchain_Release(IDirect3DSwapChain8 *iface)
struct d3d8_swapchain *swapchain = impl_from_IDirect3DSwapChain8(iface);
ULONG ref = InterlockedDecrement(&swapchain->refcount);
TRACE("%p decreasing refcount to %u.\n", iface, ref);
TRACE("%p decreasing refcount to %lu.\n", iface, ref);
if (!ref)
{
@ -180,7 +180,7 @@ static HRESULT swapchain_init(struct d3d8_swapchain *swapchain, struct d3d8_devi
if (FAILED(hr = wined3d_swapchain_create(device->wined3d_device, desc, &swapchain->state_parent,
swapchain, &d3d8_swapchain_wined3d_parent_ops, &swapchain->wined3d_swapchain)))
{
WARN("Failed to create wined3d swapchain, hr %#x.\n", hr);
WARN("Failed to create wined3d swapchain, hr %#lx.\n", hr);
return hr;
}
@ -201,7 +201,7 @@ HRESULT d3d8_swapchain_create(struct d3d8_device *device, struct wined3d_swapcha
if (FAILED(hr = swapchain_init(object, device, desc, swap_interval)))
{
WARN("Failed to initialize swapchain, hr %#x.\n", hr);
WARN("Failed to initialize swapchain, hr %#lx.\n", hr);
heap_free(object);
return hr;
}

34
dlls/d3d8/texture.c
View file

@ -24,7 +24,7 @@ static ULONG d3d8_texture_incref(struct d3d8_texture *texture)
{
ULONG ref = InterlockedIncrement(&texture->resource.refcount);
TRACE("%p increasing refcount to %u.\n", texture, ref);
TRACE("%p increasing refcount to %lu.\n", texture, ref);
if (ref == 1)
{
@ -47,7 +47,7 @@ static ULONG d3d8_texture_decref(struct d3d8_texture *texture)
{
ULONG ref = InterlockedDecrement(&texture->resource.refcount);
TRACE("%p decreasing refcount to %u.\n", texture, ref);
TRACE("%p decreasing refcount to %lu.\n", texture, ref);
if (!ref)
{
@ -147,7 +147,7 @@ static HRESULT WINAPI d3d8_texture_2d_SetPrivateData(IDirect3DTexture8 *iface,
REFGUID guid, const void *data, DWORD data_size, DWORD flags)
{
struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
TRACE("iface %p, guid %s, data %p, data_size %lu, flags %#lx.\n",
iface, debugstr_guid(guid), data, data_size, flags);
return d3d8_resource_set_private_data(&texture->resource, guid, data, data_size, flags);
@ -177,7 +177,7 @@ static DWORD WINAPI d3d8_texture_2d_SetPriority(IDirect3DTexture8 *iface, DWORD
struct wined3d_resource *resource;
DWORD ret;
TRACE("iface %p, priority %u.\n", iface, priority);
TRACE("iface %p, priority %lu.\n", iface, priority);
wined3d_mutex_lock();
resource = wined3d_texture_get_resource(d3d8_texture_get_draw_texture(texture));
@ -224,7 +224,7 @@ static DWORD WINAPI d3d8_texture_2d_SetLOD(IDirect3DTexture8 *iface, DWORD lod)
struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface);
DWORD ret;
TRACE("iface %p, lod %u.\n", iface, lod);
TRACE("iface %p, lod %lu.\n", iface, lod);
wined3d_mutex_lock();
ret = wined3d_texture_set_lod(d3d8_texture_get_draw_texture(texture), lod);
@ -315,7 +315,7 @@ static HRESULT WINAPI d3d8_texture_2d_LockRect(IDirect3DTexture8 *iface, UINT le
struct d3d8_surface *surface_impl;
HRESULT hr;
TRACE("iface %p, level %u, locked_rect %p, rect %p, flags %#x.\n",
TRACE("iface %p, level %u, locked_rect %p, rect %p, flags %#lx.\n",
iface, level, locked_rect, rect, flags);
wined3d_mutex_lock();
@ -448,7 +448,7 @@ static HRESULT WINAPI d3d8_texture_cube_SetPrivateData(IDirect3DCubeTexture8 *if
REFGUID guid, const void *data, DWORD data_size, DWORD flags)
{
struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
TRACE("iface %p, guid %s, data %p, data_size %lu, flags %#lx.\n",
iface, debugstr_guid(guid), data, data_size, flags);
return d3d8_resource_set_private_data(&texture->resource, guid, data, data_size, flags);
@ -478,7 +478,7 @@ static DWORD WINAPI d3d8_texture_cube_SetPriority(IDirect3DCubeTexture8 *iface,
struct wined3d_resource *resource;
DWORD ret;
TRACE("iface %p, priority %u.\n", iface, priority);
TRACE("iface %p, priority %lu.\n", iface, priority);
wined3d_mutex_lock();
resource = wined3d_texture_get_resource(d3d8_texture_get_draw_texture(texture));
@ -525,7 +525,7 @@ static DWORD WINAPI d3d8_texture_cube_SetLOD(IDirect3DCubeTexture8 *iface, DWORD
struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);
DWORD ret;
TRACE("iface %p, lod %u.\n", iface, lod);
TRACE("iface %p, lod %lu.\n", iface, lod);
wined3d_mutex_lock();
ret = wined3d_texture_set_lod(d3d8_texture_get_draw_texture(texture), lod);
@ -634,7 +634,7 @@ static HRESULT WINAPI d3d8_texture_cube_LockRect(IDirect3DCubeTexture8 *iface,
UINT sub_resource_idx;
HRESULT hr;
TRACE("iface %p, face %#x, level %u, locked_rect %p, rect %p, flags %#x.\n",
TRACE("iface %p, face %#x, level %u, locked_rect %p, rect %p, flags %#lx.\n",
iface, face, level, locked_rect, rect, flags);
wined3d_mutex_lock();
@ -772,7 +772,7 @@ static HRESULT WINAPI d3d8_texture_3d_SetPrivateData(IDirect3DVolumeTexture8 *if
REFGUID guid, const void *data, DWORD data_size, DWORD flags)
{
struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
TRACE("iface %p, guid %s, data %p, data_size %lu, flags %#lx.\n",
iface, debugstr_guid(guid), data, data_size, flags);
return d3d8_resource_set_private_data(&texture->resource, guid, data, data_size, flags);
@ -802,7 +802,7 @@ static DWORD WINAPI d3d8_texture_3d_SetPriority(IDirect3DVolumeTexture8 *iface,
struct wined3d_resource *resource;
DWORD ret;
TRACE("iface %p, priority %u.\n", iface, priority);
TRACE("iface %p, priority %lu.\n", iface, priority);
wined3d_mutex_lock();
resource = wined3d_texture_get_resource(d3d8_texture_get_draw_texture(texture));
@ -849,7 +849,7 @@ static DWORD WINAPI d3d8_texture_3d_SetLOD(IDirect3DVolumeTexture8 *iface, DWORD
struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);
DWORD ret;
TRACE("iface %p, lod %u.\n", iface, lod);
TRACE("iface %p, lod %lu.\n", iface, lod);
wined3d_mutex_lock();
ret = wined3d_texture_set_lod(d3d8_texture_get_draw_texture(texture), lod);
@ -940,7 +940,7 @@ static HRESULT WINAPI d3d8_texture_3d_LockBox(IDirect3DVolumeTexture8 *iface,
struct d3d8_volume *volume_impl;
HRESULT hr;
TRACE("iface %p, level %u, locked_box %p, box %p, flags %#x.\n",
TRACE("iface %p, level %u, locked_box %p, box %p, flags %#lx.\n",
iface, level, locked_box, box, flags);
wined3d_mutex_lock();
@ -1076,7 +1076,7 @@ static HRESULT d3d8_texture_init(struct d3d8_texture *texture, struct d3d8_devic
NULL, texture, &d3d8_null_wined3d_parent_ops, &texture->wined3d_texture)))
{
wined3d_mutex_unlock();
WARN("Failed to create sysmem texture, hr %#x.\n", hr);
WARN("Failed to create sysmem texture, hr %#lx.\n", hr);
return hr;
}
@ -1087,7 +1087,7 @@ static HRESULT d3d8_texture_init(struct d3d8_texture *texture, struct d3d8_devic
{
wined3d_texture_decref(texture->wined3d_texture);
wined3d_mutex_unlock();
WARN("Failed to create draw texture, hr %#x.\n", hr);
WARN("Failed to create draw texture, hr %#lx.\n", hr);
return hr;
}
}
@ -1097,7 +1097,7 @@ static HRESULT d3d8_texture_init(struct d3d8_texture *texture, struct d3d8_devic
NULL, texture, &d3d8_texture_wined3d_parent_ops, &texture->wined3d_texture)))
{
wined3d_mutex_unlock();
WARN("Failed to create wined3d texture, hr %#x.\n", hr);
WARN("Failed to create wined3d texture, hr %#lx.\n", hr);
return hr;
}
}

28
dlls/d3d8/vertexdeclaration.c
View file

@ -76,26 +76,26 @@ size_t parse_token(const DWORD* pToken)
switch ((token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) { /* maybe a macro to inverse ... */
case D3DVSD_TOKEN_NOP:
TRACE(" 0x%08x NOP()\n", token);
TRACE(" 0x%08lx NOP()\n", token);
break;
case D3DVSD_TOKEN_STREAM:
if (token & D3DVSD_STREAMTESSMASK)
{
TRACE(" 0x%08x STREAM_TESS()\n", token);
TRACE(" 0x%08lx STREAM_TESS()\n", token);
} else {
TRACE(" 0x%08x STREAM(%u)\n", token, ((token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT));
TRACE(" 0x%08lx STREAM(%lu)\n", token, ((token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT));
}
break;
case D3DVSD_TOKEN_STREAMDATA:
if (token & 0x10000000)
{
TRACE(" 0x%08x SKIP(%u)\n", token, ((token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT));
TRACE(" 0x%08lx SKIP(%lu)\n", token, ((token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT));
} else {
DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
TRACE(" 0x%08x REG(%s, %s)\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type));
TRACE(" 0x%08lx REG(%s, %s)\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type));
}
break;
@ -104,12 +104,12 @@ size_t parse_token(const DWORD* pToken)
{
DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
TRACE(" 0x%08x TESSUV(%s) as %s\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type));
TRACE(" 0x%08lx TESSUV(%s) as %s\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type));
} else {
DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
DWORD regout = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
DWORD regin = ((token & D3DVSD_VERTEXREGINMASK) >> D3DVSD_VERTEXREGINSHIFT);
TRACE(" 0x%08x TESSNORMAL(%s, %s) as %s\n", token, debug_d3dvsde_register(regin),
TRACE(" 0x%08lx TESSNORMAL(%s, %s) as %s\n", token, debug_d3dvsde_register(regin),
debug_d3dvsde_register(regout), debug_d3dvsdt_type(type));
}
break;
@ -125,18 +125,18 @@ size_t parse_token(const DWORD* pToken)
{
DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
DWORD extinfo = ((token & D3DVSD_EXTINFOMASK) >> D3DVSD_EXTINFOSHIFT);
TRACE(" 0x%08x EXT(%u, %u)\n", token, count, extinfo);
TRACE(" 0x%08lx EXT(%lu, %lu)\n", token, count, extinfo);
/* todo ... print extension */
tokenlen = count + 1;
}
break;
case D3DVSD_TOKEN_END:
TRACE(" 0x%08x END()\n", token);
TRACE(" 0x%08lx END()\n", token);
break;
default:
TRACE(" 0x%08x UNKNOWN\n", token);
TRACE(" 0x%08lx UNKNOWN\n", token);
/* arg error */
}
@ -160,7 +160,7 @@ void load_local_constants(const DWORD *d3d8_elements, struct wined3d_shader *win
DWORD i;
for (i = 0; i < count; ++i)
{
TRACE("c[%u] = (%8f, %8f, %8f, %8f)\n",
TRACE("c[%lu] = (%8f, %8f, %8f, %8f)\n",
constant_idx,
*(const float *)(token + i * 4 + 1),
*(const float *)(token + i * 4 + 2),
@ -291,7 +291,7 @@ static UINT convert_to_wined3d_declaration(const DWORD *d3d8_elements, DWORD *d3
offset += wined3d_type_sizes[type];
} else if (token_type == D3DVSD_TOKEN_STREAMDATA && (*token & D3DVSD_DATALOADTYPEMASK)) {
TRACE(" 0x%08x SKIP(%u)\n", *token, (*token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT);
TRACE(" 0x%08lx SKIP(%lu)\n", *token, (*token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT);
offset += sizeof(DWORD) * ((*token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT);
}
@ -354,7 +354,7 @@ HRESULT d3d8_vertex_declaration_init(struct d3d8_vertex_declaration *declaration
heap_free(wined3d_elements);
if (FAILED(hr))
{
WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr);
WARN("Failed to create wined3d vertex declaration, hr %#lx.\n", hr);
heap_free(declaration->elements);
if (hr == E_INVALIDARG)
hr = E_FAIL;
@ -378,7 +378,7 @@ HRESULT d3d8_vertex_declaration_init_fvf(struct d3d8_vertex_declaration *declara
&d3d8_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_vertex_declaration);
if (FAILED(hr))
{
WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr);
WARN("Failed to create wined3d vertex declaration, hr %#lx.\n", hr);
if (hr == E_INVALIDARG)
hr = E_FAIL;
return hr;

5
dlls/d3d8/volume.c
View file

@ -78,7 +78,7 @@ static HRESULT WINAPI d3d8_volume_SetPrivateData(IDirect3DVolume8 *iface, REFGUI
const void *data, DWORD data_size, DWORD flags)
{
struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface);
TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
TRACE("iface %p, guid %s, data %p, data_size %lu, flags %#lx.\n",
iface, debugstr_guid(guid), data, data_size, flags);
return d3d8_resource_set_private_data(&volume->resource, guid, data, data_size, flags);
@ -141,8 +141,7 @@ static HRESULT WINAPI d3d8_volume_LockBox(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);
TRACE("iface %p, locked_box %p, box %p, flags %#lx.\n", iface, locked_box, box, flags);
if (FAILED(hr = wined3d_resource_map(wined3d_texture_get_resource(volume->wined3d_texture),
volume->sub_resource_idx, &map_desc, (const struct wined3d_box *)box,