[PATCH 1/2] d3d8: Build without -DWINE_NO_LONG_TYPES.

[Zebediah Figura]

From: Zebediah Figura

---
 dlls/d3d8/Makefile.in         |   1 -
 dlls/d3d8/buffer.c            |  24 ++---
 dlls/d3d8/device.c            | 186 +++++++++++++++++-----------------
 dlls/d3d8/directx.c           |  16 +--
 dlls/d3d8/shader.c            |  12 +--
 dlls/d3d8/surface.c           |  10 +-
 dlls/d3d8/swapchain.c         |   8 +-
 dlls/d3d8/texture.c           |  34 +++----
 dlls/d3d8/vertexdeclaration.c |  28 ++---
 dlls/d3d8/volume.c            |   5 +-
 10 files changed, 159 insertions(+), 165 deletions(-)

diff --git a/dlls/d3d8/Makefile.in b/dlls/d3d8/Makefile.in
index 29ef6585b57..542a052512f 100644
--- a/dlls/d3d8/Makefile.in
+++ b/dlls/d3d8/Makefile.in
@@ -1,4 +1,3 @@
-EXTRADEFS = -DWINE_NO_LONG_TYPES
 MODULE    = d3d8.dll
 IMPORTLIB = d3d8
 IMPORTS   = dxguid uuid wined3d
diff --git a/dlls/d3d8/buffer.c b/dlls/d3d8/buffer.c
index 1b5098c64c9..2b0f0a41888 100644
--- a/dlls/d3d8/buffer.c
+++ b/dlls/d3d8/buffer.c
@@ -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;
     }

diff --git a/dlls/d3d8/device.c b/dlls/d3d8/device.c
index b0be9007ea2..fb7e25a6bc1 100644
--- a/dlls/d3d8/device.c
+++ b/dlls/d3d8/device.c
@@ -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();
diff --git a/dlls/d3d8/directx.c b/dlls/d3d8/directx.c
index 365a99216aa..bd375aa58a4 100644
--- a/dlls/d3d8/directx.c
+++ b/dlls/d3d8/directx.c
@@ -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;
     }
diff --git a/dlls/d3d8/shader.c b/dlls/d3d8/shader.c
index d88f4b9a9ab..bcd024d30dc 100644
--- a/dlls/d3d8/shader.c
+++ b/dlls/d3d8/shader.c
@@ -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;
     }

diff --git a/dlls/d3d8/surface.c b/dlls/d3d8/surface.c
index 62c3a429ba6..bd07a077d08 100644
--- a/dlls/d3d8/surface.c
+++ b/dlls/d3d8/surface.c
@@ -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;
     }
diff --git a/dlls/d3d8/swapchain.c b/dlls/d3d8/swapchain.c
index 78db4fcaf24..476846d7e89 100644
--- a/dlls/d3d8/swapchain.c
+++ b/dlls/d3d8/swapchain.c
@@ -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;
     }
diff --git a/dlls/d3d8/texture.c b/dlls/d3d8/texture.c
index ca366206999..28940f6875c 100644
--- a/dlls/d3d8/texture.c
+++ b/dlls/d3d8/texture.c
@@ -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;
         }
     }
diff --git a/dlls/d3d8/vertexdeclaration.c b/dlls/d3d8/vertexdeclaration.c
index e63e379444e..ff5a1ae2d5f 100644
--- a/dlls/d3d8/vertexdeclaration.c
+++ b/dlls/d3d8/vertexdeclaration.c
@@ -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;
diff --git a/dlls/d3d8/volume.c b/dlls/d3d8/volume.c
index 6d0d6f7cb22..2774195075e 100644
--- a/dlls/d3d8/volume.c
+++ b/dlls/d3d8/volume.c
@@ -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,