https://git.reactos.org/?p=reactos.git;a=commitdiff;h=9987f02917539e05268ba2...
commit 9987f02917539e05268ba2ad11e62d24a3636972 Author: Amine Khaldi amine.khaldi@reactos.org AuthorDate: Thu Mar 8 13:15:18 2018 +0100 Commit: Amine Khaldi amine.khaldi@reactos.org CommitDate: Thu Mar 8 13:15:18 2018 +0100
[D3D8][D3D9][DDRAW][WINED3D] Sync with Wine Staging 3.3. CORE-14434 --- dll/directx/wine/d3d8/CMakeLists.txt | 4 +- dll/directx/wine/d3d8/buffer.c | 55 +- dll/directx/wine/d3d8/d3d8_main.c | 89 +- dll/directx/wine/d3d8/d3d8_private.h | 63 +- dll/directx/wine/d3d8/device.c | 202 ++- dll/directx/wine/d3d8/directx.c | 22 +- dll/directx/wine/d3d8/precomp.h | 13 + dll/directx/wine/d3d8/shader.c | 12 +- dll/directx/wine/d3d8/surface.c | 11 +- dll/directx/wine/d3d8/swapchain.c | 11 +- dll/directx/wine/d3d8/texture.c | 37 +- dll/directx/wine/d3d8/vertexdeclaration.c | 18 +- dll/directx/wine/d3d8/volume.c | 14 +- dll/directx/wine/d3d9/CMakeLists.txt | 4 +- dll/directx/wine/d3d9/buffer.c | 57 +- dll/directx/wine/d3d9/d3d9_main.c | 12 +- dll/directx/wine/d3d9/d3d9_private.h | 86 +- dll/directx/wine/d3d9/device.c | 310 +++-- dll/directx/wine/d3d9/directx.c | 17 +- dll/directx/wine/d3d9/precomp.h | 13 + dll/directx/wine/d3d9/query.c | 5 +- dll/directx/wine/d3d9/shader.c | 7 +- dll/directx/wine/d3d9/stateblock.c | 5 +- dll/directx/wine/d3d9/surface.c | 15 +- dll/directx/wine/d3d9/swapchain.c | 11 +- dll/directx/wine/d3d9/texture.c | 359 ++++-- dll/directx/wine/d3d9/vertexdeclaration.c | 33 +- dll/directx/wine/d3d9/volume.c | 14 +- dll/directx/wine/ddraw/CMakeLists.txt | 4 +- dll/directx/wine/ddraw/clipper.c | 7 +- dll/directx/wine/ddraw/ddraw.c | 244 +++- dll/directx/wine/ddraw/ddraw_private.h | 38 +- dll/directx/wine/ddraw/device.c | 104 +- dll/directx/wine/ddraw/executebuffer.c | 70 +- dll/directx/wine/ddraw/light.c | 7 +- dll/directx/wine/ddraw/main.c | 36 +- dll/directx/wine/ddraw/material.c | 10 +- dll/directx/wine/ddraw/palette.c | 7 +- dll/directx/wine/ddraw/precomp.h | 15 + dll/directx/wine/ddraw/surface.c | 277 +++-- dll/directx/wine/ddraw/utils.c | 55 +- dll/directx/wine/ddraw/vertexbuffer.c | 52 +- dll/directx/wine/ddraw/viewport.c | 11 +- dll/directx/wine/wined3d/CMakeLists.txt | 5 +- dll/directx/wine/wined3d/arb_program_shader.c | 182 +-- dll/directx/wine/wined3d/ati_fragment_shader.c | 23 +- dll/directx/wine/wined3d/buffer.c | 149 +-- dll/directx/wine/wined3d/context.c | 1436 ++++++++++++++++++---- dll/directx/wine/wined3d/cs.c | 209 +++- dll/directx/wine/wined3d/device.c | 543 +++++--- dll/directx/wine/wined3d/directx.c | 417 ++++--- dll/directx/wine/wined3d/drawprim.c | 785 ------------ dll/directx/wine/wined3d/dxtn.c | 5 +- dll/directx/wine/wined3d/gl_compat.c | 8 + dll/directx/wine/wined3d/glsl_shader.c | 796 +++++------- dll/directx/wine/wined3d/nvidia_texture_shader.c | 4 + dll/directx/wine/wined3d/palette.c | 10 +- dll/directx/wine/wined3d/precomp.h | 44 + dll/directx/wine/wined3d/query.c | 134 +- dll/directx/wine/wined3d/resource.c | 227 +++- dll/directx/wine/wined3d/sampler.c | 7 +- dll/directx/wine/wined3d/shader.c | 165 +-- dll/directx/wine/wined3d/shader_sm1.c | 9 +- dll/directx/wine/wined3d/shader_sm4.c | 11 +- dll/directx/wine/wined3d/state.c | 324 +++-- dll/directx/wine/wined3d/stateblock.c | 27 +- dll/directx/wine/wined3d/surface.c | 684 +++++++---- dll/directx/wine/wined3d/swapchain.c | 64 +- dll/directx/wine/wined3d/texture.c | 1263 ++++++++++++++----- dll/directx/wine/wined3d/utils.c | 494 +++++++- dll/directx/wine/wined3d/vertexdeclaration.c | 30 +- dll/directx/wine/wined3d/view.c | 64 +- dll/directx/wine/wined3d/wined3d.spec | 26 +- dll/directx/wine/wined3d/wined3d_gl.h | 8 +- dll/directx/wine/wined3d/wined3d_main.c | 37 +- dll/directx/wine/wined3d/wined3d_private.h | 275 +++-- media/doc/README.WINE | 8 +- sdk/include/reactos/wine/wined3d.h | 163 ++- 78 files changed, 7134 insertions(+), 3938 deletions(-)
diff --git a/dll/directx/wine/d3d8/CMakeLists.txt b/dll/directx/wine/d3d8/CMakeLists.txt index bad1641fea..09d7a6c659 100644 --- a/dll/directx/wine/d3d8/CMakeLists.txt +++ b/dll/directx/wine/d3d8/CMakeLists.txt @@ -17,7 +17,7 @@ list(APPEND SOURCE texture.c vertexdeclaration.c volume.c - d3d8_private.h) + precomp.h)
add_library(d3d8 SHARED ${SOURCE} @@ -28,5 +28,5 @@ add_library(d3d8 SHARED set_module_type(d3d8 win32dll UNICODE) target_link_libraries(d3d8 uuid wine) add_importlibs(d3d8 d3dwine msvcrt kernel32 ntdll) -add_pch(d3d8 d3d8_private.h SOURCE) +add_pch(d3d8 precomp.h SOURCE) add_cd_file(TARGET d3d8 DESTINATION reactos/system32 FOR all) diff --git a/dll/directx/wine/d3d8/buffer.c b/dll/directx/wine/d3d8/buffer.c index d778e58360..fb6b7bc1e9 100644 --- a/dll/directx/wine/d3d8/buffer.c +++ b/dll/directx/wine/d3d8/buffer.c @@ -16,8 +16,11 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d8_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d8); + static inline struct d3d8_vertexbuffer *impl_from_IDirect3DVertexBuffer8(IDirect3DVertexBuffer8 *iface) { return CONTAINING_RECORD(iface, struct d3d8_vertexbuffer, IDirect3DVertexBuffer8_iface); @@ -190,7 +193,7 @@ static HRESULT WINAPI d3d8_vertexbuffer_Lock(IDirect3DVertexBuffer8 *iface, UINT wined3d_box.right = offset + size; wined3d_mutex_lock(); hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->wined3d_buffer), - 0, &wined3d_map_desc, &wined3d_box, flags); + 0, &wined3d_map_desc, &wined3d_box, wined3dmapflags_from_d3dmapflags(flags)); wined3d_mutex_unlock(); *data = wined3d_map_desc.data;
@@ -224,12 +227,12 @@ static HRESULT WINAPI d3d8_vertexbuffer_GetDesc(IDirect3DVertexBuffer8 *iface, wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); wined3d_mutex_unlock();
+ desc->Format = D3DFMT_VERTEXDATA; desc->Type = D3DRTYPE_VERTEXBUFFER; - desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; - desc->Pool = wined3d_desc.pool; + desc->Usage = d3dusage_from_wined3dusage(wined3d_desc.usage); + desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage); desc->Size = wined3d_desc.size; desc->FVF = buffer->fvf; - desc->Format = D3DFMT_VERTEXDATA;
return D3D_OK; } @@ -259,7 +262,7 @@ static void STDMETHODCALLTYPE d3d8_vertexbuffer_wined3d_object_destroyed(void *p { struct d3d8_vertexbuffer *buffer = parent; d3d8_resource_cleanup(&buffer->resource); - HeapFree(GetProcessHeap(), 0, buffer); + heap_free(buffer); }
static const struct wined3d_parent_ops d3d8_vertexbuffer_wined3d_parent_ops = @@ -270,15 +273,30 @@ static const struct wined3d_parent_ops d3d8_vertexbuffer_wined3d_parent_ops = HRESULT vertexbuffer_init(struct d3d8_vertexbuffer *buffer, struct d3d8_device *device, UINT size, DWORD usage, DWORD fvf, D3DPOOL pool) { + struct wined3d_buffer_desc desc; HRESULT hr;
+ if (pool == D3DPOOL_SCRATCH) + { + WARN("Vertex buffer with D3DPOOL_SCRATCH requested.\n"); + return D3DERR_INVALIDCALL; + } + buffer->IDirect3DVertexBuffer8_iface.lpVtbl = &Direct3DVertexBuffer8_Vtbl; d3d8_resource_init(&buffer->resource); buffer->fvf = fvf;
+ desc.byte_width = size; + desc.usage = usage & WINED3DUSAGE_MASK; + desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER; + desc.access = wined3daccess_from_d3dpool(pool, usage) + | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + desc.misc_flags = 0; + desc.structure_byte_stride = 0; + wined3d_mutex_lock(); - hr = wined3d_buffer_create_vb(device->wined3d_device, size, usage & WINED3DUSAGE_MASK, - (enum wined3d_pool)pool, buffer, &d3d8_vertexbuffer_wined3d_parent_ops, &buffer->wined3d_buffer); + hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer, + &d3d8_vertexbuffer_wined3d_parent_ops, &buffer->wined3d_buffer); wined3d_mutex_unlock(); if (FAILED(hr)) { @@ -473,7 +491,7 @@ static HRESULT WINAPI d3d8_indexbuffer_Lock(IDirect3DIndexBuffer8 *iface, UINT o wined3d_box.right = offset + size; wined3d_mutex_lock(); hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->wined3d_buffer), - 0, &wined3d_map_desc, &wined3d_box, flags); + 0, &wined3d_map_desc, &wined3d_box, wined3dmapflags_from_d3dmapflags(flags)); wined3d_mutex_unlock(); *data = wined3d_map_desc.data;
@@ -509,8 +527,8 @@ static HRESULT WINAPI d3d8_indexbuffer_GetDesc(IDirect3DIndexBuffer8 *iface,
desc->Format = d3dformat_from_wined3dformat(buffer->format); desc->Type = D3DRTYPE_INDEXBUFFER; - desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; - desc->Pool = wined3d_desc.pool; + desc->Usage = d3dusage_from_wined3dusage(wined3d_desc.usage); + desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage); desc->Size = wined3d_desc.size;
return D3D_OK; @@ -541,7 +559,7 @@ static void STDMETHODCALLTYPE d3d8_indexbuffer_wined3d_object_destroyed(void *pa { struct d3d8_indexbuffer *buffer = parent; d3d8_resource_cleanup(&buffer->resource); - HeapFree(GetProcessHeap(), 0, buffer); + heap_free(buffer); }
static const struct wined3d_parent_ops d3d8_indexbuffer_wined3d_parent_ops = @@ -552,15 +570,26 @@ static const struct wined3d_parent_ops d3d8_indexbuffer_wined3d_parent_ops = HRESULT indexbuffer_init(struct d3d8_indexbuffer *buffer, struct d3d8_device *device, UINT size, DWORD usage, D3DFORMAT format, D3DPOOL pool) { + struct wined3d_buffer_desc desc; HRESULT hr;
+ desc.byte_width = size; + desc.usage = (usage & WINED3DUSAGE_MASK) | WINED3DUSAGE_STATICDECL; + if (pool == D3DPOOL_SCRATCH) + desc.usage |= WINED3DUSAGE_SCRATCH; + desc.bind_flags = WINED3D_BIND_INDEX_BUFFER; + desc.access = wined3daccess_from_d3dpool(pool, usage) + | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + desc.misc_flags = 0; + desc.structure_byte_stride = 0; + buffer->IDirect3DIndexBuffer8_iface.lpVtbl = &d3d8_indexbuffer_vtbl; d3d8_resource_init(&buffer->resource); buffer->format = wined3dformat_from_d3dformat(format);
wined3d_mutex_lock(); - hr = wined3d_buffer_create_ib(device->wined3d_device, size, usage & WINED3DUSAGE_MASK, - (enum wined3d_pool)pool, buffer, &d3d8_indexbuffer_wined3d_parent_ops, &buffer->wined3d_buffer); + hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer, + &d3d8_indexbuffer_wined3d_parent_ops, &buffer->wined3d_buffer); wined3d_mutex_unlock(); if (FAILED(hr)) { diff --git a/dll/directx/wine/d3d8/d3d8_main.c b/dll/directx/wine/d3d8/d3d8_main.c index 144817a545..0e686308f0 100644 --- a/dll/directx/wine/d3d8/d3d8_main.c +++ b/dll/directx/wine/d3d8/d3d8_main.c @@ -19,7 +19,12 @@ * */
+#include "config.h" +#include "initguid.h" #include "d3d8_private.h" +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d8);
HRESULT WINAPI D3D8GetSWInfo(void) { FIXME("(void): stub\n"); @@ -36,13 +41,13 @@ IDirect3D8 * WINAPI DECLSPEC_HOTPATCH Direct3DCreate8(UINT sdk_version)
TRACE("sdk_version %#x.\n", sdk_version);
- if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)))) + if (!(object = heap_alloc_zero(sizeof(*object)))) return NULL;
if (!d3d8_init(object)) { WARN("Failed to initialize d3d8.\n"); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return NULL; }
@@ -53,75 +58,73 @@ IDirect3D8 * WINAPI DECLSPEC_HOTPATCH Direct3DCreate8(UINT sdk_version)
/*********************************************************************** * ValidateVertexShader (D3D8.@) - * - * I've seen reserved1 and reserved2 always passed as 0's - * bool seems always passed as 0 or 1, but other values work as well... - * toto result? */ -HRESULT WINAPI ValidateVertexShader(DWORD* vertexshader, DWORD* reserved1, DWORD* reserved2, BOOL bool, DWORD* toto) +HRESULT WINAPI ValidateVertexShader(DWORD *vertexshader, DWORD *reserved1, DWORD *reserved2, + BOOL return_error, char **errors) { - HRESULT ret; - static BOOL warned; - - if (TRACE_ON(d3d8) || !warned) { - FIXME("(%p %p %p %d %p): stub\n", vertexshader, reserved1, reserved2, bool, toto); - warned = TRUE; - } + const char *message = ""; + HRESULT hr = E_FAIL;
- if (!vertexshader) - return E_FAIL; + TRACE("(%p %p %p %d %p): semi-stub\n", vertexshader, reserved1, reserved2, return_error, errors);
- if (reserved1 || reserved2) - return E_FAIL; + if (!vertexshader) + { + message = "(Global Validation Error) Version Token: Code pointer cannot be NULL.\n"; + goto done; + }
- switch(*vertexshader) { + switch (*vertexshader) + { case 0xFFFE0101: case 0xFFFE0100: - ret=S_OK; + hr = S_OK; break; + default: WARN("Invalid shader version token %#x.\n", *vertexshader); - ret=E_FAIL; - } + message = "(Global Validation Error) Version Token: Unsupported vertex shader version.\n"; + }
- return ret; +done: + if (!return_error) message = ""; + if (errors && (*errors = HeapAlloc(GetProcessHeap(), 0, strlen(message) + 1))) + strcpy(*errors, message); + + return hr; }
/*********************************************************************** * ValidatePixelShader (D3D8.@) - * - * PARAMS - * toto result? */ -HRESULT WINAPI ValidatePixelShader(DWORD* pixelshader, DWORD* reserved1, BOOL bool, DWORD* toto) +HRESULT WINAPI ValidatePixelShader(DWORD *pixelshader, DWORD *reserved1, BOOL return_error, char **errors) { - HRESULT ret; - static BOOL warned; - - if (TRACE_ON(d3d8) || !warned) { - FIXME("(%p %p %d %p): stub\n", pixelshader, reserved1, bool, toto); - warned = TRUE; - } + const char *message = ""; + HRESULT hr = E_FAIL;
- if (!pixelshader) - return E_FAIL; + TRACE("(%p %p %d %p): semi-stub\n", pixelshader, reserved1, return_error, errors);
- if (reserved1) - return E_FAIL; + if (!pixelshader) + return E_FAIL;
- switch(*pixelshader) { + switch (*pixelshader) + { case 0xFFFF0100: case 0xFFFF0101: case 0xFFFF0102: case 0xFFFF0103: case 0xFFFF0104: - ret=S_OK; + hr = S_OK; break; default: WARN("Invalid shader version token %#x.\n", *pixelshader); - ret=E_FAIL; - } - return ret; + message = "(Global Validation Error) Version Token: Unsupported pixel shader version.\n"; + } + + if (!return_error) message = ""; + if (errors && (*errors = HeapAlloc(GetProcessHeap(), 0, strlen(message) + 1))) + strcpy(*errors, message); + + return hr; }
void d3d8_resource_cleanup(struct d3d8_resource *resource) diff --git a/dll/directx/wine/d3d8/d3d8_private.h b/dll/directx/wine/d3d8/d3d8_private.h index a85e2995cb..cba5dd647b 100644 --- a/dll/directx/wine/d3d8/d3d8_private.h +++ b/dll/directx/wine/d3d8/d3d8_private.h @@ -23,27 +23,19 @@ #ifndef __WINE_D3D8_PRIVATE_H #define __WINE_D3D8_PRIVATE_H
-#include <config.h> - #include <assert.h> #include <stdarg.h>
-#define WIN32_NO_STATUS -#define _INC_WINDOWS -#define COM_NO_WINDOWS_H - #define NONAMELESSUNION #define NONAMELESSSTRUCT #define COBJMACROS -#include <windef.h> -#include <winbase.h> -#include <wingdi.h> - -#include <wine/debug.h> -WINE_DEFAULT_DEBUG_CHANNEL(d3d8); - -#include <d3d8.h> -#include <wine/wined3d.h> +#include "windef.h" +#include "winbase.h" +#include "wingdi.h" +#include "wine/debug.h" +#include "wine/heap.h" +#include "d3d8.h" +#include "wine/wined3d.h"
#define D3DPRESENTFLAGS_MASK 0x00000fffu
@@ -281,7 +273,48 @@ HRESULT d3d8_pixel_shader_init(struct d3d8_pixel_shader *shader, struct d3d8_dev
D3DFORMAT d3dformat_from_wined3dformat(enum wined3d_format_id format) DECLSPEC_HIDDEN; enum wined3d_format_id wined3dformat_from_d3dformat(D3DFORMAT format) DECLSPEC_HIDDEN; +unsigned int wined3dmapflags_from_d3dmapflags(unsigned int flags) DECLSPEC_HIDDEN; void load_local_constants(const DWORD *d3d8_elements, struct wined3d_shader *wined3d_vertex_shader) DECLSPEC_HIDDEN; size_t parse_token(const DWORD *pToken) DECLSPEC_HIDDEN;
+static inline DWORD d3dusage_from_wined3dusage(unsigned int usage) +{ + return usage & WINED3DUSAGE_MASK; +} + +static inline D3DPOOL d3dpool_from_wined3daccess(unsigned int access, unsigned int usage) +{ + switch (access & (WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_CPU)) + { + default: + case WINED3D_RESOURCE_ACCESS_GPU: + return D3DPOOL_DEFAULT; + case WINED3D_RESOURCE_ACCESS_CPU: + if (usage & WINED3DUSAGE_SCRATCH) + return D3DPOOL_SCRATCH; + return D3DPOOL_SYSTEMMEM; + case WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_CPU: + return D3DPOOL_MANAGED; + } +} + +static inline unsigned int wined3daccess_from_d3dpool(D3DPOOL pool, unsigned int usage) +{ + switch (pool) + { + case D3DPOOL_DEFAULT: + if (usage & D3DUSAGE_DYNAMIC) + return WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + return WINED3D_RESOURCE_ACCESS_GPU; + case D3DPOOL_MANAGED: + return WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_CPU + | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + case D3DPOOL_SYSTEMMEM: + case D3DPOOL_SCRATCH: + return WINED3D_RESOURCE_ACCESS_CPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + default: + return 0; + } +} + #endif /* __WINE_D3DX8_PRIVATE_H */ diff --git a/dll/directx/wine/d3d8/device.c b/dll/directx/wine/d3d8/device.c index 6573baa355..5daf6f46c2 100644 --- a/dll/directx/wine/d3d8/device.c +++ b/dll/directx/wine/d3d8/device.c @@ -19,8 +19,21 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" + +#include <math.h> +#include <stdarg.h> + +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + #include "d3d8_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d8); + static void STDMETHODCALLTYPE d3d8_null_wined3d_object_destroyed(void *parent) {}
static const struct wined3d_parent_ops d3d8_null_wined3d_parent_ops = @@ -128,6 +141,29 @@ enum wined3d_format_id wined3dformat_from_d3dformat(D3DFORMAT format) } }
+unsigned int wined3dmapflags_from_d3dmapflags(unsigned int flags) +{ + static const unsigned int handled = D3DLOCK_NOSYSLOCK + | D3DLOCK_NOOVERWRITE + | D3DLOCK_DISCARD + | D3DLOCK_NO_DIRTY_UPDATE; + unsigned int wined3d_flags; + + wined3d_flags = flags & handled; + if (!(flags & (D3DLOCK_NOOVERWRITE | D3DLOCK_DISCARD))) + wined3d_flags |= WINED3D_MAP_READ; + if (!(flags & D3DLOCK_READONLY)) + wined3d_flags |= WINED3D_MAP_WRITE; + if (!(wined3d_flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE))) + wined3d_flags |= WINED3D_MAP_READ | WINED3D_MAP_WRITE; + flags &= ~(handled | D3DLOCK_READONLY); + + if (flags) + FIXME("Unhandled flags %#x.\n", flags); + + return wined3d_flags; +} + static UINT vertex_count_from_primitive_count(D3DPRIMITIVETYPE primitive_type, UINT primitive_count) { switch (primitive_type) @@ -154,6 +190,24 @@ static UINT vertex_count_from_primitive_count(D3DPRIMITIVETYPE primitive_type, U } }
+static D3DSWAPEFFECT d3dswapeffect_from_wined3dswapeffect(enum wined3d_swap_effect effect) +{ + switch (effect) + { + case WINED3D_SWAP_EFFECT_DISCARD: + return D3DSWAPEFFECT_DISCARD; + case WINED3D_SWAP_EFFECT_SEQUENTIAL: + return D3DSWAPEFFECT_FLIP; + case WINED3D_SWAP_EFFECT_COPY: + return D3DSWAPEFFECT_COPY; + case WINED3D_SWAP_EFFECT_COPY_VSYNC: + return D3DSWAPEFFECT_COPY_VSYNC; + default: + FIXME("Unhandled swap effect %#x.\n", effect); + return D3DSWAPEFFECT_FLIP; + } +} + static void present_parameters_from_wined3d_swapchain_desc(D3DPRESENT_PARAMETERS *present_parameters, const struct wined3d_swapchain_desc *swapchain_desc) { @@ -162,7 +216,7 @@ static void present_parameters_from_wined3d_swapchain_desc(D3DPRESENT_PARAMETERS present_parameters->BackBufferFormat = d3dformat_from_wined3dformat(swapchain_desc->backbuffer_format); present_parameters->BackBufferCount = swapchain_desc->backbuffer_count; present_parameters->MultiSampleType = swapchain_desc->multisample_type; - present_parameters->SwapEffect = swapchain_desc->swap_effect; + present_parameters->SwapEffect = d3dswapeffect_from_wined3dswapeffect(swapchain_desc->swap_effect); present_parameters->hDeviceWindow = swapchain_desc->device_window; present_parameters->Windowed = swapchain_desc->windowed; present_parameters->EnableAutoDepthStencil = swapchain_desc->enable_auto_depth_stencil; @@ -173,6 +227,24 @@ static void present_parameters_from_wined3d_swapchain_desc(D3DPRESENT_PARAMETERS present_parameters->FullScreen_PresentationInterval = swapchain_desc->swap_interval; }
+static enum wined3d_swap_effect wined3dswapeffect_from_d3dswapeffect(D3DSWAPEFFECT effect) +{ + switch (effect) + { + case D3DSWAPEFFECT_DISCARD: + return WINED3D_SWAP_EFFECT_DISCARD; + case D3DSWAPEFFECT_FLIP: + return WINED3D_SWAP_EFFECT_SEQUENTIAL; + case D3DSWAPEFFECT_COPY: + return WINED3D_SWAP_EFFECT_COPY; + case D3DSWAPEFFECT_COPY_VSYNC: + return WINED3D_SWAP_EFFECT_COPY_VSYNC; + default: + FIXME("Unhandled swap effect %#x.\n", effect); + return WINED3D_SWAP_EFFECT_SEQUENTIAL; + } +} + static BOOL wined3d_swapchain_desc_from_present_parameters(struct wined3d_swapchain_desc *swapchain_desc, const D3DPRESENT_PARAMETERS *present_parameters) { @@ -194,9 +266,10 @@ static BOOL wined3d_swapchain_desc_from_present_parameters(struct wined3d_swapch swapchain_desc->backbuffer_height = present_parameters->BackBufferHeight; swapchain_desc->backbuffer_format = wined3dformat_from_d3dformat(present_parameters->BackBufferFormat); swapchain_desc->backbuffer_count = max(1, present_parameters->BackBufferCount); + swapchain_desc->backbuffer_usage = WINED3DUSAGE_RENDERTARGET; swapchain_desc->multisample_type = present_parameters->MultiSampleType; swapchain_desc->multisample_quality = 0; /* d3d9 only */ - swapchain_desc->swap_effect = present_parameters->SwapEffect; + swapchain_desc->swap_effect = wined3dswapeffect_from_d3dswapeffect(present_parameters->SwapEffect); swapchain_desc->device_window = present_parameters->hDeviceWindow; swapchain_desc->windowed = present_parameters->Windowed; swapchain_desc->enable_auto_depth_stencil = present_parameters->EnableAutoDepthStencil; @@ -310,9 +383,9 @@ static DWORD d3d8_allocate_handle(struct d3d8_handle_table *t, void *object, enu { /* Grow the table */ UINT new_size = t->table_size + (t->table_size >> 1); - struct d3d8_handle_entry *new_entries = HeapReAlloc(GetProcessHeap(), - 0, t->entries, new_size * sizeof(*t->entries)); - if (!new_entries) + struct d3d8_handle_entry *new_entries; + + if (!(new_entries = heap_realloc(t->entries, new_size * sizeof(*t->entries)))) { ERR("Failed to grow the handle table.\n"); return D3D8_INVALID_HANDLE; @@ -430,7 +503,7 @@ static ULONG WINAPI d3d8_device_Release(IDirect3DDevice8 *iface) { d3d8_vertex_declaration_destroy(device->decls[i].declaration); } - HeapFree(GetProcessHeap(), 0, device->decls); + heap_free(device->decls);
if (device->vertex_buffer) wined3d_buffer_decref(device->vertex_buffer); @@ -440,8 +513,8 @@ static ULONG WINAPI d3d8_device_Release(IDirect3DDevice8 *iface) wined3d_device_uninit_3d(device->wined3d_device); wined3d_device_release_focus_window(device->wined3d_device); wined3d_device_decref(device->wined3d_device); - HeapFree(GetProcessHeap(), 0, device->handle_table.entries); - HeapFree(GetProcessHeap(), 0, device); + heap_free(device->handle_table.entries); + heap_free(device);
wined3d_mutex_unlock();
@@ -672,7 +745,7 @@ static HRESULT CDECL reset_enum_callback(struct wined3d_resource *resource) IUnknown *parent;
wined3d_resource_get_desc(resource, &desc); - if (desc.pool != WINED3D_POOL_DEFAULT) + if (desc.access & WINED3D_RESOURCE_ACCESS_CPU) return D3D_OK;
if (desc.resource_type != WINED3D_RTYPE_TEXTURE_2D) @@ -849,15 +922,14 @@ static HRESULT WINAPI d3d8_device_CreateTexture(IDirect3DDevice8 *iface, return D3DERR_INVALIDCALL;
*texture = NULL; - object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return D3DERR_OUTOFVIDEOMEMORY;
hr = texture_init(object, device, width, height, levels, usage, format, pool); if (FAILED(hr)) { WARN("Failed to initialize texture, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -882,15 +954,14 @@ static HRESULT WINAPI d3d8_device_CreateVolumeTexture(IDirect3DDevice8 *iface, return D3DERR_INVALIDCALL;
*texture = NULL; - object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return D3DERR_OUTOFVIDEOMEMORY;
hr = volumetexture_init(object, device, width, height, depth, levels, usage, format, pool); if (FAILED(hr)) { WARN("Failed to initialize volume texture, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -914,15 +985,14 @@ static HRESULT WINAPI d3d8_device_CreateCubeTexture(IDirect3DDevice8 *iface, UIN return D3DERR_INVALIDCALL;
*texture = NULL; - object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return D3DERR_OUTOFVIDEOMEMORY;
hr = cubetexture_init(object, device, edge_length, levels, usage, format, pool); if (FAILED(hr)) { WARN("Failed to initialize cube texture, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -942,15 +1012,14 @@ static HRESULT WINAPI d3d8_device_CreateVertexBuffer(IDirect3DDevice8 *iface, UI TRACE("iface %p, size %u, usage %#x, fvf %#x, pool %#x, buffer %p.\n", iface, size, usage, fvf, pool, buffer);
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return D3DERR_OUTOFVIDEOMEMORY;
hr = vertexbuffer_init(object, device, size, usage, fvf, pool); if (FAILED(hr)) { WARN("Failed to initialize vertex buffer, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -970,15 +1039,14 @@ static HRESULT WINAPI d3d8_device_CreateIndexBuffer(IDirect3DDevice8 *iface, UIN TRACE("iface %p, size %u, usage %#x, format %#x, pool %#x, buffer %p.\n", iface, size, usage, format, pool, buffer);
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return D3DERR_OUTOFVIDEOMEMORY;
hr = indexbuffer_init(object, device, size, usage, format, pool); if (FAILED(hr)) { WARN("Failed to initialize index buffer, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -1007,7 +1075,10 @@ static HRESULT d3d8_device_create_surface(struct d3d8_device *device, UINT width desc.multisample_type = multisample_type; desc.multisample_quality = multisample_quality; desc.usage = usage & WINED3DUSAGE_MASK; - desc.pool = pool; + if (pool == D3DPOOL_SCRATCH) + desc.usage |= WINED3DUSAGE_SCRATCH; + desc.access = wined3daccess_from_d3dpool(pool, usage) + | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; desc.width = width; desc.height = height; desc.depth = 1; @@ -2092,15 +2163,22 @@ static HRESULT d3d8_device_prepare_vertex_buffer(struct d3d8_device *device, UIN if (device->vertex_buffer_size < min_size || !device->vertex_buffer) { UINT size = max(device->vertex_buffer_size * 2, min_size); + struct wined3d_buffer_desc desc; struct wined3d_buffer *buffer;
TRACE("Growing vertex buffer to %u bytes\n", size);
- hr = wined3d_buffer_create_vb(device->wined3d_device, size, WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY, - WINED3D_POOL_DEFAULT, NULL, &d3d8_null_wined3d_parent_ops, &buffer); - if (FAILED(hr)) + desc.byte_width = size; + desc.usage = WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY; + desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER; + desc.access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + desc.misc_flags = 0; + desc.structure_byte_stride = 0; + + if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc, + NULL, NULL, &d3d8_null_wined3d_parent_ops, &buffer))) { - ERR("(%p) wined3d_buffer_create_vb failed with hr = %08x\n", device, hr); + ERR("Failed to create vertex buffer, hr %#x.\n", hr); return hr; }
@@ -2153,7 +2231,7 @@ static HRESULT WINAPI d3d8_device_DrawPrimitiveUP(IDirect3DDevice8 *iface, wined3d_box.right = vb_pos + size; vb = wined3d_buffer_get_resource(device->vertex_buffer); if (FAILED(wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box, - vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))) + WINED3D_MAP_WRITE | (vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))) goto done; memcpy(wined3d_map_desc.data, data, size); wined3d_resource_unmap(vb, 0); @@ -2180,15 +2258,22 @@ static HRESULT d3d8_device_prepare_index_buffer(struct d3d8_device *device, UINT if (device->index_buffer_size < min_size || !device->index_buffer) { UINT size = max(device->index_buffer_size * 2, min_size); + struct wined3d_buffer_desc desc; struct wined3d_buffer *buffer;
TRACE("Growing index buffer to %u bytes\n", size);
- hr = wined3d_buffer_create_ib(device->wined3d_device, size, WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY, - WINED3D_POOL_DEFAULT, NULL, &d3d8_null_wined3d_parent_ops, &buffer); - if (FAILED(hr)) + desc.byte_width = size; + desc.usage = WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY | WINED3DUSAGE_STATICDECL; + desc.bind_flags = WINED3D_BIND_INDEX_BUFFER; + desc.access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + desc.misc_flags = 0; + desc.structure_byte_stride = 0; + + if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc, + NULL, NULL, &d3d8_null_wined3d_parent_ops, &buffer))) { - ERR("(%p) wined3d_buffer_create_ib failed with hr = %08x\n", device, hr); + ERR("Failed to create index buffer, hr %#x.\n", hr); return hr; }
@@ -2247,7 +2332,7 @@ static HRESULT WINAPI d3d8_device_DrawIndexedPrimitiveUP(IDirect3DDevice8 *iface wined3d_box.right = vb_pos + vtx_size; vb = wined3d_buffer_get_resource(device->vertex_buffer); if (FAILED(hr = wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box, - vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))) + WINED3D_MAP_WRITE | (vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))) goto done; memcpy(wined3d_map_desc.data, (char *)vertex_data + min_vertex_idx * vertex_stride, vtx_size); wined3d_resource_unmap(vb, 0); @@ -2269,7 +2354,7 @@ static HRESULT WINAPI d3d8_device_DrawIndexedPrimitiveUP(IDirect3DDevice8 *iface wined3d_box.right = ib_pos + idx_size; ib = wined3d_buffer_get_resource(device->index_buffer); if (FAILED(hr = wined3d_resource_map(ib, 0, &wined3d_map_desc, &wined3d_box, - ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))) + WINED3D_MAP_WRITE | (ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))) goto done; memcpy(wined3d_map_desc.data, index_data, idx_size); wined3d_resource_unmap(ib, 0); @@ -2325,8 +2410,7 @@ static HRESULT WINAPI d3d8_device_CreateVertexShader(IDirect3DDevice8 *iface, TRACE("iface %p, declaration %p, byte_code %p, shader %p, usage %#x.\n", iface, declaration, byte_code, shader, usage);
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) { *shader = 0; return E_OUTOFMEMORY; @@ -2338,7 +2422,7 @@ static HRESULT WINAPI d3d8_device_CreateVertexShader(IDirect3DDevice8 *iface, if (handle == D3D8_INVALID_HANDLE) { ERR("Failed to allocate vertex shader handle.\n"); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); *shader = 0; return E_OUTOFMEMORY; } @@ -2352,7 +2436,7 @@ static HRESULT WINAPI d3d8_device_CreateVertexShader(IDirect3DDevice8 *iface, wined3d_mutex_lock(); d3d8_free_handle(&device->handle_table, handle, D3D8_HANDLE_VS); wined3d_mutex_unlock(); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); *shader = 0; return hr; } @@ -2392,13 +2476,13 @@ static struct d3d8_vertex_declaration *d3d8_device_get_fvf_declaration(struct d3 } TRACE("not found. Creating and inserting at position %d.\n", low);
- if (!(d3d8_declaration = HeapAlloc(GetProcessHeap(), 0, sizeof(*d3d8_declaration)))) + if (!(d3d8_declaration = heap_alloc(sizeof(*d3d8_declaration)))) return NULL;
if (FAILED(hr = d3d8_vertex_declaration_init_fvf(d3d8_declaration, device, fvf))) { WARN("Failed to initialize vertex declaration, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, d3d8_declaration); + heap_free(d3d8_declaration); return NULL; }
@@ -2406,9 +2490,8 @@ static struct d3d8_vertex_declaration *d3d8_device_get_fvf_declaration(struct d3 { UINT grow = device->declArraySize / 2;
- convertedDecls = HeapReAlloc(GetProcessHeap(), 0, convertedDecls, - sizeof(*convertedDecls) * (device->numConvertedDecls + grow)); - if (!convertedDecls) + if (!(convertedDecls = heap_realloc(convertedDecls, + sizeof(*convertedDecls) * (device->numConvertedDecls + grow)))) { d3d8_vertex_declaration_destroy(d3d8_declaration); return NULL; @@ -2703,8 +2786,7 @@ static HRESULT WINAPI d3d8_device_CreatePixelShader(IDirect3DDevice8 *iface, if (!shader) return D3DERR_INVALIDCALL;
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return E_OUTOFMEMORY;
wined3d_mutex_lock(); @@ -2713,7 +2795,7 @@ static HRESULT WINAPI d3d8_device_CreatePixelShader(IDirect3DDevice8 *iface, if (handle == D3D8_INVALID_HANDLE) { ERR("Failed to allocate pixel shader handle.\n"); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return E_OUTOFMEMORY; }
@@ -2726,7 +2808,7 @@ static HRESULT WINAPI d3d8_device_CreatePixelShader(IDirect3DDevice8 *iface, wined3d_mutex_lock(); d3d8_free_handle(&device->handle_table, handle, D3D8_HANDLE_PS); wined3d_mutex_unlock(); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); *shader = 0; return hr; } @@ -3089,7 +3171,7 @@ static HRESULT CDECL device_parent_surface_created(struct wined3d_device_parent TRACE("device_parent %p, wined3d_texture %p, sub_resource_idx %u, parent %p, parent_ops %p.\n", device_parent, wined3d_texture, sub_resource_idx, parent, parent_ops);
- if (!(d3d_surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*d3d_surface)))) + if (!(d3d_surface = heap_alloc_zero(sizeof(*d3d_surface)))) return E_OUTOFMEMORY;
surface_init(d3d_surface, wined3d_texture, sub_resource_idx, parent_ops); @@ -3108,7 +3190,7 @@ static HRESULT CDECL device_parent_volume_created(struct wined3d_device_parent * TRACE("device_parent %p, texture %p, sub_resource_idx %u, parent %p, parent_ops %p.\n", device_parent, wined3d_texture, sub_resource_idx, parent, parent_ops);
- if (!(d3d_volume = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*d3d_volume)))) + if (!(d3d_volume = heap_alloc_zero(sizeof(*d3d_volume)))) return E_OUTOFMEMORY;
volume_init(d3d_volume, wined3d_texture, sub_resource_idx, parent_ops); @@ -3204,9 +3286,8 @@ HRESULT device_init(struct d3d8_device *device, struct d3d8 *parent, struct wine device->IDirect3DDevice8_iface.lpVtbl = &d3d8_device_vtbl; device->device_parent.ops = &d3d8_wined3d_device_parent_ops; device->ref = 1; - device->handle_table.entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, - D3D8_INITIAL_HANDLE_TABLE_SIZE * sizeof(*device->handle_table.entries)); - if (!device->handle_table.entries) + if (!(device->handle_table.entries = heap_alloc_zero(D3D8_INITIAL_HANDLE_TABLE_SIZE + * sizeof(*device->handle_table.entries)))) { ERR("Failed to allocate handle table memory.\n"); return E_OUTOFMEMORY; @@ -3222,7 +3303,7 @@ HRESULT device_init(struct d3d8_device *device, struct d3d8 *parent, struct wine { WARN("Failed to create wined3d device, hr %#x.\n", hr); wined3d_mutex_unlock(); - HeapFree(GetProcessHeap(), 0, device->handle_table.entries); + heap_free(device->handle_table.entries); return hr; }
@@ -3237,7 +3318,7 @@ HRESULT device_init(struct d3d8_device *device, struct d3d8 *parent, struct wine ERR("Failed to acquire focus window, hr %#x.\n", hr); wined3d_device_decref(device->wined3d_device); wined3d_mutex_unlock(); - HeapFree(GetProcessHeap(), 0, device->handle_table.entries); + heap_free(device->handle_table.entries); return hr; }
@@ -3256,7 +3337,7 @@ HRESULT device_init(struct d3d8_device *device, struct d3d8 *parent, struct wine wined3d_device_release_focus_window(device->wined3d_device); wined3d_device_decref(device->wined3d_device); wined3d_mutex_unlock(); - HeapFree(GetProcessHeap(), 0, device->handle_table.entries); + heap_free(device->handle_table.entries); return D3DERR_INVALIDCALL; }
@@ -3266,7 +3347,7 @@ HRESULT device_init(struct d3d8_device *device, struct d3d8 *parent, struct wine wined3d_device_release_focus_window(device->wined3d_device); wined3d_device_decref(device->wined3d_device); wined3d_mutex_unlock(); - HeapFree(GetProcessHeap(), 0, device->handle_table.entries); + heap_free(device->handle_table.entries); return hr; }
@@ -3278,8 +3359,7 @@ HRESULT device_init(struct d3d8_device *device, struct d3d8 *parent, struct wine present_parameters_from_wined3d_swapchain_desc(parameters, &swapchain_desc);
device->declArraySize = 16; - device->decls = HeapAlloc(GetProcessHeap(), 0, device->declArraySize * sizeof(*device->decls)); - if (!device->decls) + if (!(device->decls = heap_alloc(device->declArraySize * sizeof(*device->decls)))) { ERR("Failed to allocate FVF vertex declaration map memory.\n"); hr = E_OUTOFMEMORY; @@ -3300,6 +3380,6 @@ err: wined3d_device_release_focus_window(device->wined3d_device); wined3d_device_decref(device->wined3d_device); wined3d_mutex_unlock(); - HeapFree(GetProcessHeap(), 0, device->handle_table.entries); + heap_free(device->handle_table.entries); return hr; } diff --git a/dll/directx/wine/d3d8/directx.c b/dll/directx/wine/d3d8/directx.c index ffb8ddefb4..6e8f93a25c 100644 --- a/dll/directx/wine/d3d8/directx.c +++ b/dll/directx/wine/d3d8/directx.c @@ -20,8 +20,21 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" + +#include <stdarg.h> + +#include "windef.h" +#include "winbase.h" +#include "wingdi.h" +#include "winuser.h" +#include "wine/debug.h" +#include "wine/unicode.h" + #include "d3d8_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d8); + static inline struct d3d8 *impl_from_IDirect3D8(IDirect3D8 *iface) { return CONTAINING_RECORD(iface, struct d3d8, IDirect3D8_iface); @@ -68,7 +81,7 @@ static ULONG WINAPI d3d8_Release(IDirect3D8 *iface) wined3d_decref(d3d8->wined3d); wined3d_mutex_unlock();
- HeapFree(GetProcessHeap(), 0, d3d8); + heap_free(d3d8); }
return refcount; @@ -360,15 +373,14 @@ static HRESULT WINAPI d3d8_CreateDevice(IDirect3D8 *iface, UINT adapter, TRACE("iface %p, adapter %u, device_type %#x, focus_window %p, flags %#x, parameters %p, device %p.\n", iface, adapter, device_type, focus_window, flags, parameters, device);
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return E_OUTOFMEMORY;
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); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -405,7 +417,7 @@ BOOL d3d8_init(struct d3d8 *d3d8) DWORD flags = WINED3D_LEGACY_DEPTH_BIAS | WINED3D_VIDMEM_ACCOUNTING | WINED3D_HANDLE_RESTORE | WINED3D_PIXEL_CENTER_INTEGER | WINED3D_LEGACY_UNBOUND_RESOURCE_COLOR | WINED3D_NO_PRIMITIVE_RESTART - | WINED3D_LEGACY_CUBEMAP_FILTERING; + | WINED3D_LEGACY_CUBEMAP_FILTERING | WINED3D_LIMIT_VIEWPORT;
d3d8->IDirect3D8_iface.lpVtbl = &d3d8_vtbl; d3d8->refcount = 1; diff --git a/dll/directx/wine/d3d8/precomp.h b/dll/directx/wine/d3d8/precomp.h new file mode 100644 index 0000000000..17c27cb718 --- /dev/null +++ b/dll/directx/wine/d3d8/precomp.h @@ -0,0 +1,13 @@ + +#ifndef __WINE_D3D8_PRECOMP_H +#define __WINE_D3D8_PRECOMP_H + +#include <wine/config.h> + +#define WIN32_NO_STATUS +#define _INC_WINDOWS +#define COM_NO_WINDOWS_H + +#include "d3d8_private.h" + +#endif /* __WINE_D3D8_PRECOMP_H */ diff --git a/dll/directx/wine/d3d8/shader.c b/dll/directx/wine/d3d8/shader.c index d0361a9e83..8192b238eb 100644 --- a/dll/directx/wine/d3d8/shader.c +++ b/dll/directx/wine/d3d8/shader.c @@ -17,13 +17,16 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d8_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d8); + static void STDMETHODCALLTYPE d3d8_vertexshader_wined3d_object_destroyed(void *parent) { struct d3d8_vertex_shader *shader = parent; d3d8_vertex_declaration_destroy(shader->vertex_declaration); - HeapFree(GetProcessHeap(), 0, shader); + heap_free(shader); }
void d3d8_vertex_shader_destroy(struct d3d8_vertex_shader *shader) @@ -56,15 +59,14 @@ static HRESULT d3d8_vertexshader_create_vertexdeclaration(struct d3d8_device *de TRACE("device %p, declaration %p, shader_handle %#x, decl_ptr %p.\n", device, declaration, shader_handle, decl_ptr);
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return E_OUTOFMEMORY;
hr = d3d8_vertex_declaration_init(object, device, declaration, shader_handle); if (FAILED(hr)) { WARN("Failed to initialize vertex declaration, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -140,7 +142,7 @@ HRESULT d3d8_vertex_shader_init(struct d3d8_vertex_shader *shader, struct d3d8_d
static void STDMETHODCALLTYPE d3d8_pixelshader_wined3d_object_destroyed(void *parent) { - HeapFree(GetProcessHeap(), 0, parent); + heap_free(parent); }
void d3d8_pixel_shader_destroy(struct d3d8_pixel_shader *shader) diff --git a/dll/directx/wine/d3d8/surface.c b/dll/directx/wine/d3d8/surface.c index 545361644b..fff47f5ca1 100644 --- a/dll/directx/wine/d3d8/surface.c +++ b/dll/directx/wine/d3d8/surface.c @@ -18,8 +18,11 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d8_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d8); + static inline struct d3d8_surface *impl_from_IDirect3DSurface8(IDirect3DSurface8 *iface) { return CONTAINING_RECORD(iface, struct d3d8_surface, IDirect3DSurface8_iface); @@ -188,8 +191,8 @@ static HRESULT WINAPI d3d8_surface_GetDesc(IDirect3DSurface8 *iface, D3DSURFACE_
desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); desc->Type = D3DRTYPE_SURFACE; - desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; - desc->Pool = wined3d_desc.pool; + desc->Usage = d3dusage_from_wined3dusage(wined3d_desc.usage); + desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage); desc->Size = wined3d_desc.size; desc->MultiSampleType = wined3d_desc.multisample_type; desc->Width = wined3d_desc.width; @@ -241,7 +244,7 @@ static HRESULT WINAPI d3d8_surface_LockRect(IDirect3DSurface8 *iface, }
hr = wined3d_resource_map(wined3d_texture_get_resource(surface->wined3d_texture), surface->sub_resource_idx, - &map_desc, rect ? &box : NULL, flags); + &map_desc, rect ? &box : NULL, wined3dmapflags_from_d3dmapflags(flags)); wined3d_mutex_unlock();
if (SUCCEEDED(hr)) @@ -303,7 +306,7 @@ static void STDMETHODCALLTYPE surface_wined3d_object_destroyed(void *parent) { struct d3d8_surface *surface = parent; d3d8_resource_cleanup(&surface->resource); - HeapFree(GetProcessHeap(), 0, surface); + heap_free(surface); }
static const struct wined3d_parent_ops d3d8_surface_wined3d_parent_ops = diff --git a/dll/directx/wine/d3d8/swapchain.c b/dll/directx/wine/d3d8/swapchain.c index d82a8ed657..3a588b5e8c 100644 --- a/dll/directx/wine/d3d8/swapchain.c +++ b/dll/directx/wine/d3d8/swapchain.c @@ -18,8 +18,11 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d8_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d8); + static inline struct d3d8_swapchain *impl_from_IDirect3DSwapChain8(IDirect3DSwapChain8 *iface) { return CONTAINING_RECORD(iface, struct d3d8_swapchain, IDirect3DSwapChain8_iface); @@ -102,7 +105,7 @@ static HRESULT WINAPI DECLSPEC_HOTPATCH d3d8_swapchain_Present(IDirect3DSwapChai
wined3d_mutex_lock(); hr = wined3d_swapchain_present(swapchain->wined3d_swapchain, - src_rect, dst_rect, dst_window_override, 0); + src_rect, dst_rect, dst_window_override, 0, 0); wined3d_mutex_unlock();
return hr; @@ -155,7 +158,7 @@ static const IDirect3DSwapChain8Vtbl d3d8_swapchain_vtbl =
static void STDMETHODCALLTYPE d3d8_swapchain_wined3d_object_released(void *parent) { - HeapFree(GetProcessHeap(), 0, parent); + heap_free(parent); }
static const struct wined3d_parent_ops d3d8_swapchain_wined3d_parent_ops = @@ -194,13 +197,13 @@ HRESULT d3d8_swapchain_create(struct d3d8_device *device, struct wined3d_swapcha struct d3d8_swapchain *object; HRESULT hr;
- if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)))) + if (!(object = heap_alloc_zero(sizeof(*object)))) return E_OUTOFMEMORY;
if (FAILED(hr = swapchain_init(object, device, desc))) { WARN("Failed to initialize swapchain, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
diff --git a/dll/directx/wine/d3d8/texture.c b/dll/directx/wine/d3d8/texture.c index b860859987..87a2575cb1 100644 --- a/dll/directx/wine/d3d8/texture.c +++ b/dll/directx/wine/d3d8/texture.c @@ -16,21 +16,24 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d8_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d8); + static inline struct d3d8_texture *impl_from_IDirect3DTexture8(IDirect3DTexture8 *iface) { - return CONTAINING_RECORD(iface, struct d3d8_texture, IDirect3DBaseTexture8_iface); + return CONTAINING_RECORD((IDirect3DBaseTexture8 *)iface, struct d3d8_texture, IDirect3DBaseTexture8_iface); }
static inline struct d3d8_texture *impl_from_IDirect3DCubeTexture8(IDirect3DCubeTexture8 *iface) { - return CONTAINING_RECORD(iface, struct d3d8_texture, IDirect3DBaseTexture8_iface); + return CONTAINING_RECORD((IDirect3DBaseTexture8 *)iface, struct d3d8_texture, IDirect3DBaseTexture8_iface); }
static inline struct d3d8_texture *impl_from_IDirect3DVolumeTexture8(IDirect3DVolumeTexture8 *iface) { - return CONTAINING_RECORD(iface, struct d3d8_texture, IDirect3DBaseTexture8_iface); + return CONTAINING_RECORD((IDirect3DBaseTexture8 *)iface, struct d3d8_texture, IDirect3DBaseTexture8_iface); }
static HRESULT WINAPI d3d8_texture_2d_QueryInterface(IDirect3DTexture8 *iface, REFIID riid, void **out) @@ -250,8 +253,8 @@ static HRESULT WINAPI d3d8_texture_2d_GetLevelDesc(IDirect3DTexture8 *iface, UIN { desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); desc->Type = D3DRTYPE_SURFACE; - desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; - desc->Pool = wined3d_desc.pool; + desc->Usage = d3dusage_from_wined3dusage(wined3d_desc.usage); + desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage); desc->Size = wined3d_desc.size; desc->MultiSampleType = wined3d_desc.multisample_type; desc->Width = wined3d_desc.width; @@ -597,8 +600,8 @@ static HRESULT WINAPI d3d8_texture_cube_GetLevelDesc(IDirect3DCubeTexture8 *ifac { desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); desc->Type = D3DRTYPE_SURFACE; - desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; - desc->Pool = wined3d_desc.pool; + desc->Usage = d3dusage_from_wined3dusage(wined3d_desc.usage); + desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage); desc->Size = wined3d_desc.size; desc->MultiSampleType = wined3d_desc.multisample_type; desc->Width = wined3d_desc.width; @@ -942,8 +945,8 @@ static HRESULT WINAPI d3d8_texture_3d_GetLevelDesc(IDirect3DVolumeTexture8 *ifac { desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); desc->Type = D3DRTYPE_VOLUME; - desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; - desc->Pool = wined3d_desc.pool; + desc->Usage = d3dusage_from_wined3dusage(wined3d_desc.usage); + desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage); desc->Size = wined3d_desc.size; desc->Width = wined3d_desc.width; desc->Height = wined3d_desc.height; @@ -1080,7 +1083,7 @@ static void STDMETHODCALLTYPE d3d8_texture_wined3d_object_destroyed(void *parent { struct d3d8_texture *texture = parent; d3d8_resource_cleanup(&texture->resource); - HeapFree(GetProcessHeap(), 0, texture); + heap_free(texture); }
static const struct wined3d_parent_ops d3d8_texture_wined3d_parent_ops = @@ -1105,7 +1108,10 @@ HRESULT texture_init(struct d3d8_texture *texture, struct d3d8_device *device, desc.multisample_quality = 0; desc.usage = usage & WINED3DUSAGE_MASK; desc.usage |= WINED3DUSAGE_TEXTURE; - desc.pool = pool; + if (pool == D3DPOOL_SCRATCH) + desc.usage |= WINED3DUSAGE_SCRATCH; + desc.access = wined3daccess_from_d3dpool(pool, usage) + | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; desc.width = width; desc.height = height; desc.depth = 1; @@ -1150,7 +1156,10 @@ HRESULT cubetexture_init(struct d3d8_texture *texture, struct d3d8_device *devic desc.multisample_quality = 0; desc.usage = usage & WINED3DUSAGE_MASK; desc.usage |= WINED3DUSAGE_LEGACY_CUBEMAP | WINED3DUSAGE_TEXTURE; - desc.pool = pool; + if (pool == D3DPOOL_SCRATCH) + desc.usage |= WINED3DUSAGE_SCRATCH; + desc.access = wined3daccess_from_d3dpool(pool, usage) + | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; desc.width = edge_length; desc.height = edge_length; desc.depth = 1; @@ -1194,7 +1203,9 @@ HRESULT volumetexture_init(struct d3d8_texture *texture, struct d3d8_device *dev desc.multisample_quality = 0; desc.usage = usage & WINED3DUSAGE_MASK; desc.usage |= WINED3DUSAGE_TEXTURE; - desc.pool = pool; + if (pool == D3DPOOL_SCRATCH) + desc.usage |= WINED3DUSAGE_SCRATCH; + desc.access = wined3daccess_from_d3dpool(pool, usage); desc.width = width; desc.height = height; desc.depth = depth; diff --git a/dll/directx/wine/d3d8/vertexdeclaration.c b/dll/directx/wine/d3d8/vertexdeclaration.c index e01230e5ae..0cae3cd8c6 100644 --- a/dll/directx/wine/d3d8/vertexdeclaration.c +++ b/dll/directx/wine/d3d8/vertexdeclaration.c @@ -21,8 +21,11 @@ /* IDirect3DVertexDeclaration8 is internal to our implementation. * It's not visible in the API. */
+#include "config.h" #include "d3d8_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d8); + static const char *debug_d3dvsdt_type(D3DVSDT_TYPE d3dvsdt_type) { switch (d3dvsdt_type) @@ -263,7 +266,7 @@ static UINT convert_to_wined3d_declaration(const DWORD *d3d8_elements, DWORD *d3 TRACE("d3d8_elements %p, d3d8_elements_size %p, wined3d_elements %p\n", d3d8_elements, d3d8_elements_size, wined3d_elements);
/* 128 should be enough for anyone... */ - *wined3d_elements = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 128 * sizeof(**wined3d_elements)); + *wined3d_elements = heap_alloc_zero(128 * sizeof(**wined3d_elements)); while (D3DVSD_END() != *token) { token_type = ((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT); @@ -311,8 +314,8 @@ static UINT convert_to_wined3d_declaration(const DWORD *d3d8_elements, DWORD *d3 static void STDMETHODCALLTYPE d3d8_vertexdeclaration_wined3d_object_destroyed(void *parent) { struct d3d8_vertex_declaration *declaration = parent; - HeapFree(GetProcessHeap(), 0, declaration->elements); - HeapFree(GetProcessHeap(), 0, declaration); + heap_free(declaration->elements); + heap_free(declaration); }
void d3d8_vertex_declaration_destroy(struct d3d8_vertex_declaration *declaration) @@ -339,11 +342,10 @@ HRESULT d3d8_vertex_declaration_init(struct d3d8_vertex_declaration *declaration declaration->shader_handle = shader_handle;
wined3d_element_count = convert_to_wined3d_declaration(elements, &declaration->elements_size, &wined3d_elements); - declaration->elements = HeapAlloc(GetProcessHeap(), 0, declaration->elements_size); - if (!declaration->elements) + if (!(declaration->elements = heap_alloc(declaration->elements_size))) { ERR("Failed to allocate vertex declaration elements memory.\n"); - HeapFree(GetProcessHeap(), 0, wined3d_elements); + heap_free(wined3d_elements); return E_OUTOFMEMORY; }
@@ -353,11 +355,11 @@ HRESULT d3d8_vertex_declaration_init(struct d3d8_vertex_declaration *declaration hr = wined3d_vertex_declaration_create(device->wined3d_device, wined3d_elements, wined3d_element_count, declaration, &d3d8_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_vertex_declaration); wined3d_mutex_unlock(); - HeapFree(GetProcessHeap(), 0, wined3d_elements); + heap_free(wined3d_elements); if (FAILED(hr)) { WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, declaration->elements); + heap_free(declaration->elements); return hr; }
diff --git a/dll/directx/wine/d3d8/volume.c b/dll/directx/wine/d3d8/volume.c index 0e1e904e2f..89aa84fdb5 100644 --- a/dll/directx/wine/d3d8/volume.c +++ b/dll/directx/wine/d3d8/volume.c @@ -18,8 +18,11 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d8_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d8); + static inline struct d3d8_volume *impl_from_IDirect3DVolume8(IDirect3DVolume8 *iface) { return CONTAINING_RECORD(iface, struct d3d8_volume, IDirect3DVolume8_iface); @@ -122,8 +125,8 @@ static HRESULT WINAPI d3d8_volume_GetDesc(IDirect3DVolume8 *iface, D3DVOLUME_DES
desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); desc->Type = D3DRTYPE_VOLUME; - desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; - desc->Pool = wined3d_desc.pool; + desc->Usage = d3dusage_from_wined3dusage(wined3d_desc.usage); + desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage); desc->Size = wined3d_desc.size; desc->Width = wined3d_desc.width; desc->Height = wined3d_desc.height; @@ -144,7 +147,8 @@ static HRESULT WINAPI d3d8_volume_LockBox(IDirect3DVolume8 *iface,
wined3d_mutex_lock(); if (FAILED(hr = wined3d_resource_map(wined3d_texture_get_resource(volume->wined3d_texture), - volume->sub_resource_idx, &map_desc, (const struct wined3d_box *)box, flags))) + volume->sub_resource_idx, &map_desc, (const struct wined3d_box *)box, + wined3dmapflags_from_d3dmapflags(flags)))) map_desc.data = NULL; wined3d_mutex_unlock();
@@ -152,6 +156,8 @@ static HRESULT WINAPI d3d8_volume_LockBox(IDirect3DVolume8 *iface, locked_box->SlicePitch = map_desc.slice_pitch; locked_box->pBits = map_desc.data;
+ if (hr == E_INVALIDARG) + return D3DERR_INVALIDCALL; return hr; }
@@ -192,7 +198,7 @@ static void STDMETHODCALLTYPE volume_wined3d_object_destroyed(void *parent) { struct d3d8_volume *volume = parent; d3d8_resource_cleanup(&volume->resource); - HeapFree(GetProcessHeap(), 0, volume); + heap_free(volume); }
static const struct wined3d_parent_ops d3d8_volume_wined3d_parent_ops = diff --git a/dll/directx/wine/d3d9/CMakeLists.txt b/dll/directx/wine/d3d9/CMakeLists.txt index 9dd8b4aa6a..223606b87e 100644 --- a/dll/directx/wine/d3d9/CMakeLists.txt +++ b/dll/directx/wine/d3d9/CMakeLists.txt @@ -19,7 +19,7 @@ list(APPEND SOURCE texture.c vertexdeclaration.c volume.c - d3d9_private.h) + precomp.h)
add_library(d3d9 SHARED ${SOURCE} @@ -31,5 +31,5 @@ add_library(d3d9 SHARED set_module_type(d3d9 win32dll UNICODE) target_link_libraries(d3d9 wine) add_importlibs(d3d9 d3dwine user32 msvcrt kernel32 ntdll) -add_pch(d3d9 d3d9_private.h SOURCE) +add_pch(d3d9 precomp.h SOURCE) add_cd_file(TARGET d3d9 DESTINATION reactos/system32 FOR all) diff --git a/dll/directx/wine/d3d9/buffer.c b/dll/directx/wine/d3d9/buffer.c index 462ef3bb97..36a6ae3f90 100644 --- a/dll/directx/wine/d3d9/buffer.c +++ b/dll/directx/wine/d3d9/buffer.c @@ -18,8 +18,11 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d9_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d9); + static inline struct d3d9_vertexbuffer *impl_from_IDirect3DVertexBuffer9(IDirect3DVertexBuffer9 *iface) { return CONTAINING_RECORD(iface, struct d3d9_vertexbuffer, IDirect3DVertexBuffer9_iface); @@ -191,7 +194,7 @@ static HRESULT WINAPI d3d9_vertexbuffer_Lock(IDirect3DVertexBuffer9 *iface, UINT wined3d_box.right = offset + size; wined3d_mutex_lock(); hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->wined3d_buffer), - 0, &wined3d_map_desc, &wined3d_box, flags); + 0, &wined3d_map_desc, &wined3d_box, wined3dmapflags_from_d3dmapflags(flags)); wined3d_mutex_unlock(); *data = wined3d_map_desc.data;
@@ -226,10 +229,10 @@ static HRESULT WINAPI d3d9_vertexbuffer_GetDesc(IDirect3DVertexBuffer9 *iface, wined3d_mutex_unlock();
desc->Format = D3DFMT_VERTEXDATA; - desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; - desc->Pool = wined3d_desc.pool; - desc->Size = wined3d_desc.size; desc->Type = D3DRTYPE_VERTEXBUFFER; + desc->Usage = d3dusage_from_wined3dusage(wined3d_desc.usage); + desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage); + desc->Size = wined3d_desc.size; desc->FVF = buffer->fvf;
return D3D_OK; @@ -260,7 +263,7 @@ static void STDMETHODCALLTYPE d3d9_vertexbuffer_wined3d_object_destroyed(void *p { struct d3d9_vertexbuffer *buffer = parent; d3d9_resource_cleanup(&buffer->resource); - HeapFree(GetProcessHeap(), 0, buffer); + heap_free(buffer); }
static const struct wined3d_parent_ops d3d9_vertexbuffer_wined3d_parent_ops = @@ -271,15 +274,30 @@ static const struct wined3d_parent_ops d3d9_vertexbuffer_wined3d_parent_ops = HRESULT vertexbuffer_init(struct d3d9_vertexbuffer *buffer, struct d3d9_device *device, UINT size, UINT usage, DWORD fvf, D3DPOOL pool) { + struct wined3d_buffer_desc desc; HRESULT hr;
+ if (pool == D3DPOOL_SCRATCH) + { + WARN("Vertex buffer with D3DPOOL_SCRATCH requested.\n"); + return D3DERR_INVALIDCALL; + } + buffer->IDirect3DVertexBuffer9_iface.lpVtbl = &d3d9_vertexbuffer_vtbl; buffer->fvf = fvf; d3d9_resource_init(&buffer->resource);
+ desc.byte_width = size; + desc.usage = usage & WINED3DUSAGE_MASK; + desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER; + desc.access = wined3daccess_from_d3dpool(pool, usage) + | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + desc.misc_flags = 0; + desc.structure_byte_stride = 0; + wined3d_mutex_lock(); - hr = wined3d_buffer_create_vb(device->wined3d_device, size, usage & WINED3DUSAGE_MASK, - (enum wined3d_pool)pool, buffer, &d3d9_vertexbuffer_wined3d_parent_ops, &buffer->wined3d_buffer); + hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer, + &d3d9_vertexbuffer_wined3d_parent_ops, &buffer->wined3d_buffer); wined3d_mutex_unlock(); if (FAILED(hr)) { @@ -473,7 +491,7 @@ static HRESULT WINAPI d3d9_indexbuffer_Lock(IDirect3DIndexBuffer9 *iface, wined3d_box.right = offset + size; wined3d_mutex_lock(); hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->wined3d_buffer), - 0, &wined3d_map_desc, &wined3d_box, flags); + 0, &wined3d_map_desc, &wined3d_box, wined3dmapflags_from_d3dmapflags(flags)); wined3d_mutex_unlock(); *data = wined3d_map_desc.data;
@@ -507,10 +525,10 @@ static HRESULT WINAPI d3d9_indexbuffer_GetDesc(IDirect3DIndexBuffer9 *iface, D3D wined3d_mutex_unlock();
desc->Format = d3dformat_from_wined3dformat(buffer->format); - desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; - desc->Pool = wined3d_desc.pool; - desc->Size = wined3d_desc.size; desc->Type = D3DRTYPE_INDEXBUFFER; + desc->Usage = d3dusage_from_wined3dusage(wined3d_desc.usage); + desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage); + desc->Size = wined3d_desc.size;
return D3D_OK; } @@ -540,7 +558,7 @@ static void STDMETHODCALLTYPE d3d9_indexbuffer_wined3d_object_destroyed(void *pa { struct d3d9_indexbuffer *buffer = parent; d3d9_resource_cleanup(&buffer->resource); - HeapFree(GetProcessHeap(), 0, buffer); + heap_free(buffer); }
static const struct wined3d_parent_ops d3d9_indexbuffer_wined3d_parent_ops = @@ -551,15 +569,26 @@ static const struct wined3d_parent_ops d3d9_indexbuffer_wined3d_parent_ops = HRESULT indexbuffer_init(struct d3d9_indexbuffer *buffer, struct d3d9_device *device, UINT size, DWORD usage, D3DFORMAT format, D3DPOOL pool) { + struct wined3d_buffer_desc desc; HRESULT hr;
+ desc.byte_width = size; + desc.usage = (usage & WINED3DUSAGE_MASK) | WINED3DUSAGE_STATICDECL; + if (pool == D3DPOOL_SCRATCH) + desc.usage |= WINED3DUSAGE_SCRATCH; + desc.bind_flags = WINED3D_BIND_INDEX_BUFFER; + desc.access = wined3daccess_from_d3dpool(pool, usage) + | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + desc.misc_flags = 0; + desc.structure_byte_stride = 0; + buffer->IDirect3DIndexBuffer9_iface.lpVtbl = &d3d9_indexbuffer_vtbl; buffer->format = wined3dformat_from_d3dformat(format); d3d9_resource_init(&buffer->resource);
wined3d_mutex_lock(); - hr = wined3d_buffer_create_ib(device->wined3d_device, size, usage & WINED3DUSAGE_MASK, - (enum wined3d_pool)pool, buffer, &d3d9_indexbuffer_wined3d_parent_ops, &buffer->wined3d_buffer); + hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer, + &d3d9_indexbuffer_wined3d_parent_ops, &buffer->wined3d_buffer); wined3d_mutex_unlock(); if (FAILED(hr)) { diff --git a/dll/directx/wine/d3d9/d3d9_main.c b/dll/directx/wine/d3d9/d3d9_main.c index 4bd80e1b91..c23fa54d99 100644 --- a/dll/directx/wine/d3d9/d3d9_main.c +++ b/dll/directx/wine/d3d9/d3d9_main.c @@ -21,8 +21,12 @@ * */
+#include "config.h" +#include "initguid.h" #include "d3d9_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d9); + static int D3DPERF_event_level = 0;
void WINAPI DebugSetMute(void) { @@ -35,13 +39,13 @@ IDirect3D9 * WINAPI DECLSPEC_HOTPATCH Direct3DCreate9(UINT sdk_version)
TRACE("sdk_version %#x.\n", sdk_version);
- if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)))) + if (!(object = heap_alloc_zero(sizeof(*object)))) return NULL;
if (!d3d9_init(object, FALSE)) { WARN("Failed to initialize d3d9.\n"); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return NULL; }
@@ -56,13 +60,13 @@ HRESULT WINAPI DECLSPEC_HOTPATCH Direct3DCreate9Ex(UINT sdk_version, IDirect3D9E
TRACE("sdk_version %#x, d3d9ex %p.\n", sdk_version, d3d9ex);
- if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)))) + if (!(object = heap_alloc_zero(sizeof(*object)))) return E_OUTOFMEMORY;
if (!d3d9_init(object, TRUE)) { WARN("Failed to initialize d3d9.\n"); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return D3DERR_NOTAVAILABLE; }
diff --git a/dll/directx/wine/d3d9/d3d9_private.h b/dll/directx/wine/d3d9/d3d9_private.h index d34dd73137..ba19e5fb08 100644 --- a/dll/directx/wine/d3d9/d3d9_private.h +++ b/dll/directx/wine/d3d9/d3d9_private.h @@ -23,36 +23,39 @@ #ifndef __WINE_D3D9_PRIVATE_H #define __WINE_D3D9_PRIVATE_H
-#include <config.h> - #include <assert.h> #include <stdarg.h>
-#define WIN32_NO_STATUS -#define _INC_WINDOWS -#define COM_NO_WINDOWS_H - #define NONAMELESSUNION #define NONAMELESSSTRUCT #define COBJMACROS -#include <windef.h> -#include <winbase.h> -#include <wingdi.h> +#include "windef.h" +#include "winbase.h" +#include "wingdi.h" +#include "winuser.h" +#include "wine/debug.h" +#include "wine/heap.h" +#include "wine/unicode.h"
-#include <wine/debug.h> -WINE_DEFAULT_DEBUG_CHANNEL(d3d9); +#include "d3d9.h" +#include "wine/wined3d.h"
-#include <d3d9.h> -#include <wine/wined3d.h> +#define D3D9_MAX_VERTEX_SHADER_CONSTANTF 256 +#define D3D9_MAX_TEXTURE_UNITS 20
#define D3DPRESENTFLAGS_MASK 0x00000fffu
+#define D3D9_TEXTURE_MIPMAP_DIRTY 0x1 + +#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0])) + extern const struct wined3d_parent_ops d3d9_null_wined3d_parent_ops DECLSPEC_HIDDEN;
HRESULT vdecl_convert_fvf(DWORD FVF, D3DVERTEXELEMENT9 **ppVertexElements) DECLSPEC_HIDDEN; D3DFORMAT d3dformat_from_wined3dformat(enum wined3d_format_id format) DECLSPEC_HIDDEN; BOOL is_gdi_compat_wined3dformat(enum wined3d_format_id format) DECLSPEC_HIDDEN; enum wined3d_format_id wined3dformat_from_d3dformat(D3DFORMAT format) DECLSPEC_HIDDEN; +unsigned int wined3dmapflags_from_d3dmapflags(unsigned int flags) DECLSPEC_HIDDEN; void present_parameters_from_wined3d_swapchain_desc(D3DPRESENT_PARAMETERS *present_parameters, const struct wined3d_swapchain_desc *swapchain_desc) DECLSPEC_HIDDEN; void d3dcaps_from_wined3dcaps(D3DCAPS9 *caps, const WINED3DCAPS *wined3d_caps) DECLSPEC_HIDDEN; @@ -98,6 +101,9 @@ struct d3d9_device UINT index_buffer_size; UINT index_buffer_pos;
+ struct d3d9_texture *textures[D3D9_MAX_TEXTURE_UNITS]; + struct d3d9_surface *render_targets[D3D_MAX_SIMULTANEOUS_RENDERTARGETS]; + LONG device_state; BOOL in_destruction; BOOL in_scene; @@ -204,6 +210,10 @@ struct d3d9_texture struct wined3d_texture *wined3d_texture; IDirect3DDevice9Ex *parent_device; struct list rtv_list; + DWORD usage; + BOOL flags; + struct wined3d_shader_resource_view *wined3d_srv; + D3DTEXTUREFILTERTYPE autogen_filter_type; };
HRESULT cubetexture_init(struct d3d9_texture *texture, struct d3d9_device *device, @@ -213,6 +223,8 @@ HRESULT texture_init(struct d3d9_texture *texture, struct d3d9_device *device, HRESULT volumetexture_init(struct d3d9_texture *texture, struct d3d9_device *device, UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool) DECLSPEC_HIDDEN; struct d3d9_texture *unsafe_impl_from_IDirect3DBaseTexture9(IDirect3DBaseTexture9 *iface) DECLSPEC_HIDDEN; +void d3d9_texture_flag_auto_gen_mipmap(struct d3d9_texture *texture) DECLSPEC_HIDDEN; +void d3d9_texture_gen_auto_mipmap(struct d3d9_texture *texture) DECLSPEC_HIDDEN;
struct d3d9_stateblock { @@ -253,9 +265,6 @@ HRESULT vertexshader_init(struct d3d9_vertexshader *shader, struct d3d9_device *device, const DWORD *byte_code) DECLSPEC_HIDDEN; struct d3d9_vertexshader *unsafe_impl_from_IDirect3DVertexShader9(IDirect3DVertexShader9 *iface) DECLSPEC_HIDDEN;
-#define D3D9_MAX_VERTEX_SHADER_CONSTANTF 256 -#define D3D9_MAX_SIMULTANEOUS_RENDERTARGETS 4 - struct d3d9_pixelshader { IDirect3DPixelShader9 IDirect3DPixelShader9_iface; @@ -284,4 +293,49 @@ static inline struct d3d9_device *impl_from_IDirect3DDevice9Ex(IDirect3DDevice9E return CONTAINING_RECORD(iface, struct d3d9_device, IDirect3DDevice9Ex_iface); }
+static inline DWORD d3dusage_from_wined3dusage(unsigned int usage) +{ + return usage & WINED3DUSAGE_MASK; +} + +static inline D3DPOOL d3dpool_from_wined3daccess(unsigned int access, unsigned int usage) +{ + switch (access & (WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_CPU)) + { + default: + case WINED3D_RESOURCE_ACCESS_GPU: + return D3DPOOL_DEFAULT; + case WINED3D_RESOURCE_ACCESS_CPU: + if (usage & WINED3DUSAGE_SCRATCH) + return D3DPOOL_SCRATCH; + return D3DPOOL_SYSTEMMEM; + case WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_CPU: + return D3DPOOL_MANAGED; + } +} + +static inline unsigned int wined3daccess_from_d3dpool(D3DPOOL pool, unsigned int usage) +{ + switch (pool) + { + case D3DPOOL_DEFAULT: + if (usage & D3DUSAGE_DYNAMIC) + return WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + return WINED3D_RESOURCE_ACCESS_GPU; + case D3DPOOL_MANAGED: + return WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_CPU + | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + case D3DPOOL_SYSTEMMEM: + case D3DPOOL_SCRATCH: + return WINED3D_RESOURCE_ACCESS_CPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + default: + return 0; + } +} + +static inline DWORD wined3dusage_from_d3dusage(unsigned int usage) +{ + return usage & WINED3DUSAGE_MASK; +} + #endif /* __WINE_D3D9_PRIVATE_H */ diff --git a/dll/directx/wine/d3d9/device.c b/dll/directx/wine/d3d9/device.c index b3e085f34d..bc73699e52 100644 --- a/dll/directx/wine/d3d9/device.c +++ b/dll/directx/wine/d3d9/device.c @@ -20,9 +20,10 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d9_private.h"
-#include <winuser.h> +WINE_DEFAULT_DEBUG_CHANNEL(d3d9);
static void STDMETHODCALLTYPE d3d9_null_wined3d_object_destroyed(void *parent) {}
@@ -159,6 +160,30 @@ enum wined3d_format_id wined3dformat_from_d3dformat(D3DFORMAT format) } }
+unsigned int wined3dmapflags_from_d3dmapflags(unsigned int flags) +{ + static const unsigned int handled = D3DLOCK_NOSYSLOCK + | D3DLOCK_NOOVERWRITE + | D3DLOCK_DISCARD + | D3DLOCK_DONOTWAIT + | D3DLOCK_NO_DIRTY_UPDATE; + unsigned int wined3d_flags; + + wined3d_flags = flags & handled; + if (!(flags & (D3DLOCK_NOOVERWRITE | D3DLOCK_DISCARD))) + wined3d_flags |= WINED3D_MAP_READ; + if (!(flags & D3DLOCK_READONLY)) + wined3d_flags |= WINED3D_MAP_WRITE; + if (!(wined3d_flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE))) + wined3d_flags |= WINED3D_MAP_READ | WINED3D_MAP_WRITE; + flags &= ~(handled | D3DLOCK_READONLY); + + if (flags) + FIXME("Unhandled flags %#x.\n", flags); + + return wined3d_flags; +} + static UINT vertex_count_from_primitive_count(D3DPRIMITIVETYPE primitive_type, UINT primitive_count) { switch (primitive_type) @@ -185,6 +210,26 @@ static UINT vertex_count_from_primitive_count(D3DPRIMITIVETYPE primitive_type, U } }
+static D3DSWAPEFFECT d3dswapeffect_from_wined3dswapeffect(enum wined3d_swap_effect effect) +{ + switch (effect) + { + case WINED3D_SWAP_EFFECT_DISCARD: + return D3DSWAPEFFECT_DISCARD; + case WINED3D_SWAP_EFFECT_SEQUENTIAL: + return D3DSWAPEFFECT_FLIP; + case WINED3D_SWAP_EFFECT_COPY: + return D3DSWAPEFFECT_COPY; + case WINED3D_SWAP_EFFECT_OVERLAY: + return D3DSWAPEFFECT_OVERLAY; + case WINED3D_SWAP_EFFECT_FLIP_SEQUENTIAL: + return D3DSWAPEFFECT_FLIPEX; + default: + FIXME("Unhandled swap effect %#x.\n", effect); + return D3DSWAPEFFECT_FLIP; + } +} + void present_parameters_from_wined3d_swapchain_desc(D3DPRESENT_PARAMETERS *present_parameters, const struct wined3d_swapchain_desc *swapchain_desc) { @@ -194,7 +239,7 @@ void present_parameters_from_wined3d_swapchain_desc(D3DPRESENT_PARAMETERS *prese present_parameters->BackBufferCount = swapchain_desc->backbuffer_count; present_parameters->MultiSampleType = swapchain_desc->multisample_type; present_parameters->MultiSampleQuality = swapchain_desc->multisample_quality; - present_parameters->SwapEffect = swapchain_desc->swap_effect; + present_parameters->SwapEffect = d3dswapeffect_from_wined3dswapeffect(swapchain_desc->swap_effect); present_parameters->hDeviceWindow = swapchain_desc->device_window; present_parameters->Windowed = swapchain_desc->windowed; present_parameters->EnableAutoDepthStencil = swapchain_desc->enable_auto_depth_stencil; @@ -205,6 +250,26 @@ void present_parameters_from_wined3d_swapchain_desc(D3DPRESENT_PARAMETERS *prese present_parameters->PresentationInterval = swapchain_desc->swap_interval; }
+static enum wined3d_swap_effect wined3dswapeffect_from_d3dswapeffect(D3DSWAPEFFECT effect) +{ + switch (effect) + { + case D3DSWAPEFFECT_DISCARD: + return WINED3D_SWAP_EFFECT_DISCARD; + case D3DSWAPEFFECT_FLIP: + return WINED3D_SWAP_EFFECT_SEQUENTIAL; + case D3DSWAPEFFECT_COPY: + return WINED3D_SWAP_EFFECT_COPY; + case D3DSWAPEFFECT_OVERLAY: + return WINED3D_SWAP_EFFECT_OVERLAY; + case D3DSWAPEFFECT_FLIPEX: + return WINED3D_SWAP_EFFECT_FLIP_SEQUENTIAL; + default: + FIXME("Unhandled swap effect %#x.\n", effect); + return WINED3D_SWAP_EFFECT_SEQUENTIAL; + } +} + static BOOL wined3d_swapchain_desc_from_present_parameters(struct wined3d_swapchain_desc *swapchain_desc, const D3DPRESENT_PARAMETERS *present_parameters, BOOL extended) { @@ -228,9 +293,10 @@ static BOOL wined3d_swapchain_desc_from_present_parameters(struct wined3d_swapch swapchain_desc->backbuffer_height = present_parameters->BackBufferHeight; swapchain_desc->backbuffer_format = wined3dformat_from_d3dformat(present_parameters->BackBufferFormat); swapchain_desc->backbuffer_count = max(1, present_parameters->BackBufferCount); + swapchain_desc->backbuffer_usage = WINED3DUSAGE_RENDERTARGET; swapchain_desc->multisample_type = present_parameters->MultiSampleType; swapchain_desc->multisample_quality = present_parameters->MultiSampleQuality; - swapchain_desc->swap_effect = present_parameters->SwapEffect; + swapchain_desc->swap_effect = wined3dswapeffect_from_d3dswapeffect(present_parameters->SwapEffect); swapchain_desc->device_window = present_parameters->hDeviceWindow; swapchain_desc->windowed = present_parameters->Windowed; swapchain_desc->enable_auto_depth_stencil = present_parameters->EnableAutoDepthStencil; @@ -387,7 +453,7 @@ void d3dcaps_from_wined3dcaps(D3DCAPS9 *caps, const WINED3DCAPS *wined3d_caps) D3DPTEXTURECAPS_CUBEMAP_POW2 | D3DPTEXTURECAPS_VOLUMEMAP_POW2| D3DPTEXTURECAPS_NOPROJECTEDBUMPENV;
caps->MaxVertexShaderConst = min(D3D9_MAX_VERTEX_SHADER_CONSTANTF, caps->MaxVertexShaderConst); - caps->NumSimultaneousRTs = min(D3D9_MAX_SIMULTANEOUS_RENDERTARGETS, caps->NumSimultaneousRTs); + caps->NumSimultaneousRTs = min(D3D_MAX_SIMULTANEOUS_RENDERTARGETS, caps->NumSimultaneousRTs);
if (caps->PixelShaderVersion > 3) { @@ -478,14 +544,14 @@ static ULONG WINAPI DECLSPEC_HOTPATCH d3d9_device_Release(IDirect3DDevice9Ex *if { wined3d_vertex_declaration_decref(device->fvf_decls[i].decl); } - HeapFree(GetProcessHeap(), 0, device->fvf_decls); + heap_free(device->fvf_decls);
if (device->vertex_buffer) wined3d_buffer_decref(device->vertex_buffer); if (device->index_buffer) wined3d_buffer_decref(device->index_buffer);
- HeapFree(GetProcessHeap(), 0, device->implicit_swapchains); + heap_free(device->implicit_swapchains);
wined3d_device_uninit_3d(device->wined3d_device); wined3d_device_release_focus_window(device->wined3d_device); @@ -494,7 +560,7 @@ static ULONG WINAPI DECLSPEC_HOTPATCH d3d9_device_Release(IDirect3DDevice9Ex *if
IDirect3D9Ex_Release(&device->d3d_parent->IDirect3D9Ex_iface);
- HeapFree(GetProcessHeap(), 0, device); + heap_free(device); }
return refcount; @@ -764,7 +830,7 @@ static HRESULT CDECL reset_enum_callback(struct wined3d_resource *resource) IUnknown *parent;
wined3d_resource_get_desc(resource, &desc); - if (desc.pool != WINED3D_POOL_DEFAULT) + if (desc.access & WINED3D_RESOURCE_ACCESS_CPU) return D3D_OK;
if (desc.resource_type != WINED3D_RTYPE_TEXTURE_2D) @@ -794,8 +860,7 @@ static HRESULT d3d9_device_get_swapchains(struct d3d9_device *device) UINT i, new_swapchain_count = wined3d_device_get_swapchain_count(device->wined3d_device); struct wined3d_swapchain *wined3d_swapchain;
- if (!(device->implicit_swapchains = HeapAlloc(GetProcessHeap(), 0, - new_swapchain_count * sizeof(*device->implicit_swapchains)))) + if (!(device->implicit_swapchains = heap_alloc(new_swapchain_count * sizeof(*device->implicit_swapchains)))) return E_OUTOFMEMORY;
for (i = 0; i < new_swapchain_count; ++i) @@ -814,9 +879,10 @@ static HRESULT d3d9_device_reset(struct d3d9_device *device, BOOL extended = device->d3d_parent->extended; struct wined3d_swapchain_desc swapchain_desc; struct wined3d_display_mode wined3d_mode; + struct wined3d_rendertarget_view *rtv; + unsigned int i; HRESULT hr;
- if (!extended && device->device_state == D3D9_DEVICE_STATE_LOST) { WARN("App not active, returning D3DERR_DEVICELOST.\n"); @@ -854,7 +920,7 @@ static HRESULT d3d9_device_reset(struct d3d9_device *device, if (SUCCEEDED(hr = wined3d_device_reset(device->wined3d_device, &swapchain_desc, mode ? &wined3d_mode : NULL, reset_enum_callback, !extended))) { - HeapFree(GetProcessHeap(), 0, device->implicit_swapchains); + heap_free(device->implicit_swapchains);
if (!extended) { @@ -876,6 +942,15 @@ static HRESULT d3d9_device_reset(struct d3d9_device *device,
device->device_state = D3D9_DEVICE_STATE_OK; } + + if (!device->d3d_parent->extended) + for (i = 0; i < ARRAY_SIZE(device->textures); ++i) + device->textures[i] = NULL; + + rtv = wined3d_device_get_rendertarget_view(device->wined3d_device, 0); + device->render_targets[0] = wined3d_rendertarget_view_get_sub_resource_parent(rtv); + for (i = 1; i < ARRAY_SIZE(device->render_targets); ++i) + device->render_targets[i] = NULL; } else if (!extended) { @@ -917,7 +992,7 @@ static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_device_Present(IDirect3DDevice9Ex * for (i = 0; i < device->implicit_swapchain_count; ++i) { if (FAILED(hr = wined3d_swapchain_present(device->implicit_swapchains[i]->wined3d_swapchain, - src_rect, dst_rect, dst_window_override, 0))) + src_rect, dst_rect, dst_window_override, 0, 0))) { wined3d_mutex_unlock(); return hr; @@ -1050,15 +1125,14 @@ static HRESULT WINAPI d3d9_device_CreateTexture(IDirect3DDevice9Ex *iface, } }
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return D3DERR_OUTOFVIDEOMEMORY;
hr = texture_init(object, device, width, height, levels, usage, format, pool); if (FAILED(hr)) { WARN("Failed to initialize texture, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -1103,15 +1177,14 @@ static HRESULT WINAPI d3d9_device_CreateVolumeTexture(IDirect3DDevice9Ex *iface, FIXME("Resource sharing not implemented, *shared_handle %p.\n", *shared_handle); }
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return D3DERR_OUTOFVIDEOMEMORY;
hr = volumetexture_init(object, device, width, height, depth, levels, usage, format, pool); if (FAILED(hr)) { WARN("Failed to initialize volume texture, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -1149,15 +1222,14 @@ static HRESULT WINAPI d3d9_device_CreateCubeTexture(IDirect3DDevice9Ex *iface, FIXME("Resource sharing not implemented, *shared_handle %p.\n", *shared_handle); }
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return D3DERR_OUTOFVIDEOMEMORY;
hr = cubetexture_init(object, device, edge_length, levels, usage, format, pool); if (FAILED(hr)) { WARN("Failed to initialize cube texture, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -1194,15 +1266,14 @@ static HRESULT WINAPI d3d9_device_CreateVertexBuffer(IDirect3DDevice9Ex *iface, FIXME("Resource sharing not implemented, *shared_handle %p.\n", *shared_handle); }
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return D3DERR_OUTOFVIDEOMEMORY;
hr = vertexbuffer_init(object, device, size, usage, fvf, pool); if (FAILED(hr)) { WARN("Failed to initialize vertex buffer, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -1239,15 +1310,14 @@ static HRESULT WINAPI d3d9_device_CreateIndexBuffer(IDirect3DDevice9Ex *iface, U FIXME("Resource sharing not implemented, *shared_handle %p.\n", *shared_handle); }
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return D3DERR_OUTOFVIDEOMEMORY;
hr = indexbuffer_init(object, device, size, usage, format, pool); if (FAILED(hr)) { WARN("Failed to initialize index buffer, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -1276,7 +1346,10 @@ static HRESULT d3d9_device_create_surface(struct d3d9_device *device, UINT width desc.multisample_type = multisample_type; desc.multisample_quality = multisample_quality; desc.usage = usage & WINED3DUSAGE_MASK; - desc.pool = pool; + if (pool == D3DPOOL_SCRATCH) + desc.usage |= WINED3DUSAGE_SCRATCH; + desc.access = wined3daccess_from_d3dpool(pool, usage) + | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; desc.width = width; desc.height = height; desc.depth = 1; @@ -1428,6 +1501,9 @@ static HRESULT WINAPI d3d9_device_UpdateSurface(IDirect3DDevice9Ex *iface, wined3d_texture_get_resource(dst->wined3d_texture), dst->sub_resource_idx, dst_point ? dst_point->x : 0, dst_point ? dst_point->y : 0, 0, wined3d_texture_get_resource(src->wined3d_texture), src->sub_resource_idx, &src_box); + if (SUCCEEDED(hr) && dst->texture) + d3d9_texture_flag_auto_gen_mipmap(dst->texture); + wined3d_mutex_unlock();
if (FAILED(hr)) @@ -1451,6 +1527,8 @@ static HRESULT WINAPI d3d9_device_UpdateTexture(IDirect3DDevice9Ex *iface, wined3d_mutex_lock(); hr = wined3d_device_update_texture(device->wined3d_device, src_impl->wined3d_texture, dst_impl->wined3d_texture); + if (SUCCEEDED(hr)) + d3d9_texture_flag_auto_gen_mipmap(dst_impl); wined3d_mutex_unlock();
return hr; @@ -1534,6 +1612,23 @@ static HRESULT WINAPI d3d9_device_StretchRect(IDirect3DDevice9Ex *iface, IDirect src_rect = &s; }
+ if (dst_desc.access & WINED3D_RESOURCE_ACCESS_CPU) + { + WARN("Destination resource is not in DEFAULT pool.\n"); + goto done; + } + if (src_desc.access & WINED3D_RESOURCE_ACCESS_CPU) + { + WARN("Source resource is not in DEFAULT pool.\n"); + goto done; + } + + if (dst->texture && !(dst_desc.usage & (WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_DEPTHSTENCIL))) + { + WARN("Destination is a regular texture.\n"); + goto done; + } + if (src_desc.usage & WINED3DUSAGE_DEPTHSTENCIL) { if (device->in_scene) @@ -1569,6 +1664,8 @@ static HRESULT WINAPI d3d9_device_StretchRect(IDirect3DDevice9Ex *iface, IDirect src->wined3d_texture, src->sub_resource_idx, src_rect, 0, NULL, filter); if (hr == WINEDDERR_INVALIDRECT) hr = D3DERR_INVALIDCALL; + if (SUCCEEDED(hr) && dst->texture) + d3d9_texture_flag_auto_gen_mipmap(dst->texture);
done: wined3d_mutex_unlock(); @@ -1602,10 +1699,10 @@ static HRESULT WINAPI d3d9_device_ColorFill(IDirect3DDevice9Ex *iface, return D3DERR_INVALIDCALL; }
- if (desc.pool != WINED3D_POOL_DEFAULT) + if (desc.access & WINED3D_RESOURCE_ACCESS_CPU) { wined3d_mutex_unlock(); - WARN("Colorfill is not allowed on surfaces in pool %#x, returning D3DERR_INVALIDCALL.\n", desc.pool); + WARN("Colour fills are not allowed on surfaces with resource access %#x.\n", desc.access); return D3DERR_INVALIDCALL; } if ((desc.usage & (WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_TEXTURE)) == WINED3DUSAGE_TEXTURE) @@ -1625,6 +1722,8 @@ static HRESULT WINAPI d3d9_device_ColorFill(IDirect3DDevice9Ex *iface, hr = wined3d_device_clear_rendertarget_view(device->wined3d_device, rtv, rect, WINED3DCLEAR_TARGET, &c, 0.0f, 0); d3d9_surface_release_rendertarget_view(surface_impl, rtv); + if (SUCCEEDED(hr) && surface_impl->texture) + d3d9_texture_flag_auto_gen_mipmap(surface_impl->texture);
wined3d_mutex_unlock();
@@ -1685,7 +1784,7 @@ static HRESULT WINAPI d3d9_device_SetRenderTarget(IDirect3DDevice9Ex *iface, DWO
TRACE("iface %p, idx %u, surface %p.\n", iface, idx, surface);
- if (idx >= D3D9_MAX_SIMULTANEOUS_RENDERTARGETS) + if (idx >= D3D_MAX_SIMULTANEOUS_RENDERTARGETS) { WARN("Invalid index %u specified.\n", idx); return D3DERR_INVALIDCALL; @@ -1707,6 +1806,8 @@ static HRESULT WINAPI d3d9_device_SetRenderTarget(IDirect3DDevice9Ex *iface, DWO rtv = surface_impl ? d3d9_surface_acquire_rendertarget_view(surface_impl) : NULL; hr = wined3d_device_set_rendertarget_view(device->wined3d_device, idx, rtv, TRUE); d3d9_surface_release_rendertarget_view(surface_impl, rtv); + if (SUCCEEDED(hr)) + device->render_targets[idx] = surface_impl; wined3d_mutex_unlock();
return hr; @@ -1724,7 +1825,7 @@ static HRESULT WINAPI d3d9_device_GetRenderTarget(IDirect3DDevice9Ex *iface, DWO if (!surface) return D3DERR_INVALIDCALL;
- if (idx >= D3D9_MAX_SIMULTANEOUS_RENDERTARGETS) + if (idx >= D3D_MAX_SIMULTANEOUS_RENDERTARGETS) { WARN("Invalid index %u specified.\n", idx); return D3DERR_INVALIDCALL; @@ -1827,6 +1928,19 @@ static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_device_EndScene(IDirect3DDevice9Ex return hr; }
+static void d3d9_rts_flag_auto_gen_mipmap(struct d3d9_device *device) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(device->render_targets); ++i) + { + struct d3d9_surface *surface = device->render_targets[i]; + + if (surface && surface->texture) + d3d9_texture_flag_auto_gen_mipmap(surface->texture); + } +} + static HRESULT WINAPI d3d9_device_Clear(IDirect3DDevice9Ex *iface, DWORD rect_count, const D3DRECT *rects, DWORD flags, D3DCOLOR color, float z, DWORD stencil) { @@ -1851,6 +1965,8 @@ static HRESULT WINAPI d3d9_device_Clear(IDirect3DDevice9Ex *iface, DWORD rect_co
wined3d_mutex_lock(); hr = wined3d_device_clear(device->wined3d_device, rect_count, (const RECT *)rects, flags, &c, z, stencil); + if (SUCCEEDED(hr)) + d3d9_rts_flag_auto_gen_mipmap(device); wined3d_mutex_unlock();
return hr; @@ -2104,15 +2220,14 @@ static HRESULT WINAPI d3d9_device_CreateStateBlock(IDirect3DDevice9Ex *iface, return D3DERR_INVALIDCALL; }
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return E_OUTOFMEMORY;
hr = stateblock_init(object, device, type, NULL); if (FAILED(hr)) { WARN("Failed to initialize stateblock, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -2154,8 +2269,7 @@ static HRESULT WINAPI d3d9_device_EndStateBlock(IDirect3DDevice9Ex *iface, IDire return hr; }
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) { wined3d_mutex_lock(); wined3d_stateblock_decref(wined3d_stateblock); @@ -2170,7 +2284,7 @@ static HRESULT WINAPI d3d9_device_EndStateBlock(IDirect3DDevice9Ex *iface, IDire wined3d_mutex_lock(); wined3d_stateblock_decref(wined3d_stateblock); wined3d_mutex_unlock(); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -2248,6 +2362,13 @@ static HRESULT WINAPI d3d9_device_SetTexture(IDirect3DDevice9Ex *iface, DWORD st wined3d_mutex_lock(); hr = wined3d_device_set_texture(device->wined3d_device, stage, texture_impl ? texture_impl->wined3d_texture : NULL); + if (SUCCEEDED(hr)) + { + unsigned int i = stage >= D3DVERTEXTEXTURESAMPLER0 ? stage - D3DVERTEXTEXTURESAMPLER0 + 16 : stage; + + if (stage < ARRAY_SIZE(device->textures)) + device->textures[i] = texture_impl; + } wined3d_mutex_unlock();
return hr; @@ -2297,7 +2418,7 @@ static HRESULT WINAPI d3d9_device_GetTextureStageState(IDirect3DDevice9Ex *iface
TRACE("iface %p, stage %u, state %#x, value %p.\n", iface, stage, state, value);
- if (state >= sizeof(tss_lookup) / sizeof(*tss_lookup)) + if (state >= ARRAY_SIZE(tss_lookup)) { WARN("Invalid state %#x passed.\n", state); return D3D_OK; @@ -2317,7 +2438,7 @@ static HRESULT WINAPI d3d9_device_SetTextureStageState(IDirect3DDevice9Ex *iface
TRACE("iface %p, stage %u, state %#x, value %#x.\n", iface, stage, state, value);
- if (state >= sizeof(tss_lookup) / sizeof(*tss_lookup)) + if (state >= ARRAY_SIZE(tss_lookup)) { WARN("Invalid state %#x passed.\n", state); return D3D_OK; @@ -2488,6 +2609,16 @@ static float WINAPI d3d9_device_GetNPatchMode(IDirect3DDevice9Ex *iface) return ret; }
+/* wined3d critical section must be taken by the caller. */ +static void d3d9_generate_auto_mipmaps(struct d3d9_device *device) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(device->textures); ++i) + if (device->textures[i]) + d3d9_texture_gen_auto_mipmap(device->textures[i]); +} + static HRESULT WINAPI d3d9_device_DrawPrimitive(IDirect3DDevice9Ex *iface, D3DPRIMITIVETYPE primitive_type, UINT start_vertex, UINT primitive_count) { @@ -2504,9 +2635,12 @@ static HRESULT WINAPI d3d9_device_DrawPrimitive(IDirect3DDevice9Ex *iface, WARN("Called without a valid vertex declaration set.\n"); return D3DERR_INVALIDCALL; } + d3d9_generate_auto_mipmaps(device); wined3d_device_set_primitive_type(device->wined3d_device, primitive_type, 0); hr = wined3d_device_draw_primitive(device->wined3d_device, start_vertex, vertex_count_from_primitive_count(primitive_type, primitive_count)); + if (SUCCEEDED(hr)) + d3d9_rts_flag_auto_gen_mipmap(device); wined3d_mutex_unlock();
return hr; @@ -2531,10 +2665,13 @@ static HRESULT WINAPI d3d9_device_DrawIndexedPrimitive(IDirect3DDevice9Ex *iface WARN("Called without a valid vertex declaration set.\n"); return D3DERR_INVALIDCALL; } + d3d9_generate_auto_mipmaps(device); wined3d_device_set_base_vertex_index(device->wined3d_device, base_vertex_idx); wined3d_device_set_primitive_type(device->wined3d_device, primitive_type, 0); hr = wined3d_device_draw_indexed_primitive(device->wined3d_device, start_idx, vertex_count_from_primitive_count(primitive_type, primitive_count)); + if (SUCCEEDED(hr)) + d3d9_rts_flag_auto_gen_mipmap(device); wined3d_mutex_unlock();
return hr; @@ -2548,15 +2685,22 @@ static HRESULT d3d9_device_prepare_vertex_buffer(struct d3d9_device *device, UIN if (device->vertex_buffer_size < min_size || !device->vertex_buffer) { UINT size = max(device->vertex_buffer_size * 2, min_size); + struct wined3d_buffer_desc desc; struct wined3d_buffer *buffer;
TRACE("Growing vertex buffer to %u bytes.\n", size);
- hr = wined3d_buffer_create_vb(device->wined3d_device, size, WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY, - WINED3D_POOL_DEFAULT, NULL, &d3d9_null_wined3d_parent_ops, &buffer); - if (FAILED(hr)) + desc.byte_width = size; + desc.usage = WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY; + desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER; + desc.access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + desc.misc_flags = 0; + desc.structure_byte_stride = 0; + + if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc, + NULL, NULL, &d3d9_null_wined3d_parent_ops, &buffer))) { - ERR("(%p) wined3d_buffer_create_vb failed with hr = %08x.\n", device, hr); + ERR("Failed to create vertex buffer, hr %#x.\n", hr); return hr; }
@@ -2616,7 +2760,7 @@ static HRESULT WINAPI d3d9_device_DrawPrimitiveUP(IDirect3DDevice9Ex *iface, wined3d_box.right = vb_pos + size; vb = wined3d_buffer_get_resource(device->vertex_buffer); if (FAILED(hr = wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box, - vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))) + WINED3D_MAP_WRITE | (vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))) goto done; memcpy(wined3d_map_desc.data, data, size); wined3d_resource_unmap(vb, 0); @@ -2626,9 +2770,12 @@ static HRESULT WINAPI d3d9_device_DrawPrimitiveUP(IDirect3DDevice9Ex *iface, if (FAILED(hr)) goto done;
+ d3d9_generate_auto_mipmaps(device); wined3d_device_set_primitive_type(device->wined3d_device, primitive_type, 0); hr = wined3d_device_draw_primitive(device->wined3d_device, vb_pos / stride, vtx_count); wined3d_device_set_stream_source(device->wined3d_device, 0, NULL, 0, 0); + if (SUCCEEDED(hr)) + d3d9_rts_flag_auto_gen_mipmap(device);
done: wined3d_mutex_unlock(); @@ -2643,15 +2790,22 @@ static HRESULT d3d9_device_prepare_index_buffer(struct d3d9_device *device, UINT if (device->index_buffer_size < min_size || !device->index_buffer) { UINT size = max(device->index_buffer_size * 2, min_size); + struct wined3d_buffer_desc desc; struct wined3d_buffer *buffer;
TRACE("Growing index buffer to %u bytes.\n", size);
- hr = wined3d_buffer_create_ib(device->wined3d_device, size, WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY, - WINED3D_POOL_DEFAULT, NULL, &d3d9_null_wined3d_parent_ops, &buffer); - if (FAILED(hr)) + desc.byte_width = size; + desc.usage = WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY | WINED3DUSAGE_STATICDECL; + desc.bind_flags = WINED3D_BIND_INDEX_BUFFER; + desc.access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + desc.misc_flags = 0; + desc.structure_byte_stride = 0; + + if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc, + NULL, NULL, &d3d9_null_wined3d_parent_ops, &buffer))) { - ERR("(%p) wined3d_buffer_create_ib failed with hr = %08x.\n", device, hr); + ERR("Failed to create index buffer, hr %#x.\n", hr); return hr; }
@@ -2717,7 +2871,7 @@ static HRESULT WINAPI d3d9_device_DrawIndexedPrimitiveUP(IDirect3DDevice9Ex *ifa wined3d_box.right = vb_pos + vtx_size; vb = wined3d_buffer_get_resource(device->vertex_buffer); if (FAILED(hr = wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box, - vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))) + WINED3D_MAP_WRITE | (vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))) goto done; memcpy(wined3d_map_desc.data, (char *)vertex_data + min_vertex_idx * vertex_stride, vtx_size); wined3d_resource_unmap(vb, 0); @@ -2739,7 +2893,7 @@ static HRESULT WINAPI d3d9_device_DrawIndexedPrimitiveUP(IDirect3DDevice9Ex *ifa wined3d_box.right = ib_pos + idx_size; ib = wined3d_buffer_get_resource(device->index_buffer); if (FAILED(hr = wined3d_resource_map(ib, 0, &wined3d_map_desc, &wined3d_box, - ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))) + WINED3D_MAP_WRITE | (ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))) goto done; memcpy(wined3d_map_desc.data, index_data, idx_size); wined3d_resource_unmap(ib, 0); @@ -2749,6 +2903,7 @@ static HRESULT WINAPI d3d9_device_DrawIndexedPrimitiveUP(IDirect3DDevice9Ex *ifa if (FAILED(hr)) goto done;
+ d3d9_generate_auto_mipmaps(device); wined3d_device_set_index_buffer(device->wined3d_device, device->index_buffer, wined3dformat_from_d3dformat(index_format), 0); wined3d_device_set_base_vertex_index(device->wined3d_device, vb_pos / vertex_stride - min_vertex_idx); @@ -2760,6 +2915,9 @@ static HRESULT WINAPI d3d9_device_DrawIndexedPrimitiveUP(IDirect3DDevice9Ex *ifa wined3d_device_set_index_buffer(device->wined3d_device, NULL, WINED3DFMT_UNKNOWN, 0); wined3d_device_set_base_vertex_index(device->wined3d_device, 0);
+ if (SUCCEEDED(hr)) + d3d9_rts_flag_auto_gen_mipmap(device); + done: wined3d_mutex_unlock(); return hr; @@ -2887,7 +3045,7 @@ static struct wined3d_vertex_declaration *device_get_fvf_declaration(struct d3d9 return NULL;
hr = d3d9_vertex_declaration_create(device, elements, &d3d9_declaration); - HeapFree(GetProcessHeap(), 0, elements); + heap_free(elements); if (FAILED(hr)) return NULL;
@@ -2895,8 +3053,7 @@ static struct wined3d_vertex_declaration *device_get_fvf_declaration(struct d3d9 { UINT grow = max(device->fvf_decl_size / 2, 8);
- fvf_decls = HeapReAlloc(GetProcessHeap(), 0, fvf_decls, sizeof(*fvf_decls) * (device->fvf_decl_size + grow)); - if (!fvf_decls) + if (!(fvf_decls = heap_realloc(fvf_decls, sizeof(*fvf_decls) * (device->fvf_decl_size + grow)))) { IDirect3DVertexDeclaration9_Release(&d3d9_declaration->IDirect3DVertexDeclaration9_iface); return NULL; @@ -2982,15 +3139,14 @@ static HRESULT WINAPI d3d9_device_CreateVertexShader(IDirect3DDevice9Ex *iface,
TRACE("iface %p, byte_code %p, shader %p.\n", iface, byte_code, shader);
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return E_OUTOFMEMORY;
hr = vertexshader_init(object, device, byte_code); if (FAILED(hr)) { WARN("Failed to initialize vertex shader, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -3280,8 +3436,7 @@ static HRESULT WINAPI d3d9_device_CreatePixelShader(IDirect3DDevice9Ex *iface,
TRACE("iface %p, byte_code %p, shader %p.\n", iface, byte_code, shader);
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) { FIXME("Failed to allocate pixel shader memory.\n"); return E_OUTOFMEMORY; @@ -3291,7 +3446,7 @@ static HRESULT WINAPI d3d9_device_CreatePixelShader(IDirect3DDevice9Ex *iface, if (FAILED(hr)) { WARN("Failed to initialize pixel shader, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -3468,15 +3623,14 @@ static HRESULT WINAPI d3d9_device_CreateQuery(IDirect3DDevice9Ex *iface, D3DQUER
TRACE("iface %p, type %#x, query %p.\n", iface, type, query);
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return E_OUTOFMEMORY;
hr = query_init(object, device, type); if (FAILED(hr)) { WARN("Failed to initialize query, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -3530,7 +3684,7 @@ static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_device_PresentEx(IDirect3DDevice9Ex for (i = 0; i < device->implicit_swapchain_count; ++i) { if (FAILED(hr = wined3d_swapchain_present(device->implicit_swapchains[i]->wined3d_swapchain, - src_rect, dst_rect, dst_window_override, flags))) + src_rect, dst_rect, dst_window_override, 0, flags))) { wined3d_mutex_unlock(); return hr; @@ -3905,7 +4059,7 @@ static HRESULT CDECL device_parent_surface_created(struct wined3d_device_parent TRACE("device_parent %p, wined3d_texture %p, sub_resource_idx %u, parent %p, parent_ops %p.\n", device_parent, wined3d_texture, sub_resource_idx, parent, parent_ops);
- if (!(d3d_surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*d3d_surface)))) + if (!(d3d_surface = heap_alloc_zero(sizeof(*d3d_surface)))) return E_OUTOFMEMORY;
surface_init(d3d_surface, wined3d_texture, sub_resource_idx, parent_ops); @@ -3924,7 +4078,7 @@ static HRESULT CDECL device_parent_volume_created(struct wined3d_device_parent * TRACE("device_parent %p, texture %p, sub_resource_idx %u, parent %p, parent_ops %p.\n", device_parent, wined3d_texture, sub_resource_idx, parent, parent_ops);
- if (!(d3d_volume = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*d3d_volume)))) + if (!(d3d_volume = heap_alloc_zero(sizeof(*d3d_volume)))) return E_OUTOFMEMORY;
volume_init(d3d_volume, wined3d_texture, sub_resource_idx, parent_ops); @@ -4075,8 +4229,7 @@ HRESULT device_init(struct d3d9_device *device, struct d3d9 *parent, struct wine } }
- swapchain_desc = HeapAlloc(GetProcessHeap(), 0, sizeof(*swapchain_desc) * count); - if (!swapchain_desc) + if (!(swapchain_desc = heap_alloc(sizeof(*swapchain_desc) * count))) { ERR("Failed to allocate wined3d parameters.\n"); wined3d_device_release_focus_window(device->wined3d_device); @@ -4092,7 +4245,7 @@ HRESULT device_init(struct d3d9_device *device, struct d3d9 *parent, struct wine { wined3d_device_release_focus_window(device->wined3d_device); wined3d_device_decref(device->wined3d_device); - HeapFree(GetProcessHeap(), 0, swapchain_desc); + heap_free(swapchain_desc); wined3d_mutex_unlock(); return D3DERR_INVALIDCALL; } @@ -4102,7 +4255,7 @@ HRESULT device_init(struct d3d9_device *device, struct d3d9 *parent, struct wine { WARN("Failed to initialize 3D, hr %#x.\n", hr); wined3d_device_release_focus_window(device->wined3d_device); - HeapFree(GetProcessHeap(), 0, swapchain_desc); + heap_free(swapchain_desc); wined3d_device_decref(device->wined3d_device); wined3d_mutex_unlock(); return hr; @@ -4127,16 +4280,15 @@ HRESULT device_init(struct d3d9_device *device, struct d3d9 *parent, struct wine
wined3d_mutex_unlock();
- HeapFree(GetProcessHeap(), 0, swapchain_desc); + heap_free(swapchain_desc);
/* Initialize the converted declaration array. This creates a valid pointer * and when adding decls HeapReAlloc() can be used without further checking. */ - device->fvf_decls = HeapAlloc(GetProcessHeap(), 0, 0); - if (!device->fvf_decls) + if (!(device->fvf_decls = heap_alloc(0))) { ERR("Failed to allocate FVF vertex declaration map memory.\n"); wined3d_mutex_lock(); - HeapFree(GetProcessHeap(), 0, device->implicit_swapchains); + heap_free(device->implicit_swapchains); wined3d_device_uninit_3d(device->wined3d_device); wined3d_device_release_focus_window(device->wined3d_device); wined3d_device_decref(device->wined3d_device); @@ -4144,6 +4296,14 @@ HRESULT device_init(struct d3d9_device *device, struct d3d9 *parent, struct wine return E_OUTOFMEMORY; }
+ /* We could also simply ignore the initial rendertarget since it's known + * not to be a texture (we currently use these only for automatic mipmap + * generation). */ + wined3d_mutex_lock(); + device->render_targets[0] = wined3d_rendertarget_view_get_sub_resource_parent( + wined3d_device_get_rendertarget_view(device->wined3d_device, 0)); + wined3d_mutex_unlock(); + IDirect3D9Ex_AddRef(&parent->IDirect3D9Ex_iface); device->d3d_parent = parent;
diff --git a/dll/directx/wine/d3d9/directx.c b/dll/directx/wine/d3d9/directx.c index ab153a9030..644766c2e9 100644 --- a/dll/directx/wine/d3d9/directx.c +++ b/dll/directx/wine/d3d9/directx.c @@ -19,8 +19,11 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d9_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d9); + static inline struct d3d9 *impl_from_IDirect3D9Ex(IDirect3D9Ex *iface) { return CONTAINING_RECORD(iface, struct d3d9, IDirect3D9Ex_iface); @@ -83,7 +86,7 @@ static ULONG WINAPI d3d9_Release(IDirect3D9Ex *iface) wined3d_decref(d3d9->wined3d); wined3d_mutex_unlock();
- HeapFree(GetProcessHeap(), 0, d3d9); + heap_free(d3d9); }
return refcount; @@ -397,15 +400,14 @@ static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_CreateDevice(IDirect3D9Ex *iface, U TRACE("iface %p, adapter %u, device_type %#x, focus_window %p, flags %#x, parameters %p, device %p.\n", iface, adapter, device_type, focus_window, flags, parameters, device);
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return E_OUTOFMEMORY;
hr = device_init(object, d3d9, d3d9->wined3d, adapter, device_type, focus_window, flags, parameters, NULL); if (FAILED(hr)) { WARN("Failed to initialize device, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -505,15 +507,14 @@ static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_CreateDeviceEx(IDirect3D9Ex *iface, TRACE("iface %p, adapter %u, device_type %#x, focus_window %p, flags %#x, parameters %p, mode %p, device %p.\n", iface, adapter, device_type, focus_window, flags, parameters, mode, device);
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return E_OUTOFMEMORY;
hr = device_init(object, d3d9, d3d9->wined3d, adapter, device_type, focus_window, flags, parameters, mode); if (FAILED(hr)) { WARN("Failed to initialize device, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -578,7 +579,7 @@ BOOL d3d9_init(struct d3d9 *d3d9, BOOL extended) DWORD flags = WINED3D_PRESENT_CONVERSION | WINED3D_HANDLE_RESTORE | WINED3D_PIXEL_CENTER_INTEGER | WINED3D_SRGB_READ_WRITE_CONTROL | WINED3D_LEGACY_UNBOUND_RESOURCE_COLOR | WINED3D_NO_PRIMITIVE_RESTART | WINED3D_LEGACY_CUBEMAP_FILTERING - | WINED3D_NORMALIZED_DEPTH_BIAS; + | WINED3D_NORMALIZED_DEPTH_BIAS | WINED3D_LIMIT_VIEWPORT;
if (!extended) flags |= WINED3D_VIDMEM_ACCOUNTING; diff --git a/dll/directx/wine/d3d9/precomp.h b/dll/directx/wine/d3d9/precomp.h new file mode 100644 index 0000000000..3d1e183794 --- /dev/null +++ b/dll/directx/wine/d3d9/precomp.h @@ -0,0 +1,13 @@ + +#ifndef __WINE_D3D9_PRECOMP_H +#define __WINE_D3D9_PRECOMP_H + +#include <wine/config.h> + +#define WIN32_NO_STATUS +#define _INC_WINDOWS +#define COM_NO_WINDOWS_H + +#include "d3d9_private.h" + +#endif /* __WINE_D3D9_PRECOMP_H */ diff --git a/dll/directx/wine/d3d9/query.c b/dll/directx/wine/d3d9/query.c index 8681502c49..12ff95b5a0 100644 --- a/dll/directx/wine/d3d9/query.c +++ b/dll/directx/wine/d3d9/query.c @@ -20,8 +20,11 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d9_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d9); + static inline struct d3d9_query *impl_from_IDirect3DQuery9(IDirect3DQuery9 *iface) { return CONTAINING_RECORD(iface, struct d3d9_query, IDirect3DQuery9_iface); @@ -69,7 +72,7 @@ static ULONG WINAPI d3d9_query_Release(IDirect3DQuery9 *iface) wined3d_mutex_unlock();
IDirect3DDevice9Ex_Release(query->parent_device); - HeapFree(GetProcessHeap(), 0, query); + heap_free(query); } return refcount; } diff --git a/dll/directx/wine/d3d9/shader.c b/dll/directx/wine/d3d9/shader.c index 75dfc0f394..9cb398388b 100644 --- a/dll/directx/wine/d3d9/shader.c +++ b/dll/directx/wine/d3d9/shader.c @@ -17,8 +17,11 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d9_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d9); + static inline struct d3d9_vertexshader *impl_from_IDirect3DVertexShader9(IDirect3DVertexShader9 *iface) { return CONTAINING_RECORD(iface, struct d3d9_vertexshader, IDirect3DVertexShader9_iface); @@ -123,7 +126,7 @@ static const IDirect3DVertexShader9Vtbl d3d9_vertexshader_vtbl =
static void STDMETHODCALLTYPE d3d9_vertexshader_wined3d_object_destroyed(void *parent) { - HeapFree(GetProcessHeap(), 0, parent); + heap_free(parent); }
static const struct wined3d_parent_ops d3d9_vertexshader_wined3d_parent_ops = @@ -277,7 +280,7 @@ static const IDirect3DPixelShader9Vtbl d3d9_pixelshader_vtbl =
static void STDMETHODCALLTYPE d3d9_pixelshader_wined3d_object_destroyed(void *parent) { - HeapFree(GetProcessHeap(), 0, parent); + heap_free(parent); }
static const struct wined3d_parent_ops d3d9_pixelshader_wined3d_parent_ops = diff --git a/dll/directx/wine/d3d9/stateblock.c b/dll/directx/wine/d3d9/stateblock.c index 9355d9d51e..62b3bacb28 100644 --- a/dll/directx/wine/d3d9/stateblock.c +++ b/dll/directx/wine/d3d9/stateblock.c @@ -20,8 +20,11 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d9_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d9); + static inline struct d3d9_stateblock *impl_from_IDirect3DStateBlock9(IDirect3DStateBlock9 *iface) { return CONTAINING_RECORD(iface, struct d3d9_stateblock, IDirect3DStateBlock9_iface); @@ -69,7 +72,7 @@ static ULONG WINAPI d3d9_stateblock_Release(IDirect3DStateBlock9 *iface) wined3d_mutex_unlock();
IDirect3DDevice9Ex_Release(stateblock->parent_device); - HeapFree(GetProcessHeap(), 0, stateblock); + heap_free(stateblock); }
return refcount; diff --git a/dll/directx/wine/d3d9/surface.c b/dll/directx/wine/d3d9/surface.c index 47b5267910..0605e7142a 100644 --- a/dll/directx/wine/d3d9/surface.c +++ b/dll/directx/wine/d3d9/surface.c @@ -19,8 +19,11 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d9_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d9); + static inline struct d3d9_surface *impl_from_IDirect3DSurface9(IDirect3DSurface9 *iface) { return CONTAINING_RECORD(iface, struct d3d9_surface, IDirect3DSurface9_iface); @@ -220,8 +223,8 @@ static HRESULT WINAPI d3d9_surface_GetDesc(IDirect3DSurface9 *iface, D3DSURFACE_
desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); desc->Type = D3DRTYPE_SURFACE; - desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; - desc->Pool = wined3d_desc.pool; + desc->Usage = d3dusage_from_wined3dusage(wined3d_desc.usage); + desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage); desc->MultiSampleType = wined3d_desc.multisample_type; desc->MultiSampleQuality = wined3d_desc.multisample_quality; desc->Width = wined3d_desc.width; @@ -246,7 +249,7 @@ static HRESULT WINAPI d3d9_surface_LockRect(IDirect3DSurface9 *iface,
wined3d_mutex_lock(); hr = wined3d_resource_map(wined3d_texture_get_resource(surface->wined3d_texture), surface->sub_resource_idx, - &map_desc, rect ? &box : NULL, flags); + &map_desc, rect ? &box : NULL, wined3dmapflags_from_d3dmapflags(flags)); wined3d_mutex_unlock();
if (SUCCEEDED(hr)) @@ -267,6 +270,8 @@ static HRESULT WINAPI d3d9_surface_UnlockRect(IDirect3DSurface9 *iface)
wined3d_mutex_lock(); hr = wined3d_resource_unmap(wined3d_texture_get_resource(surface->wined3d_texture), surface->sub_resource_idx); + if (SUCCEEDED(hr) && surface->texture) + d3d9_texture_flag_auto_gen_mipmap(surface->texture); wined3d_mutex_unlock();
if (hr == WINEDDERR_NOTLOCKED) @@ -304,6 +309,8 @@ static HRESULT WINAPI d3d9_surface_ReleaseDC(IDirect3DSurface9 *iface, HDC dc)
wined3d_mutex_lock(); hr = wined3d_texture_release_dc(surface->wined3d_texture, surface->sub_resource_idx, dc); + if (SUCCEEDED(hr) && surface->texture) + d3d9_texture_flag_auto_gen_mipmap(surface->texture); wined3d_mutex_unlock();
return hr; @@ -337,7 +344,7 @@ static void STDMETHODCALLTYPE surface_wined3d_object_destroyed(void *parent) { struct d3d9_surface *surface = parent; d3d9_resource_cleanup(&surface->resource); - HeapFree(GetProcessHeap(), 0, surface); + heap_free(surface); }
static const struct wined3d_parent_ops d3d9_surface_wined3d_parent_ops = diff --git a/dll/directx/wine/d3d9/swapchain.c b/dll/directx/wine/d3d9/swapchain.c index 7b2dc7ea4f..dbb3f45b91 100644 --- a/dll/directx/wine/d3d9/swapchain.c +++ b/dll/directx/wine/d3d9/swapchain.c @@ -20,8 +20,11 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d9_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d9); + static inline struct d3d9_swapchain *impl_from_IDirect3DSwapChain9Ex(IDirect3DSwapChain9Ex *iface) { return CONTAINING_RECORD(iface, struct d3d9_swapchain, IDirect3DSwapChain9Ex_iface); @@ -134,7 +137,7 @@ static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_swapchain_Present(IDirect3DSwapChai
wined3d_mutex_lock(); hr = wined3d_swapchain_present(swapchain->wined3d_swapchain, - src_rect, dst_rect, dst_window_override, flags); + src_rect, dst_rect, dst_window_override, 0, flags); wined3d_mutex_unlock();
return hr; @@ -332,7 +335,7 @@ static const struct IDirect3DSwapChain9ExVtbl d3d9_swapchain_vtbl =
static void STDMETHODCALLTYPE d3d9_swapchain_wined3d_object_released(void *parent) { - HeapFree(GetProcessHeap(), 0, parent); + heap_free(parent); }
static const struct wined3d_parent_ops d3d9_swapchain_wined3d_parent_ops = @@ -371,13 +374,13 @@ HRESULT d3d9_swapchain_create(struct d3d9_device *device, struct wined3d_swapcha struct d3d9_swapchain *object; HRESULT hr;
- if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)))) + if (!(object = heap_alloc_zero(sizeof(*object)))) return E_OUTOFMEMORY;
if (FAILED(hr = swapchain_init(object, device, desc))) { WARN("Failed to initialize swapchain, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
diff --git a/dll/directx/wine/d3d9/texture.c b/dll/directx/wine/d3d9/texture.c index 16909d6888..c97fa6b021 100644 --- a/dll/directx/wine/d3d9/texture.c +++ b/dll/directx/wine/d3d9/texture.c @@ -18,21 +18,97 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d9_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d9); + static inline struct d3d9_texture *impl_from_IDirect3DTexture9(IDirect3DTexture9 *iface) { - return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface); + return CONTAINING_RECORD((IDirect3DBaseTexture9 *)iface, struct d3d9_texture, IDirect3DBaseTexture9_iface); }
static inline struct d3d9_texture *impl_from_IDirect3DCubeTexture9(IDirect3DCubeTexture9 *iface) { - return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface); + return CONTAINING_RECORD((IDirect3DBaseTexture9 *)iface, struct d3d9_texture, IDirect3DBaseTexture9_iface); }
static inline struct d3d9_texture *impl_from_IDirect3DVolumeTexture9(IDirect3DVolumeTexture9 *iface) { - return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface); + return CONTAINING_RECORD((IDirect3DBaseTexture9 *)iface, struct d3d9_texture, IDirect3DBaseTexture9_iface); +} + +static void STDMETHODCALLTYPE srv_wined3d_object_destroyed(void *parent) +{ + struct d3d9_texture *texture = parent; + + texture->wined3d_srv = NULL; +} + +static const struct wined3d_parent_ops d3d9_srv_wined3d_parent_ops = +{ + srv_wined3d_object_destroyed, +}; + +/* wined3d critical section must be taken by the caller. */ +static struct wined3d_shader_resource_view *d3d9_texture_acquire_shader_resource_view(struct d3d9_texture *texture) +{ + struct wined3d_sub_resource_desc sr_desc; + struct wined3d_view_desc desc; + HRESULT hr; + + if (texture->wined3d_srv) + return texture->wined3d_srv; + + wined3d_texture_get_sub_resource_desc(texture->wined3d_texture, 0, &sr_desc); + desc.format_id = sr_desc.format; + desc.flags = 0; + desc.u.texture.level_idx = 0; + desc.u.texture.level_count = wined3d_texture_get_level_count(texture->wined3d_texture); + desc.u.texture.layer_idx = 0; + desc.u.texture.layer_count = sr_desc.usage & WINED3DUSAGE_LEGACY_CUBEMAP ? 6 : 1; + if (FAILED(hr = wined3d_shader_resource_view_create(&desc, + wined3d_texture_get_resource(texture->wined3d_texture), texture, + &d3d9_srv_wined3d_parent_ops, &texture->wined3d_srv))) + { + ERR("Failed to create shader resource view, hr %#x.\n", hr); + return NULL; + } + + return texture->wined3d_srv; +} + +static void d3d9_texture_cleanup(struct d3d9_texture *texture) +{ + IDirect3DDevice9Ex *parent_device = texture->parent_device; + struct d3d9_surface *surface; + + wined3d_mutex_lock(); + if (texture->wined3d_srv) + wined3d_shader_resource_view_decref(texture->wined3d_srv); + LIST_FOR_EACH_ENTRY(surface, &texture->rtv_list, struct d3d9_surface, rtv_entry) + wined3d_rendertarget_view_decref(surface->wined3d_rtv); + wined3d_texture_decref(texture->wined3d_texture); + wined3d_mutex_unlock(); + + /* Release the device last, as it may cause the device to be destroyed. */ + IDirect3DDevice9Ex_Release(parent_device); +} + +/* wined3d critical section must be taken by the caller. */ +void d3d9_texture_gen_auto_mipmap(struct d3d9_texture *texture) +{ + if (!(texture->flags & D3D9_TEXTURE_MIPMAP_DIRTY)) + return; + d3d9_texture_acquire_shader_resource_view(texture); + wined3d_shader_resource_view_generate_mipmaps(texture->wined3d_srv); + texture->flags &= ~D3D9_TEXTURE_MIPMAP_DIRTY; +} + +void d3d9_texture_flag_auto_gen_mipmap(struct d3d9_texture *texture) +{ + if (texture->usage & D3DUSAGE_AUTOGENMIPMAP) + texture->flags |= D3D9_TEXTURE_MIPMAP_DIRTY; }
static HRESULT WINAPI d3d9_texture_2d_QueryInterface(IDirect3DTexture9 *iface, REFIID riid, void **out) @@ -87,21 +163,7 @@ static ULONG WINAPI d3d9_texture_2d_Release(IDirect3DTexture9 *iface) TRACE("%p decreasing refcount to %u.\n", iface, ref);
if (!ref) - { - IDirect3DDevice9Ex *parent_device = texture->parent_device; - struct d3d9_surface *surface; - - wined3d_mutex_lock(); - LIST_FOR_EACH_ENTRY(surface, &texture->rtv_list, struct d3d9_surface, rtv_entry) - { - wined3d_rendertarget_view_decref(surface->wined3d_rtv); - } - wined3d_texture_decref(texture->wined3d_texture); - wined3d_mutex_unlock(); - - /* Release the device last, as it may cause the device to be destroyed. */ - IDirect3DDevice9Ex_Release(parent_device); - } + d3d9_texture_cleanup(texture); return ref; }
@@ -232,6 +294,9 @@ static DWORD WINAPI d3d9_texture_2d_GetLevelCount(IDirect3DTexture9 *iface)
TRACE("iface %p.\n", iface);
+ if (texture->usage & D3DUSAGE_AUTOGENMIPMAP) + return 1; + wined3d_mutex_lock(); ret = wined3d_texture_get_level_count(texture->wined3d_texture); wined3d_mutex_unlock(); @@ -242,35 +307,44 @@ static DWORD WINAPI d3d9_texture_2d_GetLevelCount(IDirect3DTexture9 *iface) static HRESULT WINAPI d3d9_texture_2d_SetAutoGenFilterType(IDirect3DTexture9 *iface, D3DTEXTUREFILTERTYPE filter_type) { struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); - HRESULT hr;
TRACE("iface %p, filter_type %#x.\n", iface, filter_type);
- wined3d_mutex_lock(); - hr = wined3d_texture_set_autogen_filter_type(texture->wined3d_texture, - (enum wined3d_texture_filter_type)filter_type); - wined3d_mutex_unlock(); + if (filter_type == D3DTEXF_NONE) + { + WARN("Invalid filter type D3DTEXF_NONE specified.\n"); + return D3DERR_INVALIDCALL; + } + if (!(texture->usage & D3DUSAGE_AUTOGENMIPMAP)) + WARN("Called on a texture without the D3DUSAGE_AUTOGENMIPMAP flag.\n"); + else if (filter_type != D3DTEXF_LINEAR) + FIXME("Unsupported filter type %u.\n", filter_type);
- return hr; + texture->autogen_filter_type = filter_type; + return D3D_OK; }
static D3DTEXTUREFILTERTYPE WINAPI d3d9_texture_2d_GetAutoGenFilterType(IDirect3DTexture9 *iface) { struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); - D3DTEXTUREFILTERTYPE ret;
TRACE("iface %p.\n", iface);
- wined3d_mutex_lock(); - ret = (D3DTEXTUREFILTERTYPE)wined3d_texture_get_autogen_filter_type(texture->wined3d_texture); - wined3d_mutex_unlock(); + if (!(texture->usage & D3DUSAGE_AUTOGENMIPMAP)) + WARN("Called on a texture without the D3DUSAGE_AUTOGENMIPMAP flag.\n");
- return ret; + return texture->autogen_filter_type; }
static void WINAPI d3d9_texture_2d_GenerateMipSubLevels(IDirect3DTexture9 *iface) { + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + d3d9_texture_gen_auto_mipmap(texture); + wined3d_mutex_unlock(); }
static HRESULT WINAPI d3d9_texture_2d_GetLevelDesc(IDirect3DTexture9 *iface, UINT level, D3DSURFACE_DESC *desc) @@ -281,13 +355,19 @@ static HRESULT WINAPI d3d9_texture_2d_GetLevelDesc(IDirect3DTexture9 *iface, UIN
TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
+ if (texture->usage & D3DUSAGE_AUTOGENMIPMAP && level) + { + WARN("D3DUSAGE_AUTOGENMIPMAP textures have only one accessible level.\n"); + return D3DERR_INVALIDCALL; + } + wined3d_mutex_lock(); if (SUCCEEDED(hr = wined3d_texture_get_sub_resource_desc(texture->wined3d_texture, level, &wined3d_desc))) { desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); desc->Type = D3DRTYPE_SURFACE; - desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; - desc->Pool = wined3d_desc.pool; + desc->Usage = texture->usage; + desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage); desc->MultiSampleType = wined3d_desc.multisample_type; desc->MultiSampleQuality = wined3d_desc.multisample_quality; desc->Width = wined3d_desc.width; @@ -306,6 +386,12 @@ static HRESULT WINAPI d3d9_texture_2d_GetSurfaceLevel(IDirect3DTexture9 *iface,
TRACE("iface %p, level %u, surface %p.\n", iface, level, surface);
+ if (texture->usage & D3DUSAGE_AUTOGENMIPMAP && level) + { + WARN("D3DUSAGE_AUTOGENMIPMAP textures have only one accessible level.\n"); + return D3DERR_INVALIDCALL; + } + wined3d_mutex_lock(); if (!(surface_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, level))) { @@ -330,6 +416,12 @@ static HRESULT WINAPI d3d9_texture_2d_LockRect(IDirect3DTexture9 *iface, TRACE("iface %p, level %u, locked_rect %p, rect %p, flags %#x.\n", iface, level, locked_rect, rect, flags);
+ if (texture->usage & D3DUSAGE_AUTOGENMIPMAP && level) + { + WARN("D3DUSAGE_AUTOGENMIPMAP textures have only one accessible level.\n"); + return D3DERR_INVALIDCALL; + } + wined3d_mutex_lock(); if (!(surface_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, level))) hr = D3DERR_INVALIDCALL; @@ -348,6 +440,12 @@ static HRESULT WINAPI d3d9_texture_2d_UnlockRect(IDirect3DTexture9 *iface, UINT
TRACE("iface %p, level %u.\n", iface, level);
+ if (texture->usage & D3DUSAGE_AUTOGENMIPMAP && level) + { + WARN("D3DUSAGE_AUTOGENMIPMAP textures have only one accessible level.\n"); + return D3DERR_INVALIDCALL; + } + wined3d_mutex_lock(); if (!(surface_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, level))) hr = D3DERR_INVALIDCALL; @@ -463,23 +561,7 @@ static ULONG WINAPI d3d9_texture_cube_Release(IDirect3DCubeTexture9 *iface) TRACE("%p decreasing refcount to %u.\n", iface, ref);
if (!ref) - { - IDirect3DDevice9Ex *parent_device = texture->parent_device; - struct d3d9_surface *surface; - - TRACE("Releasing child %p.\n", texture->wined3d_texture); - - wined3d_mutex_lock(); - LIST_FOR_EACH_ENTRY(surface, &texture->rtv_list, struct d3d9_surface, rtv_entry) - { - wined3d_rendertarget_view_decref(surface->wined3d_rtv); - } - wined3d_texture_decref(texture->wined3d_texture); - wined3d_mutex_unlock(); - - /* Release the device last, as it may cause the device to be destroyed. */ - IDirect3DDevice9Ex_Release(parent_device); - } + d3d9_texture_cleanup(texture); return ref; }
@@ -610,6 +692,9 @@ static DWORD WINAPI d3d9_texture_cube_GetLevelCount(IDirect3DCubeTexture9 *iface
TRACE("iface %p.\n", iface);
+ if (texture->usage & D3DUSAGE_AUTOGENMIPMAP) + return 1; + wined3d_mutex_lock(); ret = wined3d_texture_get_level_count(texture->wined3d_texture); wined3d_mutex_unlock(); @@ -621,35 +706,44 @@ static HRESULT WINAPI d3d9_texture_cube_SetAutoGenFilterType(IDirect3DCubeTextur D3DTEXTUREFILTERTYPE filter_type) { struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); - HRESULT hr;
TRACE("iface %p, filter_type %#x.\n", iface, filter_type);
- wined3d_mutex_lock(); - hr = wined3d_texture_set_autogen_filter_type(texture->wined3d_texture, - (enum wined3d_texture_filter_type)filter_type); - wined3d_mutex_unlock(); + if (filter_type == D3DTEXF_NONE) + { + WARN("Invalid filter type D3DTEXF_NONE specified.\n"); + return D3DERR_INVALIDCALL; + } + if (!(texture->usage & D3DUSAGE_AUTOGENMIPMAP)) + WARN("Called on a texture without the D3DUSAGE_AUTOGENMIPMAP flag.\n"); + else if (filter_type != D3DTEXF_LINEAR) + FIXME("Unsupported filter type %u.\n", filter_type);
- return hr; + texture->autogen_filter_type = filter_type; + return D3D_OK; }
static D3DTEXTUREFILTERTYPE WINAPI d3d9_texture_cube_GetAutoGenFilterType(IDirect3DCubeTexture9 *iface) { struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); - D3DTEXTUREFILTERTYPE ret;
TRACE("iface %p.\n", iface);
- wined3d_mutex_lock(); - ret = (D3DTEXTUREFILTERTYPE)wined3d_texture_get_autogen_filter_type(texture->wined3d_texture); - wined3d_mutex_unlock(); + if (!(texture->usage & D3DUSAGE_AUTOGENMIPMAP)) + WARN("Called on a texture without the D3DUSAGE_AUTOGENMIPMAP flag.\n");
- return ret; + return texture->autogen_filter_type; }
static void WINAPI d3d9_texture_cube_GenerateMipSubLevels(IDirect3DCubeTexture9 *iface) { + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + d3d9_texture_gen_auto_mipmap(texture); + wined3d_mutex_unlock(); }
static HRESULT WINAPI d3d9_texture_cube_GetLevelDesc(IDirect3DCubeTexture9 *iface, UINT level, D3DSURFACE_DESC *desc) @@ -661,6 +755,12 @@ static HRESULT WINAPI d3d9_texture_cube_GetLevelDesc(IDirect3DCubeTexture9 *ifac
TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
+ if (texture->usage & D3DUSAGE_AUTOGENMIPMAP && level) + { + WARN("D3DUSAGE_AUTOGENMIPMAP textures have only one accessible level.\n"); + return D3DERR_INVALIDCALL; + } + wined3d_mutex_lock(); level_count = wined3d_texture_get_level_count(texture->wined3d_texture); if (level >= level_count) @@ -673,8 +773,8 @@ static HRESULT WINAPI d3d9_texture_cube_GetLevelDesc(IDirect3DCubeTexture9 *ifac { desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); desc->Type = D3DRTYPE_SURFACE; - desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; - desc->Pool = wined3d_desc.pool; + desc->Usage = texture->usage; + desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage); desc->MultiSampleType = wined3d_desc.multisample_type; desc->MultiSampleQuality = wined3d_desc.multisample_quality; desc->Width = wined3d_desc.width; @@ -695,6 +795,12 @@ static HRESULT WINAPI d3d9_texture_cube_GetCubeMapSurface(IDirect3DCubeTexture9
TRACE("iface %p, face %#x, level %u, surface %p.\n", iface, face, level, surface);
+ if (texture->usage & D3DUSAGE_AUTOGENMIPMAP && level) + { + WARN("D3DUSAGE_AUTOGENMIPMAP textures have only one accessible level.\n"); + return D3DERR_INVALIDCALL; + } + wined3d_mutex_lock(); level_count = wined3d_texture_get_level_count(texture->wined3d_texture); if (level >= level_count) @@ -729,6 +835,12 @@ static HRESULT WINAPI d3d9_texture_cube_LockRect(IDirect3DCubeTexture9 *iface, TRACE("iface %p, face %#x, level %u, locked_rect %p, rect %p, flags %#x.\n", iface, face, level, locked_rect, rect, flags);
+ if (texture->usage & D3DUSAGE_AUTOGENMIPMAP && level) + { + WARN("D3DUSAGE_AUTOGENMIPMAP textures have only one accessible level.\n"); + return D3DERR_INVALIDCALL; + } + wined3d_mutex_lock(); sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level; if (!(surface_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, sub_resource_idx))) @@ -750,6 +862,12 @@ static HRESULT WINAPI d3d9_texture_cube_UnlockRect(IDirect3DCubeTexture9 *iface,
TRACE("iface %p, face %#x, level %u.\n", iface, face, level);
+ if (texture->usage & D3DUSAGE_AUTOGENMIPMAP && level) + { + WARN("D3DUSAGE_AUTOGENMIPMAP textures have only one accessible level.\n"); + return D3DERR_INVALIDCALL; + } + wined3d_mutex_lock(); sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level; if (!(surface_impl = wined3d_texture_get_sub_resource_parent(texture->wined3d_texture, sub_resource_idx))) @@ -861,16 +979,7 @@ static ULONG WINAPI d3d9_texture_3d_Release(IDirect3DVolumeTexture9 *iface) TRACE("%p decreasing refcount to %u.\n", iface, ref);
if (!ref) - { - IDirect3DDevice9Ex *parent_device = texture->parent_device; - - wined3d_mutex_lock(); - wined3d_texture_decref(texture->wined3d_texture); - wined3d_mutex_unlock(); - - /* Release the device last, as it may cause the device to be destroyed. */ - IDirect3DDevice9Ex_Release(parent_device); - } + d3d9_texture_cleanup(texture); return ref; }
@@ -1011,31 +1120,16 @@ static DWORD WINAPI d3d9_texture_3d_GetLevelCount(IDirect3DVolumeTexture9 *iface static HRESULT WINAPI d3d9_texture_3d_SetAutoGenFilterType(IDirect3DVolumeTexture9 *iface, D3DTEXTUREFILTERTYPE filter_type) { - struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); - HRESULT hr; - TRACE("iface %p, filter_type %#x.\n", iface, filter_type);
- wined3d_mutex_lock(); - hr = wined3d_texture_set_autogen_filter_type(texture->wined3d_texture, - (enum wined3d_texture_filter_type)filter_type); - wined3d_mutex_unlock(); - - return hr; + return D3DERR_INVALIDCALL; }
static D3DTEXTUREFILTERTYPE WINAPI d3d9_texture_3d_GetAutoGenFilterType(IDirect3DVolumeTexture9 *iface) { - struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); - D3DTEXTUREFILTERTYPE filter_type; - TRACE("iface %p.\n", iface);
- wined3d_mutex_lock(); - filter_type = (D3DTEXTUREFILTERTYPE)wined3d_texture_get_autogen_filter_type(texture->wined3d_texture); - wined3d_mutex_unlock(); - - return filter_type; + return D3DTEXF_NONE; }
static void WINAPI d3d9_texture_3d_GenerateMipSubLevels(IDirect3DVolumeTexture9 *iface) @@ -1056,8 +1150,8 @@ static HRESULT WINAPI d3d9_texture_3d_GetLevelDesc(IDirect3DVolumeTexture9 *ifac { desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); desc->Type = D3DRTYPE_VOLUME; - desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; - desc->Pool = wined3d_desc.pool; + desc->Usage = texture->usage; + desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage); desc->Width = wined3d_desc.width; desc->Height = wined3d_desc.height; desc->Depth = wined3d_desc.depth; @@ -1192,7 +1286,7 @@ static void STDMETHODCALLTYPE d3d9_texture_wined3d_object_destroyed(void *parent { struct d3d9_texture *texture = parent; d3d9_resource_cleanup(&texture->resource); - HeapFree(GetProcessHeap(), 0, texture); + heap_free(texture); }
static const struct wined3d_parent_ops d3d9_texture_wined3d_parent_ops = @@ -1210,14 +1304,18 @@ HRESULT texture_init(struct d3d9_texture *texture, struct d3d9_device *device, texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_2d_vtbl; d3d9_resource_init(&texture->resource); list_init(&texture->rtv_list); + texture->usage = usage;
desc.resource_type = WINED3D_RTYPE_TEXTURE_2D; desc.format = wined3dformat_from_d3dformat(format); desc.multisample_type = WINED3D_MULTISAMPLE_NONE; desc.multisample_quality = 0; - desc.usage = usage & WINED3DUSAGE_MASK; + desc.usage = wined3dusage_from_d3dusage(usage); desc.usage |= WINED3DUSAGE_TEXTURE; - desc.pool = pool; + if (pool == D3DPOOL_SCRATCH) + desc.usage |= WINED3DUSAGE_SCRATCH; + desc.access = wined3daccess_from_d3dpool(pool, usage) + | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; desc.width = width; desc.height = height; desc.depth = 1; @@ -1229,13 +1327,28 @@ HRESULT texture_init(struct d3d9_texture *texture, struct d3d9_device *device, if (is_gdi_compat_wined3dformat(desc.format)) flags |= WINED3D_TEXTURE_CREATE_GET_DC;
- if (!levels) + if (usage & D3DUSAGE_AUTOGENMIPMAP) { - if (usage & D3DUSAGE_AUTOGENMIPMAP) - levels = 1; - else - levels = wined3d_log2i(max(width, height)) + 1; + if (pool == D3DPOOL_SYSTEMMEM) + { + WARN("D3DUSAGE_AUTOGENMIPMAP texture can't be in D3DPOOL_SYSTEMMEM, returning D3DERR_INVALIDCALL.\n"); + return D3DERR_INVALIDCALL; + } + if (levels && levels != 1) + { + WARN("D3DUSAGE_AUTOGENMIPMAP texture with %u levels, returning D3DERR_INVALIDCALL.\n", levels); + return D3DERR_INVALIDCALL; + } + flags |= WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS; + texture->autogen_filter_type = D3DTEXF_LINEAR; + levels = 0; + } + else + { + texture->autogen_filter_type = D3DTEXF_NONE; } + if (!levels) + levels = wined3d_log2i(max(width, height)) + 1;
wined3d_mutex_lock(); hr = wined3d_texture_create(device->wined3d_device, &desc, 1, levels, flags, @@ -1263,14 +1376,18 @@ HRESULT cubetexture_init(struct d3d9_texture *texture, struct d3d9_device *devic texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_cube_vtbl; d3d9_resource_init(&texture->resource); list_init(&texture->rtv_list); + texture->usage = usage;
desc.resource_type = WINED3D_RTYPE_TEXTURE_2D; desc.format = wined3dformat_from_d3dformat(format); desc.multisample_type = WINED3D_MULTISAMPLE_NONE; desc.multisample_quality = 0; - desc.usage = usage & WINED3DUSAGE_MASK; + desc.usage = wined3dusage_from_d3dusage(usage); desc.usage |= WINED3DUSAGE_LEGACY_CUBEMAP | WINED3DUSAGE_TEXTURE; - desc.pool = pool; + if (pool == D3DPOOL_SCRATCH) + desc.usage |= WINED3DUSAGE_SCRATCH; + desc.access = wined3daccess_from_d3dpool(pool, usage) + | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; desc.width = edge_length; desc.height = edge_length; desc.depth = 1; @@ -1282,13 +1399,28 @@ HRESULT cubetexture_init(struct d3d9_texture *texture, struct d3d9_device *devic if (is_gdi_compat_wined3dformat(desc.format)) flags |= WINED3D_TEXTURE_CREATE_GET_DC;
- if (!levels) + if (usage & D3DUSAGE_AUTOGENMIPMAP) + { + if (pool == D3DPOOL_SYSTEMMEM) + { + WARN("D3DUSAGE_AUTOGENMIPMAP texture can't be in D3DPOOL_SYSTEMMEM, returning D3DERR_INVALIDCALL.\n"); + return D3DERR_INVALIDCALL; + } + if (levels && levels != 1) + { + WARN("D3DUSAGE_AUTOGENMIPMAP texture with %u levels, returning D3DERR_INVALIDCALL.\n", levels); + return D3DERR_INVALIDCALL; + } + flags |= WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS; + texture->autogen_filter_type = D3DTEXF_LINEAR; + levels = 0; + } + else { - if (usage & D3DUSAGE_AUTOGENMIPMAP) - levels = 1; - else - levels = wined3d_log2i(edge_length) + 1; + texture->autogen_filter_type = D3DTEXF_NONE; } + if (!levels) + levels = wined3d_log2i(edge_length) + 1;
wined3d_mutex_lock(); hr = wined3d_texture_create(device->wined3d_device, &desc, 6, levels, flags, @@ -1315,26 +1447,29 @@ HRESULT volumetexture_init(struct d3d9_texture *texture, struct d3d9_device *dev texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_3d_vtbl; d3d9_resource_init(&texture->resource); list_init(&texture->rtv_list); + texture->usage = usage;
desc.resource_type = WINED3D_RTYPE_TEXTURE_3D; desc.format = wined3dformat_from_d3dformat(format); desc.multisample_type = WINED3D_MULTISAMPLE_NONE; desc.multisample_quality = 0; - desc.usage = usage & WINED3DUSAGE_MASK; + desc.usage = wined3dusage_from_d3dusage(usage); desc.usage |= WINED3DUSAGE_TEXTURE; - desc.pool = pool; + if (pool == D3DPOOL_SCRATCH) + desc.usage |= WINED3DUSAGE_SCRATCH; + desc.access = wined3daccess_from_d3dpool(pool, usage); desc.width = width; desc.height = height; desc.depth = depth; desc.size = 0;
- if (!levels) + if (usage & D3DUSAGE_AUTOGENMIPMAP) { - if (usage & D3DUSAGE_AUTOGENMIPMAP) - levels = 1; - else - levels = wined3d_log2i(max(max(width, height), depth)) + 1; + WARN("D3DUSAGE_AUTOGENMIPMAP volume texture is not supported, returning D3DERR_INVALIDCALL.\n"); + return D3DERR_INVALIDCALL; } + if (!levels) + levels = wined3d_log2i(max(max(width, height), depth)) + 1;
wined3d_mutex_lock(); hr = wined3d_texture_create(device->wined3d_device, &desc, 1, levels, 0, diff --git a/dll/directx/wine/d3d9/vertexdeclaration.c b/dll/directx/wine/d3d9/vertexdeclaration.c index e9248be5ea..5075309638 100644 --- a/dll/directx/wine/d3d9/vertexdeclaration.c +++ b/dll/directx/wine/d3d9/vertexdeclaration.c @@ -19,8 +19,11 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d9_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d9); + static const struct { enum wined3d_format_id format; @@ -86,8 +89,8 @@ HRESULT vdecl_convert_fvf( has_psize + has_diffuse + has_specular + num_textures + 1;
/* convert the declaration */ - elements = HeapAlloc(GetProcessHeap(), 0, size * sizeof(D3DVERTEXELEMENT9)); - if (!elements) return D3DERR_OUTOFVIDEOMEMORY; + if (!(elements = heap_alloc(size * sizeof(*elements)))) + return D3DERR_OUTOFVIDEOMEMORY;
elements[size-1] = end_element; idx = 0; @@ -307,8 +310,8 @@ struct d3d9_vertex_declaration *unsafe_impl_from_IDirect3DVertexDeclaration9(IDi static void STDMETHODCALLTYPE d3d9_vertexdeclaration_wined3d_object_destroyed(void *parent) { struct d3d9_vertex_declaration *declaration = parent; - HeapFree(GetProcessHeap(), 0, declaration->elements); - HeapFree(GetProcessHeap(), 0, declaration); + heap_free(declaration->elements); + heap_free(declaration); }
static const struct wined3d_parent_ops d3d9_vertexdeclaration_wined3d_parent_ops = @@ -333,18 +336,18 @@ static HRESULT convert_to_wined3d_declaration(const D3DVERTEXELEMENT9 *d3d9_elem /* Skip the END element */ --count;
- *wined3d_elements = HeapAlloc(GetProcessHeap(), 0, count * sizeof(**wined3d_elements)); - if (!*wined3d_elements) { + if (!(*wined3d_elements = heap_alloc(count * sizeof(**wined3d_elements)))) + { FIXME("Memory allocation failed\n"); return D3DERR_OUTOFVIDEOMEMORY; }
for (i = 0; i < count; ++i) { - if (d3d9_elements[i].Type >= (sizeof(d3d_dtype_lookup) / sizeof(*d3d_dtype_lookup))) + if (d3d9_elements[i].Type >= ARRAY_SIZE(d3d_dtype_lookup)) { WARN("Invalid element type %#x.\n", d3d9_elements[i].Type); - HeapFree(GetProcessHeap(), 0, *wined3d_elements); + heap_free(*wined3d_elements); return E_FAIL; } (*wined3d_elements)[i].format = d3d_dtype_lookup[d3d9_elements[i].Type].format; @@ -382,10 +385,9 @@ static HRESULT vertexdeclaration_init(struct d3d9_vertex_declaration *declaratio declaration->refcount = 1;
element_count = wined3d_element_count + 1; - declaration->elements = HeapAlloc(GetProcessHeap(), 0, element_count * sizeof(*declaration->elements)); - if (!declaration->elements) + if (!(declaration->elements = heap_alloc(element_count * sizeof(*declaration->elements)))) { - HeapFree(GetProcessHeap(), 0, wined3d_elements); + heap_free(wined3d_elements); ERR("Failed to allocate vertex declaration elements memory.\n"); return D3DERR_OUTOFVIDEOMEMORY; } @@ -396,10 +398,10 @@ static HRESULT vertexdeclaration_init(struct d3d9_vertex_declaration *declaratio hr = wined3d_vertex_declaration_create(device->wined3d_device, wined3d_elements, wined3d_element_count, declaration, &d3d9_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_declaration); wined3d_mutex_unlock(); - HeapFree(GetProcessHeap(), 0, wined3d_elements); + heap_free(wined3d_elements); if (FAILED(hr)) { - HeapFree(GetProcessHeap(), 0, declaration->elements); + heap_free(declaration->elements); WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr); return hr; } @@ -416,15 +418,14 @@ HRESULT d3d9_vertex_declaration_create(struct d3d9_device *device, struct d3d9_vertex_declaration *object; HRESULT hr;
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) return E_OUTOFMEMORY;
hr = vertexdeclaration_init(object, device, elements); if (FAILED(hr)) { WARN("Failed to initialize vertex declaration, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
diff --git a/dll/directx/wine/d3d9/volume.c b/dll/directx/wine/d3d9/volume.c index 5c6a068811..f4c43bc589 100644 --- a/dll/directx/wine/d3d9/volume.c +++ b/dll/directx/wine/d3d9/volume.c @@ -19,8 +19,11 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" #include "d3d9_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(d3d9); + static inline struct d3d9_volume *impl_from_IDirect3DVolume9(IDirect3DVolume9 *iface) { return CONTAINING_RECORD(iface, struct d3d9_volume, IDirect3DVolume9_iface); @@ -123,8 +126,8 @@ static HRESULT WINAPI d3d9_volume_GetDesc(IDirect3DVolume9 *iface, D3DVOLUME_DES
desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); desc->Type = D3DRTYPE_VOLUME; - desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; - desc->Pool = wined3d_desc.pool; + desc->Usage = d3dusage_from_wined3dusage(wined3d_desc.usage); + desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage); desc->Width = wined3d_desc.width; desc->Height = wined3d_desc.height; desc->Depth = wined3d_desc.depth; @@ -144,7 +147,8 @@ static HRESULT WINAPI d3d9_volume_LockBox(IDirect3DVolume9 *iface,
wined3d_mutex_lock(); if (FAILED(hr = wined3d_resource_map(wined3d_texture_get_resource(volume->wined3d_texture), - volume->sub_resource_idx, &map_desc, (const struct wined3d_box *)box, flags))) + volume->sub_resource_idx, &map_desc, (const struct wined3d_box *)box, + wined3dmapflags_from_d3dmapflags(flags)))) map_desc.data = NULL; wined3d_mutex_unlock();
@@ -152,6 +156,8 @@ static HRESULT WINAPI d3d9_volume_LockBox(IDirect3DVolume9 *iface, locked_box->SlicePitch = map_desc.slice_pitch; locked_box->pBits = map_desc.data;
+ if (hr == E_INVALIDARG) + return D3DERR_INVALIDCALL; return hr; }
@@ -192,7 +198,7 @@ static void STDMETHODCALLTYPE volume_wined3d_object_destroyed(void *parent) { struct d3d9_volume *volume = parent; d3d9_resource_cleanup(&volume->resource); - HeapFree(GetProcessHeap(), 0, volume); + heap_free(volume); }
static const struct wined3d_parent_ops d3d9_volume_wined3d_parent_ops = diff --git a/dll/directx/wine/ddraw/CMakeLists.txt b/dll/directx/wine/ddraw/CMakeLists.txt index ed7801e4ce..6141d630f3 100644 --- a/dll/directx/wine/ddraw/CMakeLists.txt +++ b/dll/directx/wine/ddraw/CMakeLists.txt @@ -20,7 +20,7 @@ list(APPEND SOURCE utils.c vertexbuffer.c viewport.c - ddraw_private.h + precomp.h ${CMAKE_CURRENT_BINARY_DIR}/ddraw_stubs.c)
if(MSVC) @@ -38,5 +38,5 @@ set_module_type(ddraw win32dll) target_link_libraries(ddraw wine uuid dxguid ${PSEH_LIB}) add_importlibs(ddraw advapi32 gdi32 user32 d3dwine msvcrt kernel32 ntdll) add_dependencies(ddraw wineheaders) -add_pch(ddraw ddraw_private.h SOURCE) +add_pch(ddraw precomp.h SOURCE) add_cd_file(TARGET ddraw DESTINATION reactos/system32 FOR all) diff --git a/dll/directx/wine/ddraw/clipper.c b/dll/directx/wine/ddraw/clipper.c index f1fadd429a..01cac40ec6 100644 --- a/dll/directx/wine/ddraw/clipper.c +++ b/dll/directx/wine/ddraw/clipper.c @@ -19,8 +19,13 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" +#include "wine/port.h" + #include "ddraw_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(ddraw); + static inline struct ddraw_clipper *impl_from_IDirectDrawClipper(IDirectDrawClipper *iface) { return CONTAINING_RECORD(iface, struct ddraw_clipper, IDirectDrawClipper_iface); @@ -67,7 +72,7 @@ static ULONG WINAPI ddraw_clipper_Release(IDirectDrawClipper *iface) { if (clipper->region) DeleteObject(clipper->region); - HeapFree(GetProcessHeap(), 0, clipper); + heap_free(clipper); }
return refcount; diff --git a/dll/directx/wine/ddraw/ddraw.c b/dll/directx/wine/ddraw/ddraw.c index 2ab9edd015..e5205c0d00 100644 --- a/dll/directx/wine/ddraw/ddraw.c +++ b/dll/directx/wine/ddraw/ddraw.c @@ -21,9 +21,14 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" +#include "wine/port.h" + #include "ddraw_private.h"
-#include <wine/exception.h> +#include "wine/exception.h" + +WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
static const struct ddraw *exclusive_ddraw; static HWND exclusive_window; @@ -45,6 +50,7 @@ static struct enum_device_entry char interface_name[100]; char device_name[100]; const GUID *device_guid; + DWORD remove_caps; } device_list7[] = { /* T&L HAL device */ @@ -52,6 +58,7 @@ static struct enum_device_entry "WINE Direct3D7 Hardware Transform and Lighting acceleration using WineD3D", "Wine D3D7 T&L HAL", &IID_IDirect3DTnLHalDevice, + 0, },
/* HAL device */ @@ -59,6 +66,7 @@ static struct enum_device_entry "WINE Direct3D7 Hardware acceleration using WineD3D", "Direct3D HAL", &IID_IDirect3DHALDevice, + 0, },
/* RGB device */ @@ -66,6 +74,7 @@ static struct enum_device_entry "WINE Direct3D7 RGB Software Emulation using WineD3D", "Wine D3D7 RGB", &IID_IDirect3DRGBDevice, + D3DDEVCAPS_HWTRANSFORMANDLIGHT, }, };
@@ -371,7 +380,7 @@ static void ddraw_destroy_swapchain(struct ddraw *ddraw) { wined3d_vertex_declaration_decref(ddraw->decls[i].decl); } - HeapFree(GetProcessHeap(), 0, ddraw->decls); + heap_free(ddraw->decls); ddraw->numConvertedDecls = 0;
if (FAILED(wined3d_device_uninit_3d(ddraw->wined3d_device))) @@ -437,7 +446,7 @@ static void ddraw_destroy(struct ddraw *This) This->d3ddevice->ddraw = NULL;
/* Now free the object */ - HeapFree(GetProcessHeap(), 0, This); + heap_free(This); }
/***************************************************************************** @@ -595,8 +604,7 @@ static HRESULT ddraw_attach_d3d_device(struct ddraw *ddraw, }
ddraw->declArraySize = 2; - ddraw->decls = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ddraw->decls) * ddraw->declArraySize); - if (!ddraw->decls) + if (!(ddraw->decls = heap_alloc_zero(ddraw->declArraySize * sizeof(*ddraw->decls)))) { ERR("Error allocating an array for the converted vertex decls.\n"); ddraw->declArraySize = 0; @@ -625,6 +633,7 @@ static HRESULT ddraw_create_swapchain(struct ddraw *ddraw, HWND window, BOOL win swapchain_desc.backbuffer_width = mode.width; swapchain_desc.backbuffer_height = mode.height; swapchain_desc.backbuffer_format = mode.format_id; + swapchain_desc.backbuffer_usage = WINED3DUSAGE_RENDERTARGET; swapchain_desc.swap_effect = WINED3D_SWAP_EFFECT_COPY; swapchain_desc.device_window = window; swapchain_desc.windowed = windowed; @@ -1430,6 +1439,28 @@ HRESULT ddraw_get_d3dcaps(const struct ddraw *ddraw, D3DDEVICEDESC7 *caps) return DD_OK; }
+HRESULT CALLBACK enum_zbuffer(DDPIXELFORMAT *format, void *ctx) +{ + DDCAPS *caps = ctx; + + switch (format->u1.dwZBufferBitDepth) + { + case 8: + caps->dwZBufferBitDepths |= DDBD_8; + break; + case 16: + caps->dwZBufferBitDepths |= DDBD_16; + break; + case 24: + caps->dwZBufferBitDepths |= DDBD_24; + break; + case 32: + caps->dwZBufferBitDepths |= DDBD_32; + break; + } + return D3DENUMRET_OK; +} + /***************************************************************************** * IDirectDraw7::GetCaps * @@ -1510,6 +1541,10 @@ static HRESULT WINAPI ddraw7_GetCaps(IDirectDraw7 *iface, DDCAPS *DriverCaps, DD caps.dwCaps |= DDCAPS_ALIGNSTRIDE; caps.dwAlignStrideAlign = DDRAW_STRIDE_ALIGNMENT;
+ caps.ddsOldCaps.dwCaps = caps.ddsCaps.dwCaps; + + IDirect3D7_EnumZBufferFormats(&ddraw->IDirect3D7_iface, &IID_IDirect3DHALDevice, enum_zbuffer, &caps); + if(DriverCaps) { DD_STRUCT_COPY_BYSIZE(DriverCaps, &caps); @@ -1733,7 +1768,7 @@ static HRESULT WINAPI ddraw7_GetFourCCCodes(IDirectDraw7 *iface, DWORD *NumCodes
outsize = NumCodes && Codes ? *NumCodes : 0;
- for (i = 0; i < (sizeof(formats) / sizeof(formats[0])); ++i) + for (i = 0; i < ARRAY_SIZE(formats); ++i) { if (SUCCEEDED(wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT, WINED3D_DEVICE_TYPE_HAL, mode.format_id, 0, WINED3D_RTYPE_TEXTURE_2D, formats[i]))) @@ -2057,7 +2092,14 @@ static HRESULT WINAPI d3d1_Initialize(IDirect3D *iface, REFIID riid) *****************************************************************************/ static HRESULT WINAPI ddraw7_FlipToGDISurface(IDirectDraw7 *iface) { - FIXME("iface %p stub!\n", iface); + struct ddraw *ddraw = impl_from_IDirectDraw7(iface); + + TRACE("iface %p.\n", iface); + + ddraw->flags |= DDRAW_GDI_FLIP; + + if (ddraw->primary) + ddraw_surface_update_frontbuffer(ddraw->primary, NULL, FALSE);
return DD_OK; } @@ -2384,13 +2426,13 @@ static HRESULT WINAPI ddraw7_EnumDisplayModes(IDirectDraw7 *iface, DWORD Flags, if (!cb) return DDERR_INVALIDPARAMS;
- enum_modes = HeapAlloc(GetProcessHeap(), 0, sizeof(*enum_modes) * enum_mode_array_size); - if (!enum_modes) return DDERR_OUTOFMEMORY; + if (!(enum_modes = heap_alloc(enum_mode_array_size * sizeof(*enum_modes)))) + return DDERR_OUTOFMEMORY;
wined3d_mutex_lock();
pixelformat.dwSize = sizeof(pixelformat); - for(fmt = 0; fmt < (sizeof(checkFormatList) / sizeof(checkFormatList[0])); fmt++) + for(fmt = 0; fmt < ARRAY_SIZE(checkFormatList); fmt++) { modenum = 0; while (wined3d_enum_adapter_modes(ddraw->wined3d, WINED3DADAPTER_DEFAULT, checkFormatList[fmt], @@ -2449,7 +2491,7 @@ static HRESULT WINAPI ddraw7_EnumDisplayModes(IDirectDraw7 *iface, DWORD Flags, if(cb(&callback_sd, Context) == DDENUMRET_CANCEL) { TRACE("Application asked to terminate the enumeration\n"); - HeapFree(GetProcessHeap(), 0, enum_modes); + heap_free(enum_modes); wined3d_mutex_unlock(); return DD_OK; } @@ -2459,11 +2501,9 @@ static HRESULT WINAPI ddraw7_EnumDisplayModes(IDirectDraw7 *iface, DWORD Flags, struct wined3d_display_mode *new_enum_modes;
enum_mode_array_size *= 2; - new_enum_modes = HeapReAlloc(GetProcessHeap(), 0, enum_modes, - sizeof(*new_enum_modes) * enum_mode_array_size); - if (!new_enum_modes) + if (!(new_enum_modes = heap_realloc(enum_modes, enum_mode_array_size * sizeof(*new_enum_modes)))) { - HeapFree(GetProcessHeap(), 0, enum_modes); + heap_free(enum_modes); wined3d_mutex_unlock(); return DDERR_OUTOFMEMORY; } @@ -2475,7 +2515,7 @@ static HRESULT WINAPI ddraw7_EnumDisplayModes(IDirectDraw7 *iface, DWORD Flags, }
TRACE("End of enumeration\n"); - HeapFree(GetProcessHeap(), 0, enum_modes); + heap_free(enum_modes); wined3d_mutex_unlock();
return DD_OK; @@ -3108,7 +3148,7 @@ static BOOL ddraw_match_surface_desc(const DDSURFACEDESC2 *requested, const DDSU if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags) return FALSE;
- for (i=0; i < sizeof(compare)/sizeof(compare[0]); i++) + for (i=0; i < ARRAY_SIZE(compare); i++) { if (requested->dwFlags & compare[i].flag && memcmp((const char *)provided + compare[i].offset, @@ -3189,46 +3229,97 @@ static HRESULT WINAPI ddraw7_EnumSurfaces(IDirectDraw7 *iface, DWORD Flags, { struct ddraw *ddraw = impl_from_IDirectDraw7(iface); struct ddraw_surface *surf; - BOOL all, nomatch; - DDSURFACEDESC2 desc; - struct list *entry, *entry2; + DWORD match_flags = Flags & (DDENUMSURFACES_ALL | DDENUMSURFACES_NOMATCH | DDENUMSURFACES_MATCH);
TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n", iface, Flags, DDSD, Context, Callback);
- all = Flags & DDENUMSURFACES_ALL; - nomatch = Flags & DDENUMSURFACES_NOMATCH; - if (!Callback) return DDERR_INVALIDPARAMS;
- wined3d_mutex_lock(); - - /* Use the _SAFE enumeration, the app may destroy enumerated surfaces */ - LIST_FOR_EACH_SAFE(entry, entry2, &ddraw->surface_list) + if (Flags & DDENUMSURFACES_CANBECREATED) { - surf = LIST_ENTRY(entry, struct ddraw_surface, surface_list_entry); + IDirectDrawSurface7 *surface; + DDSURFACEDESC2 testdesc; + HRESULT hr; + + if (match_flags != DDENUMSURFACES_MATCH) + return DDERR_INVALIDPARAMS;
- if (!surf->iface_count) + if (!DDSD) + return DDERR_INVALIDPARAMS; + + memcpy(&testdesc, DDSD, sizeof(testdesc)); + if (!(testdesc.dwFlags & DDSD_WIDTH)) { - WARN("Not enumerating surface %p because it doesn't have any references.\n", surf); - continue; + testdesc.dwFlags |= DDSD_WIDTH; + testdesc.dwWidth = 512; } + if (!(testdesc.dwFlags & DDSD_HEIGHT)) + { + testdesc.dwFlags |= DDSD_HEIGHT; + testdesc.dwHeight = 512; + } + + hr = IDirectDraw7_CreateSurface(iface, &testdesc, &surface, NULL); + if (SUCCEEDED(hr)) + { + surf = unsafe_impl_from_IDirectDrawSurface7(surface); + Callback(NULL, &surf->surface_desc, Context); + IDirectDrawSurface7_Release(surface); + } + else + ERR("Failed to create surface, hr %#x.\n", hr); + } + else if (Flags & DDENUMSURFACES_DOESEXIST) + { + BOOL all, nomatch; + DDSURFACEDESC2 desc; + struct list *entry, *entry2; + + /* a combination of match flags is not allowed */ + if (match_flags != 0 && + match_flags != DDENUMSURFACES_ALL && + match_flags != DDENUMSURFACES_MATCH && + match_flags != DDENUMSURFACES_NOMATCH) + return DDERR_INVALIDPARAMS; + + all = (Flags & DDENUMSURFACES_ALL) != 0; + nomatch = (Flags & DDENUMSURFACES_NOMATCH) != 0; + + if (!all && !DDSD) + return DDERR_INVALIDPARAMS; + + wined3d_mutex_lock();
- if (all || (nomatch != ddraw_match_surface_desc(DDSD, &surf->surface_desc))) + /* Use the _SAFE enumeration, the app may destroy enumerated surfaces */ + LIST_FOR_EACH_SAFE(entry, entry2, &ddraw->surface_list) { - TRACE("Enumerating surface %p.\n", surf); - desc = surf->surface_desc; - IDirectDrawSurface7_AddRef(&surf->IDirectDrawSurface7_iface); - if (Callback(&surf->IDirectDrawSurface7_iface, &desc, Context) != DDENUMRET_OK) + surf = LIST_ENTRY(entry, struct ddraw_surface, surface_list_entry); + + if (!surf->iface_count) { - wined3d_mutex_unlock(); - return DD_OK; + WARN("Not enumerating surface %p because it doesn't have any references.\n", surf); + continue; + } + + if (all || (nomatch != ddraw_match_surface_desc(DDSD, &surf->surface_desc))) + { + TRACE("Enumerating surface %p.\n", surf); + desc = surf->surface_desc; + IDirectDrawSurface7_AddRef(&surf->IDirectDrawSurface7_iface); + if (Callback(&surf->IDirectDrawSurface7_iface, &desc, Context) != DDENUMRET_OK) + { + wined3d_mutex_unlock(); + return DD_OK; + } } } - }
- wined3d_mutex_unlock(); + wined3d_mutex_unlock(); + } + else + return DDERR_INVALIDPARAMS;
return DD_OK; } @@ -3313,8 +3404,7 @@ HRESULT WINAPI DirectDrawCreateClipper(DWORD flags, IDirectDrawClipper **clipper
wined3d_mutex_lock();
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) { wined3d_mutex_unlock(); return E_OUTOFMEMORY; @@ -3324,7 +3414,7 @@ HRESULT WINAPI DirectDrawCreateClipper(DWORD flags, IDirectDrawClipper **clipper if (FAILED(hr)) { WARN("Failed to initialize clipper, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); wined3d_mutex_unlock(); return hr; } @@ -3424,8 +3514,7 @@ static HRESULT WINAPI ddraw7_CreatePalette(IDirectDraw7 *iface, DWORD Flags, return DDERR_NOCOOPERATIVELEVELSET; }
- object = HeapAlloc(GetProcessHeap(), 0, sizeof(*object)); - if (!object) + if (!(object = heap_alloc(sizeof(*object)))) { ERR("Out of memory when allocating memory for a palette implementation\n"); wined3d_mutex_unlock(); @@ -3436,7 +3525,7 @@ static HRESULT WINAPI ddraw7_CreatePalette(IDirectDraw7 *iface, DWORD Flags, if (FAILED(hr)) { WARN("Failed to initialize palette, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); wined3d_mutex_unlock(); return hr; } @@ -3626,6 +3715,7 @@ static HRESULT WINAPI d3d7_EnumDevices(IDirect3D7 *iface, LPD3DENUMDEVICESCALLBA { struct ddraw *ddraw = impl_from_IDirect3D7(iface); D3DDEVICEDESC7 device_desc7; + DWORD dev_caps; HRESULT hr; size_t i;
@@ -3642,11 +3732,15 @@ static HRESULT WINAPI d3d7_EnumDevices(IDirect3D7 *iface, LPD3DENUMDEVICESCALLBA return hr; }
- for (i = 0; i < sizeof(device_list7)/sizeof(device_list7[0]); i++) + dev_caps = device_desc7.dwDevCaps; + + for (i = 0; i < ARRAY_SIZE(device_list7); i++) { HRESULT ret;
device_desc7.deviceGUID = *device_list7[i].device_guid; + device_desc7.dwDevCaps = dev_caps & ~device_list7[i].remove_caps; + ret = callback(device_list7[i].interface_name, device_list7[i].device_name, &device_desc7, context); if (ret != DDENUMRET_OK) { @@ -3832,10 +3926,10 @@ static HRESULT WINAPI d3d3_CreateLight(IDirect3D3 *iface, IDirect3DLight **light
TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
- if (outer_unknown) return CLASS_E_NOAGGREGATION; + if (outer_unknown) + return CLASS_E_NOAGGREGATION;
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) { ERR("Failed to allocate light memory.\n"); return DDERR_OUTOFMEMORY; @@ -3982,8 +4076,7 @@ static HRESULT WINAPI d3d3_CreateViewport(IDirect3D3 *iface, IDirect3DViewport3
if (outer_unknown) return CLASS_E_NOAGGREGATION;
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) { ERR("Failed to allocate viewport memory.\n"); return DDERR_OUTOFMEMORY; @@ -4044,8 +4137,8 @@ static HRESULT WINAPI d3d3_FindDevice(IDirect3D3 *iface, D3DFINDDEVICESEARCH *fd
if (!fds || !fdr) return DDERR_INVALIDPARAMS;
- if (fds->dwSize != sizeof(D3DFINDDEVICESEARCH) - || fdr->dwSize != sizeof(D3DFINDDEVICERESULT)) + if (fds->dwSize != sizeof(D3DFINDDEVICESEARCH) || (fdr->dwSize != sizeof(D3DFINDDEVICERESULT1) && + fdr->dwSize != sizeof(D3DFINDDEVICERESULT2) && fdr->dwSize != sizeof(D3DFINDDEVICERESULT))) return DDERR_INVALIDPARAMS;
if ((fds->dwFlags & D3DFDS_COLORMODEL) @@ -4074,8 +4167,24 @@ static HRESULT WINAPI d3d3_FindDevice(IDirect3D3 *iface, D3DFINDDEVICESEARCH *fd /* Now return our own GUID */ ddraw_d3dcaps1_from_7(&desc1, &desc7); fdr->guid = IID_D3DDEVICE_WineD3D; - fdr->ddHwDesc = desc1; - fdr->ddSwDesc = desc1; + + if (fdr->dwSize == sizeof(D3DFINDDEVICERESULT1)) + { + D3DFINDDEVICERESULT1 *fdr1 = (D3DFINDDEVICERESULT1 *)fdr; + memcpy(&fdr1->ddHwDesc, &desc1, sizeof(fdr1->ddHwDesc)); + memcpy(&fdr1->ddSwDesc, &desc1, sizeof(fdr1->ddSwDesc)); + } + else if (fdr->dwSize == sizeof(D3DFINDDEVICERESULT2)) + { + D3DFINDDEVICERESULT2 *fdr2 = (D3DFINDDEVICERESULT2 *)fdr; + memcpy(&fdr2->ddHwDesc, &desc1, sizeof(fdr2->ddHwDesc)); + memcpy(&fdr2->ddSwDesc, &desc1, sizeof(fdr2->ddSwDesc)); + } + else + { + fdr->ddHwDesc = desc1; + fdr->ddSwDesc = desc1; + }
TRACE("Returning Wine's wined3d device with (undumped) capabilities.\n");
@@ -4132,7 +4241,7 @@ static HRESULT WINAPI d3d7_CreateDevice(IDirect3D7 *iface, REFCLSID riid, TRACE("iface %p, riid %s, surface %p, device %p.\n", iface, debugstr_guid(riid), surface, device);
wined3d_mutex_lock(); - if (SUCCEEDED(hr = d3d_device_create(ddraw, target, (IUnknown *)surface, 7, &object, NULL))) + if (SUCCEEDED(hr = d3d_device_create(ddraw, riid, target, (IUnknown *)surface, 7, &object, NULL))) { *device = &object->IDirect3DDevice7_iface; } @@ -4161,7 +4270,7 @@ static HRESULT WINAPI d3d3_CreateDevice(IDirect3D3 *iface, REFCLSID riid, return CLASS_E_NOAGGREGATION;
wined3d_mutex_lock(); - if (SUCCEEDED(hr = d3d_device_create(ddraw, surface_impl, (IUnknown *)surface, 3, &device_impl, NULL))) + if (SUCCEEDED(hr = d3d_device_create(ddraw, riid, surface_impl, (IUnknown *)surface, 3, &device_impl, NULL))) { *device = &device_impl->IDirect3DDevice3_iface; } @@ -4187,7 +4296,7 @@ static HRESULT WINAPI d3d2_CreateDevice(IDirect3D2 *iface, REFCLSID riid, iface, debugstr_guid(riid), surface, device);
wined3d_mutex_lock(); - if (SUCCEEDED(hr = d3d_device_create(ddraw, surface_impl, (IUnknown *)surface, 2, &device_impl, NULL))) + if (SUCCEEDED(hr = d3d_device_create(ddraw, riid, surface_impl, (IUnknown *)surface, 2, &device_impl, NULL))) { *device = &device_impl->IDirect3DDevice2_iface; } @@ -4357,7 +4466,7 @@ static HRESULT WINAPI d3d7_EnumZBufferFormats(IDirect3D7 *iface, REFCLSID device return hr; }
- for (i = 0; i < (sizeof(formats) / sizeof(*formats)); ++i) + for (i = 0; i < ARRAY_SIZE(formats); ++i) { if (SUCCEEDED(wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT, type, mode.format_id, WINED3DUSAGE_DEPTHSTENCIL, WINED3D_RTYPE_TEXTURE_2D, formats[i]))) @@ -4559,7 +4668,7 @@ static const struct IDirectDraw2Vtbl ddraw2_vtbl = ddraw2_GetAvailableVidMem, };
-static const struct IDirectDrawVtbl ddraw1_vtbl = +static struct IDirectDrawVtbl ddraw1_vtbl = { /* IUnknown */ ddraw1_QueryInterface, @@ -4698,11 +4807,12 @@ struct wined3d_vertex_declaration *ddraw_find_decl(struct ddraw *This, DWORD fvf fvf, This, &ddraw_null_wined3d_parent_ops, &pDecl); if (hr != S_OK) return NULL;
- if(This->declArraySize == This->numConvertedDecls) { - int grow = max(This->declArraySize / 2, 8); - convertedDecls = HeapReAlloc(GetProcessHeap(), 0, convertedDecls, - sizeof(convertedDecls[0]) * (This->numConvertedDecls + grow)); - if (!convertedDecls) + if (This->declArraySize == This->numConvertedDecls) + { + unsigned int grow = max(This->declArraySize / 2, 8); + + if (!(convertedDecls = heap_realloc(convertedDecls, + (This->numConvertedDecls + grow) * sizeof(*convertedDecls)))) { wined3d_vertex_declaration_decref(pDecl); return NULL; @@ -4818,7 +4928,7 @@ static HRESULT CDECL device_parent_surface_created(struct wined3d_device_parent return DD_OK; }
- if (!(ddraw_surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ddraw_surface)))) + if (!(ddraw_surface = heap_alloc_zero(sizeof(*ddraw_surface)))) { ERR("Failed to allocate surface memory.\n"); return DDERR_OUTOFVIDEOMEMORY; diff --git a/dll/directx/wine/ddraw/ddraw_private.h b/dll/directx/wine/ddraw/ddraw_private.h index 04ee59c05f..1454e8012a 100644 --- a/dll/directx/wine/ddraw/ddraw_private.h +++ b/dll/directx/wine/ddraw/ddraw_private.h @@ -19,30 +19,25 @@ #ifndef __WINE_DLLS_DDRAW_DDRAW_PRIVATE_H #define __WINE_DLLS_DDRAW_DDRAW_PRIVATE_H
-#include <config.h> -#include <wine/port.h> - #include <assert.h> -#include <stdarg.h> - -#define _INC_WINDOWS -#define COM_NO_WINDOW_H - +#include <limits.h> #define COBJMACROS #define NONAMELESSSTRUCT #define NONAMELESSUNION +#include "wine/debug.h" +#include "wine/heap.h"
-#include <windef.h> -#include <winbase.h> -#include <wingdi.h> -#include <winuser.h> -#include <d3d.h> +#include "winbase.h" +#include "wingdi.h" +#include "winuser.h"
-#include <wine/debug.h> -#include <wine/list.h> -#include <wine/wined3d.h> - -WINE_DEFAULT_DEBUG_CHANNEL(ddraw); +#include "d3d.h" +#include "ddraw.h" +#ifdef DDRAW_INIT_GUID +#include "initguid.h" +#endif +#include "wine/list.h" +#include "wine/wined3d.h"
#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
@@ -64,13 +59,14 @@ struct FvfToDecl #define DDRAW_NO3D 0x00000008 #define DDRAW_SCL_DDRAW1 0x00000010 #define DDRAW_SCL_RECURSIVE 0x00000020 +#define DDRAW_GDI_FLIP 0x00000040
#define DDRAW_STRIDE_ALIGNMENT 8
#define DDRAW_WINED3D_FLAGS (WINED3D_LEGACY_DEPTH_BIAS | WINED3D_VIDMEM_ACCOUNTING \ | WINED3D_RESTORE_MODE_ON_ACTIVATE | WINED3D_FOCUS_MESSAGES | WINED3D_PIXEL_CENTER_INTEGER \ | WINED3D_LEGACY_UNBOUND_RESOURCE_COLOR | WINED3D_NO_PRIMITIVE_RESTART \ - | WINED3D_LEGACY_CUBEMAP_FILTERING) + | WINED3D_LEGACY_CUBEMAP_FILTERING | WINED3D_LIMIT_VIEWPORT)
enum ddraw_device_state { @@ -309,6 +305,7 @@ struct d3d_device IUnknown IUnknown_inner; LONG ref; UINT version; + BOOL hw;
IUnknown *outer_unknown; struct wined3d_device *wined3d_device; @@ -353,7 +350,7 @@ struct d3d_device struct wined3d_vec4 user_clip_planes[D3DMAXUSERCLIPPLANES]; };
-HRESULT d3d_device_create(struct ddraw *ddraw, struct ddraw_surface *target, IUnknown *rt_iface, +HRESULT d3d_device_create(struct ddraw *ddraw, const GUID *guid, struct ddraw_surface *target, IUnknown *rt_iface, UINT version, struct d3d_device **device, IUnknown *outer_unknown) DECLSPEC_HIDDEN; enum wined3d_depth_buffer_type d3d_device_update_depth_stencil(struct d3d_device *device) DECLSPEC_HIDDEN;
@@ -592,6 +589,7 @@ void ddrawformat_from_wined3dformat(DDPIXELFORMAT *ddraw_format, BOOL wined3d_colour_from_ddraw_colour(const DDPIXELFORMAT *pf, const struct ddraw_palette *palette, DWORD colour, struct wined3d_color *wined3d_colour) DECLSPEC_HIDDEN; enum wined3d_format_id wined3dformat_from_ddrawformat(const DDPIXELFORMAT *format) DECLSPEC_HIDDEN; +unsigned int wined3dmapflags_from_ddrawmapflags(unsigned int flags) DECLSPEC_HIDDEN; void DDRAW_dump_surface_desc(const DDSURFACEDESC2 *lpddsd) DECLSPEC_HIDDEN; void dump_D3DMATRIX(const D3DMATRIX *mat) DECLSPEC_HIDDEN; void DDRAW_dump_DDCAPS(const DDCAPS *lpcaps) DECLSPEC_HIDDEN; diff --git a/dll/directx/wine/ddraw/device.c b/dll/directx/wine/ddraw/device.c index fe48ad3b36..24dbd3be50 100644 --- a/dll/directx/wine/ddraw/device.c +++ b/dll/directx/wine/ddraw/device.c @@ -27,8 +27,12 @@ * */
+#include "config.h" +#include "wine/port.h" + #include "ddraw_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(ddraw); WINE_DECLARE_DEBUG_CHANNEL(winediag);
/* The device ID */ @@ -318,7 +322,7 @@ static ULONG WINAPI d3d_device_inner_Release(IUnknown *iface) This->ddraw->d3ddevice = NULL;
/* Now free the structure */ - HeapFree(GetProcessHeap(), 0, This); + heap_free(This); wined3d_mutex_unlock(); }
@@ -659,8 +663,7 @@ static HRESULT WINAPI d3d_device1_CreateExecuteBuffer(IDirect3DDevice *iface, return CLASS_E_NOAGGREGATION;
/* Allocate the new Execute Buffer */ - object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if(!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) { ERR("Failed to allocate execute buffer memory.\n"); return DDERR_OUTOFMEMORY; @@ -670,7 +673,7 @@ static HRESULT WINAPI d3d_device1_CreateExecuteBuffer(IDirect3DDevice *iface, if (FAILED(hr)) { WARN("Failed to initialize execute buffer, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
@@ -1083,7 +1086,7 @@ static HRESULT d3d_device7_EnumTextureFormats(IDirect3DDevice7 *iface, return hr; }
- for (i = 0; i < sizeof(FormatList) / sizeof(*FormatList); ++i) + for (i = 0; i < ARRAY_SIZE(FormatList); ++i) { if (wined3d_check_device_format(device->ddraw->wined3d, WINED3DADAPTER_DEFAULT, WINED3D_DEVICE_TYPE_HAL, mode.format_id, WINED3DUSAGE_TEXTURE, WINED3D_RTYPE_TEXTURE_2D, FormatList[i]) == D3D_OK) @@ -1105,7 +1108,7 @@ static HRESULT d3d_device7_EnumTextureFormats(IDirect3DDevice7 *iface, } }
- for (i = 0; i < sizeof(BumpFormatList) / sizeof(*BumpFormatList); ++i) + for (i = 0; i < ARRAY_SIZE(BumpFormatList); ++i) { if (wined3d_check_device_format(device->ddraw->wined3d, WINED3DADAPTER_DEFAULT, WINED3D_DEVICE_TYPE_HAL, mode.format_id, WINED3DUSAGE_TEXTURE | WINED3DUSAGE_QUERY_LEGACYBUMPMAP, @@ -1211,7 +1214,7 @@ static HRESULT WINAPI d3d_device2_EnumTextureFormats(IDirect3DDevice2 *iface, return hr; }
- for (i = 0; i < sizeof(FormatList) / sizeof(*FormatList); ++i) + for (i = 0; i < ARRAY_SIZE(FormatList); ++i) { if (wined3d_check_device_format(device->ddraw->wined3d, 0, WINED3D_DEVICE_TYPE_HAL, mode.format_id, WINED3DUSAGE_TEXTURE, WINED3D_RTYPE_TEXTURE_2D, FormatList[i]) == D3D_OK) @@ -1270,7 +1273,7 @@ static HRESULT WINAPI d3d_device1_EnumTextureFormats(IDirect3DDevice *iface, static HRESULT WINAPI d3d_device1_CreateMatrix(IDirect3DDevice *iface, D3DMATRIXHANDLE *D3DMatHandle) { struct d3d_device *device = impl_from_IDirect3DDevice(iface); - D3DMATRIX *Matrix; + D3DMATRIX *matrix; DWORD h;
TRACE("iface %p, matrix_handle %p.\n", iface, D3DMatHandle); @@ -1278,8 +1281,7 @@ static HRESULT WINAPI d3d_device1_CreateMatrix(IDirect3DDevice *iface, D3DMATRIX if(!D3DMatHandle) return DDERR_INVALIDPARAMS;
- Matrix = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(D3DMATRIX)); - if(!Matrix) + if (!(matrix = heap_alloc_zero(sizeof(*matrix)))) { ERR("Out of memory when allocating a D3DMATRIX\n"); return DDERR_OUTOFMEMORY; @@ -1287,11 +1289,11 @@ static HRESULT WINAPI d3d_device1_CreateMatrix(IDirect3DDevice *iface, D3DMATRIX
wined3d_mutex_lock();
- h = ddraw_allocate_handle(&device->handle_table, Matrix, DDRAW_HANDLE_MATRIX); + h = ddraw_allocate_handle(&device->handle_table, matrix, DDRAW_HANDLE_MATRIX); if (h == DDRAW_INVALID_HANDLE) { ERR("Failed to allocate a matrix handle.\n"); - HeapFree(GetProcessHeap(), 0, Matrix); + heap_free(matrix); wined3d_mutex_unlock(); return DDERR_OUTOFMEMORY; } @@ -1442,7 +1444,7 @@ static HRESULT WINAPI d3d_device1_DeleteMatrix(IDirect3DDevice *iface, D3DMATRIX
wined3d_mutex_unlock();
- HeapFree(GetProcessHeap(), 0, m); + heap_free(m);
return D3D_OK; } @@ -1852,7 +1854,7 @@ static HRESULT d3d_device7_SetRenderTarget(IDirect3DDevice7 *iface, return DDERR_INVALIDCAPS; }
- if (!(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)) + if (device->hw && !(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)) { WARN("Surface %p is not in video memory.\n", target_impl); wined3d_mutex_unlock(); @@ -1928,7 +1930,7 @@ static HRESULT WINAPI d3d_device3_SetRenderTarget(IDirect3DDevice3 *iface, return DDERR_INVALIDPIXELFORMAT; }
- if (!(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)) + if (device->hw && !(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)) { WARN("Surface %p is not in video memory.\n", target_impl); IDirectDrawSurface4_AddRef(target); @@ -1977,7 +1979,7 @@ static HRESULT WINAPI d3d_device2_SetRenderTarget(IDirect3DDevice2 *iface, return DDERR_INVALIDPIXELFORMAT; }
- if (!(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)) + if (device->hw && !(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)) { WARN("Surface %p is not in video memory.\n", target_impl); IDirectDrawSurface_AddRef(target); @@ -2214,11 +2216,11 @@ static HRESULT WINAPI d3d_device3_Vertex(IDirect3DDevice3 *iface, void *vertex)
device->buffer_size = device->buffer_size ? device->buffer_size * 2 : device->vertex_size * 3; old_buffer = device->sysmem_vertex_buffer; - device->sysmem_vertex_buffer = HeapAlloc(GetProcessHeap(), 0, device->buffer_size); + device->sysmem_vertex_buffer = heap_alloc(device->buffer_size); if (old_buffer) { memcpy(device->sysmem_vertex_buffer, old_buffer, device->nb_vertices * device->vertex_size); - HeapFree(GetProcessHeap(), 0, old_buffer); + heap_free(old_buffer); } }
@@ -3461,15 +3463,22 @@ static HRESULT d3d_device_prepare_vertex_buffer(struct d3d_device *device, UINT if (device->vertex_buffer_size < min_size || !device->vertex_buffer) { UINT size = max(device->vertex_buffer_size * 2, min_size); + struct wined3d_buffer_desc desc; struct wined3d_buffer *buffer;
TRACE("Growing vertex buffer to %u bytes\n", size);
- hr = wined3d_buffer_create_vb(device->wined3d_device, size, WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY, - WINED3D_POOL_DEFAULT, NULL, &ddraw_null_wined3d_parent_ops, &buffer); - if (FAILED(hr)) + desc.byte_width = size; + desc.usage = WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY; + desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER; + desc.access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + desc.misc_flags = 0; + desc.structure_byte_stride = 0; + + if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc, + NULL, NULL, &ddraw_null_wined3d_parent_ops, &buffer))) { - ERR("(%p) wined3d_buffer_create_vb failed with hr = %08x\n", device, hr); + ERR("Failed to create vertex buffer, hr %#x.\n", hr); return hr; }
@@ -3524,7 +3533,7 @@ static HRESULT d3d_device7_DrawPrimitive(IDirect3DDevice7 *iface, wined3d_box.right = vb_pos + size; vb = wined3d_buffer_get_resource(device->vertex_buffer); if (FAILED(hr = wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box, - vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))) + WINED3D_MAP_WRITE | (vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))) goto done; memcpy(wined3d_map_desc.data, vertices, size); wined3d_resource_unmap(vb, 0); @@ -3646,15 +3655,22 @@ static HRESULT d3d_device_prepare_index_buffer(struct d3d_device *device, UINT m if (device->index_buffer_size < min_size || !device->index_buffer) { UINT size = max(device->index_buffer_size * 2, min_size); + struct wined3d_buffer_desc desc; struct wined3d_buffer *buffer;
TRACE("Growing index buffer to %u bytes\n", size);
- hr = wined3d_buffer_create_ib(device->wined3d_device, size, WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY, - WINED3D_POOL_DEFAULT, NULL, &ddraw_null_wined3d_parent_ops, &buffer); - if (FAILED(hr)) + desc.byte_width = size; + desc.usage = WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY | WINED3DUSAGE_STATICDECL; + desc.bind_flags = WINED3D_BIND_INDEX_BUFFER; + desc.access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + desc.misc_flags = 0; + desc.structure_byte_stride = 0; + + if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc, + NULL, NULL, &ddraw_null_wined3d_parent_ops, &buffer))) { - ERR("(%p) wined3d_buffer_create_ib failed with hr = %08x\n", device, hr); + ERR("Failed to create index buffer, hr %#x.\n", hr); return hr; }
@@ -3709,7 +3725,7 @@ static HRESULT d3d_device7_DrawIndexedPrimitive(IDirect3DDevice7 *iface, wined3d_box.right = vb_pos + vtx_size; vb = wined3d_buffer_get_resource(device->vertex_buffer); if (FAILED(hr = wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box, - vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))) + WINED3D_MAP_WRITE | (vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))) goto done; memcpy(wined3d_map_desc.data, vertices, vtx_size); wined3d_resource_unmap(vb, 0); @@ -3726,7 +3742,7 @@ static HRESULT d3d_device7_DrawIndexedPrimitive(IDirect3DDevice7 *iface, wined3d_box.right = ib_pos + idx_size; ib = wined3d_buffer_get_resource(device->index_buffer); if (FAILED(hr = wined3d_resource_map(ib, 0, &wined3d_map_desc, &wined3d_box, - ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))) + WINED3D_MAP_WRITE | (ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))) goto done; memcpy(wined3d_map_desc.data, indices, idx_size); wined3d_resource_unmap(ib, 0); @@ -4040,7 +4056,7 @@ static HRESULT d3d_device7_DrawPrimitiveStrided(IDirect3DDevice7 *iface, D3DPRIM wined3d_box.right = vb_pos + dst_size; vb = wined3d_buffer_get_resource(device->vertex_buffer); if (FAILED(hr = wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box, - vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))) + WINED3D_MAP_WRITE | (vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))) goto done; pack_strided_data(wined3d_map_desc.data, vertex_count, strided_data, fvf); wined3d_resource_unmap(vb, 0); @@ -4156,7 +4172,7 @@ static HRESULT d3d_device7_DrawIndexedPrimitiveStrided(IDirect3DDevice7 *iface, wined3d_box.right = vb_pos + vtx_dst_size; vb = wined3d_buffer_get_resource(device->vertex_buffer); if (FAILED(hr = wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box, - vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))) + WINED3D_MAP_WRITE | (vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))) goto done; pack_strided_data(wined3d_map_desc.data, vertex_count, strided_data, fvf); wined3d_resource_unmap(vb, 0); @@ -4173,7 +4189,7 @@ static HRESULT d3d_device7_DrawIndexedPrimitiveStrided(IDirect3DDevice7 *iface, wined3d_box.right = ib_pos + idx_size; ib = wined3d_buffer_get_resource(device->index_buffer); if (FAILED(hr = wined3d_resource_map(ib, 0, &wined3d_map_desc, &wined3d_box, - ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))) + WINED3D_MAP_WRITE | (ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))) goto done; memcpy(wined3d_map_desc.data, indices, idx_size); wined3d_resource_unmap(ib, 0); @@ -4393,7 +4409,7 @@ static HRESULT d3d_device7_DrawIndexedPrimitiveVB(IDirect3DDevice7 *iface, wined3d_box.right = ib_pos + index_count * sizeof(WORD); ib = wined3d_buffer_get_resource(device->index_buffer); if (FAILED(hr = wined3d_resource_map(ib, 0, &wined3d_map_desc, &wined3d_box, - ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))) + WINED3D_MAP_WRITE | (ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))) { ERR("Failed to map buffer, hr %#x.\n", hr); wined3d_mutex_unlock(); @@ -6887,7 +6903,7 @@ enum wined3d_depth_buffer_type d3d_device_update_depth_stencil(struct d3d_device return WINED3D_ZB_TRUE; }
-static HRESULT d3d_device_init(struct d3d_device *device, struct ddraw *ddraw, +static HRESULT d3d_device_init(struct d3d_device *device, struct ddraw *ddraw, BOOL hw, struct ddraw_surface *target, IUnknown *rt_iface, UINT version, IUnknown *outer_unknown) { static const D3DMATRIX ident = @@ -6910,6 +6926,7 @@ static HRESULT d3d_device_init(struct d3d_device *device, struct ddraw *ddraw, device->IUnknown_inner.lpVtbl = &d3d_device_inner_vtbl; device->ref = 1; device->version = version; + device->hw = hw;
if (outer_unknown) device->outer_unknown = outer_unknown; @@ -6960,14 +6977,18 @@ static HRESULT d3d_device_init(struct d3d_device *device, struct ddraw *ddraw, return D3D_OK; }
-HRESULT d3d_device_create(struct ddraw *ddraw, struct ddraw_surface *target, IUnknown *rt_iface, +HRESULT d3d_device_create(struct ddraw *ddraw, const GUID *guid, struct ddraw_surface *target, IUnknown *rt_iface, UINT version, struct d3d_device **device, IUnknown *outer_unknown) { struct d3d_device *object; + BOOL hw = TRUE; HRESULT hr;
- TRACE("ddraw %p, target %p, version %u, device %p, outer_unknown %p.\n", - ddraw, target, version, device, outer_unknown); + TRACE("ddraw %p, guid %s, target %p, version %u, device %p, outer_unknown %p.\n", + ddraw, debugstr_guid(guid), target, version, device, outer_unknown); + + if (IsEqualGUID(guid, &IID_IDirect3DRGBDevice)) + hw = FALSE;
if (!(target->surface_desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE) || (target->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER)) @@ -6982,7 +7003,7 @@ HRESULT d3d_device_create(struct ddraw *ddraw, struct ddraw_surface *target, IUn return DDERR_NOPALETTEATTACHED; }
- if (!(target->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)) + if (hw && !(target->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)) { WARN("Surface %p is not in video memory.\n", target); return D3DERR_SURFACENOTINVIDMEM; @@ -7002,17 +7023,16 @@ HRESULT d3d_device_create(struct ddraw *ddraw, struct ddraw_surface *target, IUn return DDERR_INVALIDPARAMS; }
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); - if (!object) + if (!(object = heap_alloc_zero(sizeof(*object)))) { ERR("Failed to allocate device memory.\n"); return DDERR_OUTOFMEMORY; }
- if (FAILED(hr = d3d_device_init(object, ddraw, target, rt_iface, version, outer_unknown))) + if (FAILED(hr = d3d_device_init(object, ddraw, hw, target, rt_iface, version, outer_unknown))) { WARN("Failed to initialize device, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, object); + heap_free(object); return hr; }
diff --git a/dll/directx/wine/ddraw/executebuffer.c b/dll/directx/wine/ddraw/executebuffer.c index 7b68bd70b5..17bea2764c 100644 --- a/dll/directx/wine/ddraw/executebuffer.c +++ b/dll/directx/wine/ddraw/executebuffer.c @@ -18,8 +18,13 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" +#include "wine/port.h" + #include "ddraw_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(ddraw); + /***************************************************************************** * _dump_executedata * _dump_D3DEXECUTEBUFFERDESC @@ -119,13 +124,20 @@ HRESULT d3d_execute_buffer_execute(struct d3d_execute_buffer *buffer,
if (buffer->index_size < index_count) { - struct wined3d_buffer *new_buffer; unsigned int new_size = max(buffer->index_size * 2, index_count); - - hr = wined3d_buffer_create_ib(device->wined3d_device, new_size * sizeof(*indices), - WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY, WINED3D_POOL_DEFAULT, - NULL, &ddraw_null_wined3d_parent_ops, &new_buffer); - if (FAILED(hr)) + struct wined3d_buffer *new_buffer; + struct wined3d_buffer_desc desc; + + desc.byte_width = new_size * sizeof(*indices); + desc.usage = WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY | WINED3DUSAGE_STATICDECL; + desc.bind_flags = WINED3D_BIND_INDEX_BUFFER; + desc.access = WINED3D_RESOURCE_ACCESS_GPU + | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + desc.misc_flags = 0; + desc.structure_byte_stride = 0; + + if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc, + NULL, NULL, &ddraw_null_wined3d_parent_ops, &new_buffer))) return hr;
buffer->index_size = new_size; @@ -141,9 +153,8 @@ HRESULT d3d_execute_buffer_execute(struct d3d_execute_buffer *buffer,
box.left = index_pos * sizeof(*indices); box.right = (index_pos + index_count) * sizeof(*indices); - hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->index_buffer), 0, - &map_desc, &box, index_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD); - if (FAILED(hr)) + if (FAILED(hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->index_buffer), 0, &map_desc, + &box, WINED3D_MAP_WRITE | (index_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD)))) return hr; indices = map_desc.data;
@@ -297,7 +308,10 @@ HRESULT d3d_execute_buffer_execute(struct d3d_execute_buffer *buffer, ci->wStart, ci->wDest, ci->dwCount, ci->dwFlags);
if (ci->dwFlags & D3DPROCESSVERTICES_UPDATEEXTENTS) - FIXME("D3DPROCESSVERTICES_UPDATEEXTENTS not implemented.\n"); + { + static int once; + if (!once++) FIXME("D3DPROCESSVERTICES_UPDATEEXTENTS not implemented.\n"); + } if (ci->dwFlags & D3DPROCESSVERTICES_NOCOLOR) FIXME("D3DPROCESSVERTICES_NOCOLOR not implemented.\n");
@@ -497,7 +511,7 @@ static ULONG WINAPI d3d_execute_buffer_Release(IDirect3DExecuteBuffer *iface) if (!ref) { if (buffer->need_free) - HeapFree(GetProcessHeap(), 0, buffer->desc.lpData); + heap_free(buffer->desc.lpData); if (buffer->index_buffer) wined3d_buffer_decref(buffer->index_buffer); if (buffer->dst_vertex_buffer) @@ -505,7 +519,7 @@ static ULONG WINAPI d3d_execute_buffer_Release(IDirect3DExecuteBuffer *iface) wined3d_buffer_decref(buffer->src_vertex_buffer); wined3d_buffer_decref(buffer->dst_vertex_buffer); } - HeapFree(GetProcessHeap(), 0, buffer); + heap_free(buffer); }
return ref; @@ -606,17 +620,25 @@ static HRESULT WINAPI d3d_execute_buffer_SetExecuteData(IDirect3DExecuteBuffer * { unsigned int new_size = max(data->dwVertexCount, buffer->vertex_size * 2); struct wined3d_buffer *src_buffer, *dst_buffer; + struct wined3d_buffer_desc desc;
- hr = wined3d_buffer_create_vb(buffer->d3ddev->wined3d_device, new_size * sizeof(D3DVERTEX), - WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY, WINED3D_POOL_SYSTEM_MEM, - NULL, &ddraw_null_wined3d_parent_ops, &src_buffer); - if (FAILED(hr)) + desc.byte_width = new_size * sizeof(D3DVERTEX); + desc.usage = 0; + desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER; + desc.access = WINED3D_RESOURCE_ACCESS_CPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + desc.misc_flags = 0; + desc.structure_byte_stride = 0; + + if (FAILED(hr = wined3d_buffer_create(buffer->d3ddev->wined3d_device, &desc, + NULL, NULL, &ddraw_null_wined3d_parent_ops, &src_buffer))) return hr;
- hr = wined3d_buffer_create_vb(buffer->d3ddev->wined3d_device, new_size * sizeof(D3DTLVERTEX), - WINED3DUSAGE_STATICDECL, WINED3D_POOL_DEFAULT, - NULL, &ddraw_null_wined3d_parent_ops, &dst_buffer); - if (FAILED(hr)) + desc.byte_width = new_size * sizeof(D3DTLVERTEX); + desc.usage = WINED3DUSAGE_STATICDECL; + desc.access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W; + + if (FAILED(hr = wined3d_buffer_create(buffer->d3ddev->wined3d_device, &desc, + NULL, NULL, &ddraw_null_wined3d_parent_ops, &dst_buffer))) { wined3d_buffer_decref(src_buffer); return hr; @@ -641,9 +663,8 @@ static HRESULT WINAPI d3d_execute_buffer_SetExecuteData(IDirect3DExecuteBuffer * { box.left = buffer->src_vertex_pos * sizeof(D3DVERTEX); box.right = box.left + data->dwVertexCount * sizeof(D3DVERTEX); - hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->src_vertex_buffer), 0, - &map_desc, &box, buffer->src_vertex_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD); - if (FAILED(hr)) + if (FAILED(hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->src_vertex_buffer), + 0, &map_desc, &box, WINED3D_MAP_WRITE))) return hr;
memcpy(map_desc.data, ((BYTE *)buffer->desc.lpData) + data->dwVertexOffset, @@ -773,8 +794,7 @@ HRESULT d3d_execute_buffer_init(struct d3d_execute_buffer *execute_buffer, if (!execute_buffer->desc.lpData && execute_buffer->desc.dwBufferSize) { execute_buffer->need_free = TRUE; - execute_buffer->desc.lpData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, execute_buffer->desc.dwBufferSize); - if (!execute_buffer->desc.lpData) + if (!(execute_buffer->desc.lpData = heap_alloc_zero(execute_buffer->desc.dwBufferSize))) { ERR("Failed to allocate execute buffer data.\n"); return DDERR_OUTOFMEMORY; diff --git a/dll/directx/wine/ddraw/light.c b/dll/directx/wine/ddraw/light.c index d20c132c37..9d0bb6028f 100644 --- a/dll/directx/wine/ddraw/light.c +++ b/dll/directx/wine/ddraw/light.c @@ -17,8 +17,13 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" +#include "wine/port.h" + #include "ddraw_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(ddraw); + /***************************************************************************** * light_update * @@ -128,7 +133,7 @@ static ULONG WINAPI d3d_light_Release(IDirect3DLight *iface)
if (!ref) { - HeapFree(GetProcessHeap(), 0, light); + heap_free(light); return 0; } return ref; diff --git a/dll/directx/wine/ddraw/main.c b/dll/directx/wine/ddraw/main.c index ea3cbbe42d..9c0a81ca18 100644 --- a/dll/directx/wine/ddraw/main.c +++ b/dll/directx/wine/ddraw/main.c @@ -21,11 +21,17 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
+#include "config.h" +#include "wine/port.h" + +#define DDRAW_INIT_GUID #include "ddraw_private.h" -#include <winreg.h> -#include <rpcproxy.h> +#include "rpcproxy.h"
#include "wine/exception.h" +#include "winreg.h" + +WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
static struct list global_ddraw_list = LIST_INIT(global_ddraw_list);
@@ -86,8 +92,7 @@ static void ddraw_enumerate_secondary_devices(struct wined3d *wined3d, LPDDENUMC /* Handle table functions */ BOOL ddraw_handle_table_init(struct ddraw_handle_table *t, UINT initial_size) { - t->entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, initial_size * sizeof(*t->entries)); - if (!t->entries) + if (!(t->entries = heap_alloc_zero(initial_size * sizeof(*t->entries)))) { ERR("Failed to allocate handle table memory.\n"); return FALSE; @@ -101,7 +106,7 @@ BOOL ddraw_handle_table_init(struct ddraw_handle_table *t, UINT initial_size)
void ddraw_handle_table_destroy(struct ddraw_handle_table *t) { - HeapFree(GetProcessHeap(), 0, t->entries); + heap_free(t->entries); memset(t, 0, sizeof(*t)); }
@@ -130,9 +135,9 @@ DWORD ddraw_allocate_handle(struct ddraw_handle_table *t, void *object, enum ddr { /* Grow the table */ UINT new_size = t->table_size + (t->table_size >> 1); - struct ddraw_handle_entry *new_entries = HeapReAlloc(GetProcessHeap(), - 0, t->entries, new_size * sizeof(*t->entries)); - if (!new_entries) + struct ddraw_handle_entry *new_entries; + + if (!(new_entries = heap_realloc(t->entries, new_size * sizeof(*t->entries)))) { ERR("Failed to grow the handle table.\n"); return DDRAW_INVALID_HANDLE; @@ -292,8 +297,7 @@ DDRAW_Create(const GUID *guid, flags = WINED3D_LEGACY_FFP_LIGHTING;
/* DirectDraw creation comes here */ - ddraw = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ddraw)); - if (!ddraw) + if (!(ddraw = heap_alloc_zero(sizeof(*ddraw)))) { ERR("Out of memory when creating DirectDraw\n"); return E_OUTOFMEMORY; @@ -303,7 +307,7 @@ DDRAW_Create(const GUID *guid, if (FAILED(hr)) { WARN("Failed to initialize ddraw object, hr %#x.\n", hr); - HeapFree(GetProcessHeap(), 0, ddraw); + heap_free(ddraw); return hr; }
@@ -664,7 +668,7 @@ static ULONG WINAPI ddraw_class_factory_Release(IClassFactory *iface) TRACE("%p decreasing refcount to %u.\n", factory, ref);
if (!ref) - HeapFree(GetProcessHeap(), 0, factory); + heap_free(factory);
return ref; } @@ -736,20 +740,20 @@ HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **out) && !IsEqualGUID(&IID_IUnknown, riid)) return E_NOINTERFACE;
- for (i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++) + for (i=0; i < ARRAY_SIZE(object_creation); i++) { ... 16675 lines suppressed ...
-
Amine Khaldi