Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/Makefile.kmk =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/Makefile.kmk (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/Makefile.kmk (revision 46521) @@ -0,0 +1,396 @@ +# $Id$ +## @file +# Makefile for the Wine D3D related dlls for VirtualBox. +# + +# +# Copyright (C) 2009-2012 Oracle Corporation +# +# This file is part of VirtualBox Open Source Edition (OSE), as +# available from http://www.virtualbox.org. This file is free software; +# you can redistribute it and/or modify it under the terms of the GNU +# General Public License (GPL) as published by the Free Software +# Foundation, in version 2 as it comes in the "COPYING" file of the +# VirtualBox OSE distribution. VirtualBox OSE is distributed in the +# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +# + + +SUB_DEPTH = ../../../../../.. +include $(KBUILD_PATH)/subheader.kmk + +# +# Template for building wine stuff. +# +TEMPLATE_VBoxGuestWineDLL = Template for building a wine DLL. +TEMPLATE_VBoxGuestWineDLL_EXTENDS = VBOXGUESTR3NPDLL +TEMPLATE_VBoxGuestWineDLL_DEFS = $(TEMPLATE_VBOXGUESTR3NPDLL_DEFS) \ + __WINESRC__ \ + WINE_UNICODE_API="" \ + _REENTRANT \ + WINE_NOWINSOCK \ + USE_WIN32_OPENGL \ + DLLDIR=\"\" \ + BINDIR=\"\" \ + LIB_TO_BINDIR=\"\" \ + LIB_TO_DLLDIR=\"\" \ + BIN_TO_DLLDIR=\"\" \ + LIB_TO_DATADIR=\"\" \ + BIN_TO_DATADIR=\"\" + +TEMPLATE_VBoxGuestWineDLL_DEFS.x86 = __i386__ + +# +# Template for building the D3D[89] stuff. +# +TEMPLATE_VBoxGuestWineD3DxDLL = Template for building the D3D8/9 stuff. +TEMPLATE_VBoxGuestWineD3DxDLL_EXTENDS = VBOXGUESTR3NPDLL +TEMPLATE_VBoxGuestWineD3DxDLL_EXTENDS_BY = appending +TEMPLATE_VBoxGuestWineD3DxDLL_SDKS = ReorderCompilerIncs $(VBOX_WINDDK_GST_WLH) +TEMPLATE_VBoxGuestWineD3DxDLL_DEFS = VBOX_USING_WINDDK_W7_OR_LATER +TEMPLATE_VBoxGuestWineD3DxDLL_DEFS.x86 = __i386__ +#TEMPLATE_VBoxGuestWineD3DxDLL_INCS.x86 = vbox/libWineStub/include +ifdef VBOX_WINE_WITH_IPRT + TEMPLATE_VBoxGuestWineD3DxDLL_DEFS = VBOX_WINE_WITH_IPRT + TEMPLATE_VBoxGuestWineD3DxDLL_LIBS = \ + $(VBOX_LIB_IPRT_GUEST_R3) \ + $(VBOX_LIB_VBGL_R3) +endif + + +if 0 +# +# libWine - ???. +# +DLLS.x86 += libWine +libWine_TEMPLATE = VBoxGuestWineDLL +libWine_INCS = \ + include +libWine_SOURCES := \ + libWine/wine.def \ + libWine/casemap.c \ + libWine/collation.c \ + libWine/compose.c \ + libWine/config.c \ + libWine/cptable.c \ + libWine/debug.c \ + libWine/fold.c \ + libWine/ldt.c \ + libWine/loader.c \ + libWine/mbtowc.c \ + libWine/mmap.c \ + libWine/port.c \ + libWine/sortkey.c \ + libWine/string.c \ + libWine/utf8.c \ + libWine/wctomb.c \ + libWine/wctype.c \ + libWine/c_037.c \ + libWine/c_424.c \ + libWine/c_437.c \ + libWine/c_500.c \ + libWine/c_737.c \ + libWine/c_775.c \ + libWine/c_850.c \ + libWine/c_852.c \ + libWine/c_855.c \ + libWine/c_856.c \ + libWine/c_857.c \ + libWine/c_860.c \ + libWine/c_861.c \ + libWine/c_862.c \ + libWine/c_863.c \ + libWine/c_864.c \ + libWine/c_865.c \ + libWine/c_866.c \ + libWine/c_869.c \ + libWine/c_874.c \ + libWine/c_875.c \ + libWine/c_878.c \ + libWine/c_932.c \ + libWine/c_936.c \ + libWine/c_949.c \ + libWine/c_950.c \ + libWine/c_1006.c \ + libWine/c_1026.c \ + libWine/c_1250.c \ + libWine/c_1251.c \ + libWine/c_1252.c \ + libWine/c_1253.c \ + libWine/c_1254.c \ + libWine/c_1255.c \ + libWine/c_1256.c \ + libWine/c_1257.c \ + libWine/c_1258.c \ + libWine/c_1361.c \ + libWine/c_10000.c \ + libWine/c_10006.c \ + libWine/c_10007.c \ + libWine/c_10029.c \ + libWine/c_10079.c \ + libWine/c_10081.c \ + libWine/c_20127.c \ + libWine/c_20866.c \ + libWine/c_20932.c \ + libWine/c_21866.c \ + libWine/c_28591.c \ + libWine/c_28592.c \ + libWine/c_28593.c \ + libWine/c_28594.c \ + libWine/c_28595.c \ + libWine/c_28596.c \ + libWine/c_28597.c \ + libWine/c_28598.c \ + libWine/c_28599.c \ + libWine/c_28600.c \ + libWine/c_28603.c \ + libWine/c_28604.c \ + libWine/c_28605.c \ + libWine/c_28606.c \ + libWine/version.c +endif # 0 + +# +# wined3d - ???. +# +DLLS += wined3d +wined3d_TEMPLATE = VBoxGuestWineDLL +wined3d_SDKS = ReorderCompilerIncs $(VBOX_WINDDK_GST_WLH) +wined3d_DEFS = \ + _USE_MATH_DEFINES \ + VBOX_USING_WINDDK_W7_OR_LATER \ + VBOX_WINE_WITHOUT_LIBWINE \ + VBOX_WINE_WITH_SINGLE_CONTEXT \ + VBOX_WINE_WITH_IPRT +# ^^^^ wined3d is now using iprt/asm.h, which includes iprt/assert.h, so iprt is required. +if "$(KBUILD_TYPE)" != "debug" || defined(VBOX_WINE_NO_DEBUG_MSGS) + wined3d_DEFS += WINE_NO_DEBUG_MSGS +endif +wined3d_DEFS += \ + VBOX_WITH_WINE_FIX_IBMTMR \ + VBOX_WITH_WINE_FIX_BUFOFFSET \ + VBOX_WITH_WINE_FIX_QUIRKS \ + VBOX_WITH_WINE_FIX_PBOPSM \ + VBOX_WITH_WINE_FIX_INITCLEAR \ + VBOX_WITH_WINE_DBG +#wined3d_DEFS += VBOX_WITH_WINE_FIXES +wined3d_INCS := \ + vbox/libWineStub/include +wined3d_SOURCES := \ + wined3d/arb_program_shader.c \ + wined3d/ati_fragment_shader.c \ + wined3d/buffer.c \ + wined3d/context.c \ + wined3d/device.c \ + wined3d/directx.c \ + wined3d/drawprim.c \ + wined3d/gl_compat.c \ + wined3d/glsl_shader.c \ + wined3d/nvidia_texture_shader.c \ + wined3d/palette.c \ + wined3d/query.c \ + wined3d/resource.c \ + wined3d/shader.c \ + wined3d/shader_sm1.c \ + wined3d/shader_sm4.c \ + wined3d/state.c \ + wined3d/stateblock.c \ + wined3d/surface.c \ + wined3d/swapchain.c \ + wined3d/texture.c \ + wined3d/utils.c \ + wined3d/vertexdeclaration.c \ + wined3d/view.c \ + wined3d/volume.c \ + wined3d/wined3d_main.c \ + wined3d/vboxext.c \ + wined3d/sampler.c \ + vbox/libWineStub/debug.c \ + vbox/VBoxDbgGl.c \ + wined3d/wined3d.def +wined3d_LIBS = \ + $(VBOX_LIB_IPRT_GUEST_R3) \ + $(VBOX_LIB_VBGL_R3) \ + $(PATH_STAGE_LIB)/VBoxOGL$(VBOX_SUFF_LIB) + +ifdef VBOX_WITH_WDDM + # + # wined3dwddm - ??? + # + DLLS += wined3dwddm + wined3dwddm_EXTENDS = wined3d + if defined(VBOX_SIGNING_MODE) + wined3dwddm_INSTTYPE.win = none + wined3dwddm_DEBUG_INSTTYPE.win = both + endif + wined3dwddm_DEFS = $(wined3d_DEFS) \ + VBOX_WITH_WDDM \ + IN_VBOXLIBWINE \ + VBOX_WINE_WITH_SHADER_CACHE +ifdef VBOX_WINE_WITH_PROFILE + wined3dwddm_DEFS += VBOX_WINE_WITH_PROFILE +endif + wined3dwddm_INCS = $(wined3d_INCS) \ + $(PATH_ROOT)/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm + wined3dwddm_SOURCES = $(subst wined3d.def,wined3dwddm.def,$(wined3d_SOURCES)) + wined3dwddm_LIBS = $(wined3d_LIBS) \ + $(VBOX_PATH_ADDITIONS_LIB)/VBoxDispMpLogger$(VBOX_SUFF_LIB) \ + $(VBOX_PATH_ADDITIONS_LIB)/VBoxCrHgsmi$(VBOX_SUFF_LIB) + + # + # wined3dwddm-x86 - ???. + # + DLLS.amd64 += wined3dwddm-x86 + wined3dwddm-x86_EXTENDS = wined3dwddm + wined3dwddm-x86_BLD_TRG_ARCH = x86 + wined3dwddm-x86_DEFS = $(wined3dwddm_DEFS) VBOX_WDDM_WOW64 + wined3dwddm-x86_LIBS = \ + $(VBOX_LIB_IPRT_GUEST_R3_X86) \ + $(VBOX_LIB_VBGL_R3_X86) \ + $(VBOX_PATH_ADDITIONS_LIB)/VBoxDispMpLogger-x86$(VBOX_SUFF_LIB) \ + $(VBOX_PATH_ADDITIONS_LIB)/VBoxCrHgsmi-x86$(VBOX_SUFF_LIB) \ + $(PATH_STAGE_LIB)/VBoxOGL-x86$(VBOX_SUFF_LIB) +endif # ifdef VBOX_WITH_WDDM + +# +# VBoxD3D8 - ???. +# +DLLS += VBoxD3D8 +VBoxD3D8_TEMPLATE = VBoxGuestWineDLL +VBoxD3D8_SDKS = ReorderCompilerIncs $(VBOX_WINDDK_GST_WLH) +VBoxD3D8_DEFS = _USE_MATH_DEFINES \ + VBOX_USING_WINDDK \ + VBOX_WINE_WITHOUT_LIBWINE +if "$(KBUILD_TYPE)" != "debug" || defined(VBOX_WINE_NO_DEBUG_MSGS) + VBoxD3D8_DEFS += WINE_NO_DEBUG_MSGS +endif +VBoxD3D8_INCS := \ + vbox/libWineStub/include +VBoxD3D8_SOURCES := \ + d3d8/d3d8_main.c \ + d3d8/buffer.c \ + d3d8/device.c \ + d3d8/directx.c \ + d3d8/shader.c \ + d3d8/surface.c \ + d3d8/swapchain.c \ + d3d8/texture.c \ + d3d8/vertexdeclaration.c \ + d3d8/volume.c \ + vbox/libWineStub/debug.c \ + d3d8/d3d8.def +VBoxD3D8_LIBS = \ + $(PATH_STAGE_LIB)/wined3d$(VBOX_SUFF_LIB) +ifdef VBOX_WINE_WITH_IPRT + VBoxD3D8_DEFS += VBOX_WINE_WITH_IPRT + VBoxD3D8_LIBS += \ + $(VBOX_LIB_IPRT_GUEST_R3) \ + $(VBOX_LIB_VBGL_R3) +endif + +# +# VBoxD3D9 - ???. +# +DLLS += VBoxD3D9 +VBoxD3D9_TEMPLATE = VBoxGuestWineDLL +VBoxD3D9_SDKS = ReorderCompilerIncs $(VBOX_WINDDK_GST_WLH) +VBoxD3D9_DEFS = _USE_MATH_DEFINES \ + VBOX_USING_WINDDK \ + VBOX_WINE_WITHOUT_LIBWINE +if "$(KBUILD_TYPE)" != "debug" || defined(VBOX_WINE_NO_DEBUG_MSGS) + VBoxD3D9_DEFS += WINE_NO_DEBUG_MSGS +endif +#@todo: do we actually need this? +#VBoxD3D9_DEFS += VBOX_WITH_WINE_FIX_NO9EX +VBoxD3D9_INCS := \ + vbox/libWineStub/include +VBoxD3D9_SOURCES := \ + d3d9/d3d9_main.c \ + d3d9/buffer.c \ + d3d9/device.c \ + d3d9/directx.c \ + d3d9/query.c \ + d3d9/shader.c \ + d3d9/stateblock.c \ + d3d9/surface.c \ + d3d9/swapchain.c \ + d3d9/texture.c \ + d3d9/vertexdeclaration.c \ + d3d9/volume.c \ + vbox/libWineStub/debug.c \ + d3d9/d3d9xpdm.def +VBoxD3D9_LIBS = \ + $(PATH_STAGE_LIB)/wined3d$(VBOX_SUFF_LIB) +ifdef VBOX_WINE_WITH_IPRT + VBoxD3D9_DEFS += VBOX_WINE_WITH_IPRT + VBoxD3D9_LIBS += \ + $(VBOX_LIB_IPRT_GUEST_R3) \ + $(VBOX_LIB_VBGL_R3) +endif + +ifdef VBOX_WITH_WDDM + # + # VBoxD3D9wddm - ???. + # + DLLS += VBoxD3D9wddm + VBoxD3D9wddm_EXTENDS = VBoxD3D9 + if defined(VBOX_SIGNING_MODE) && defined(VBOX_WITH_WDDM) + VBoxD3D9wddm_INSTTYPE = none + VBoxD3D9wddm_DEBUG_INSTTYPE = both + endif + VBoxD3D9wddm_INCS = $(VBoxD3D9_INCS) \ + $(PATH_ROOT)/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm + VBoxD3D9wddm_DEFS += $(VBoxD3D9_DEFS) \ + VBOX_WITH_WDDM \ + IN_VBOXWINEEX \ + VBOX_WINE_NO_LOCK + VBoxD3D9wddm_SOURCES = $(subst d3d9xpdm.def,d3d9wddm.def,$(VBoxD3D9_SOURCES)) + VBoxD3D9wddm_LIBS = \ + $(subst $(PATH_STAGE_LIB)/wined3d$(VBOX_SUFF_LIB),$(PATH_STAGE_LIB)/wined3dwddm$(VBOX_SUFF_LIB),$(VBoxD3D9_LIBS)) \ + $(VBOX_PATH_ADDITIONS_LIB)/VBoxDispMpLogger$(VBOX_SUFF_LIB) \ + $(VBOX_PATH_ADDITIONS_LIB)/VBoxCrHgsmi$(VBOX_SUFF_LIB) + + # + # VBoxD3D9wddm-x86 - For WOW64. + # + DLLS.amd64 += VBoxD3D9wddm-x86 + VBoxD3D9wddm-x86_EXTENDS = VBoxD3D9wddm + VBoxD3D9wddm-x86_BLD_TRG_ARCH = x86 + VBoxD3D9wddm-x86_DEFS = $(VBoxD3D9wddm_DEFS) VBOX_WDDM_WOW64 + VBoxD3D9wddm-x86_LIBS = $(PATH_STAGE_LIB)/wined3dwddm-x86$(VBOX_SUFF_LIB) + ifdef VBOX_WINE_WITH_IPRT + VBoxD3D9wddm-x86_LIBS += \ + $(VBOX_LIB_IPRT_GUEST_R3_X86) \ + $(VBOX_LIB_VBGL_R3_X86) + endif + VBoxD3D9wddm-x86_LIBS += \ + $(VBOX_PATH_ADDITIONS_LIB)/VBoxDispMpLogger-x86$(VBOX_SUFF_LIB) \ + $(VBOX_PATH_ADDITIONS_LIB)/VBoxCrHgsmi-x86$(VBOX_SUFF_LIB) +endif # VBOX_WITH_WDDM + +# +# d3d8 - ???. +# +DLLS += d3d8 +d3d8_TEMPLATE = VBoxGuestWineD3DxDLL +d3d8_SOURCES = \ + switcher/d3d8_main.c \ + switcher/sw_common.c \ + switcher/sw_d3d8.def \ + switcher/d3d8.rc + +# +# d3d9 - ???. +# +DLLS += d3d9 +d3d9_TEMPLATE = VBoxGuestWineD3DxDLL +d3d9_SOURCES = \ + switcher/d3d9_main.c \ + switcher/sw_common.c \ + switcher/d3d9.rc +d3d9_SOURCES.x86 = \ + switcher/sw_d3d9.def +d3d9_SOURCES.amd64 = \ + switcher/sw_d3d9xpdm.def + +include $(FILE_KBUILD_SUB_FOOTER) Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/buffer.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/buffer.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/buffer.c (revision 46521) @@ -0,0 +1,611 @@ +/* + * Copyright 2005 Oliver Stieber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * 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); +} + +static HRESULT WINAPI d3d8_vertexbuffer_QueryInterface(IDirect3DVertexBuffer8 *iface, REFIID riid, void **object) +{ + TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object); + + if (IsEqualGUID(riid, &IID_IDirect3DVertexBuffer8) + || IsEqualGUID(riid, &IID_IDirect3DResource8) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DVertexBuffer8_AddRef(iface); + *object = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *object = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d8_vertexbuffer_AddRef(IDirect3DVertexBuffer8 *iface) +{ + struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface); + ULONG refcount = InterlockedIncrement(&buffer->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, refcount); + + if (refcount == 1) + { + IDirect3DDevice8_AddRef(buffer->parent_device); + wined3d_mutex_lock(); + wined3d_buffer_incref(buffer->wined3d_buffer); + wined3d_mutex_unlock(); + } + + return refcount; +} + +static ULONG WINAPI d3d8_vertexbuffer_Release(IDirect3DVertexBuffer8 *iface) +{ + struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface); + ULONG refcount = InterlockedDecrement(&buffer->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, refcount); + + if (!refcount) + { + IDirect3DDevice8 *device = buffer->parent_device; + + wined3d_mutex_lock(); + wined3d_buffer_decref(buffer->wined3d_buffer); + wined3d_mutex_unlock(); + + /* Release the device last, as it may cause the device to be destroyed. */ + IDirect3DDevice8_Release(device); + } + + return refcount; +} + +static HRESULT WINAPI d3d8_vertexbuffer_GetDevice(IDirect3DVertexBuffer8 *iface, + IDirect3DDevice8 **device) +{ + struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = buffer->parent_device; + IDirect3DDevice8_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_vertexbuffer_SetPrivateData(IDirect3DVertexBuffer8 *iface, + REFGUID guid, const void *data, DWORD data_size, DWORD flags) +{ + struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n", + iface, debugstr_guid(guid), data, data_size, flags); + + wined3d_mutex_lock(); + resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); + hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_vertexbuffer_GetPrivateData(IDirect3DVertexBuffer8 *iface, + REFGUID guid, void *data, DWORD *data_size) +{ + struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %p.\n", + iface, debugstr_guid(guid), data, data_size); + + wined3d_mutex_lock(); + resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); + hr = wined3d_resource_get_private_data(resource, guid, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_vertexbuffer_FreePrivateData(IDirect3DVertexBuffer8 *iface, REFGUID guid) +{ + struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid)); + + wined3d_mutex_lock(); + resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); + hr = wined3d_resource_free_private_data(resource, guid); + wined3d_mutex_unlock(); + + return hr; +} + +static DWORD WINAPI d3d8_vertexbuffer_SetPriority(IDirect3DVertexBuffer8 *iface, DWORD priority) +{ + struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface); + DWORD previous; + + TRACE("iface %p, priority %u.\n", iface, priority); + + wined3d_mutex_lock(); + previous = wined3d_buffer_set_priority(buffer->wined3d_buffer, priority); + wined3d_mutex_unlock(); + + return previous; +} + +static DWORD WINAPI d3d8_vertexbuffer_GetPriority(IDirect3DVertexBuffer8 *iface) +{ + struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface); + DWORD priority; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + priority = wined3d_buffer_get_priority(buffer->wined3d_buffer); + wined3d_mutex_unlock(); + + return priority; +} + +static void WINAPI d3d8_vertexbuffer_PreLoad(IDirect3DVertexBuffer8 *iface) +{ + struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_buffer_preload(buffer->wined3d_buffer); + wined3d_mutex_unlock(); +} + +static D3DRESOURCETYPE WINAPI d3d8_vertexbuffer_GetType(IDirect3DVertexBuffer8 *iface) +{ + TRACE("iface %p.\n", iface); + + return D3DRTYPE_VERTEXBUFFER; +} + +static HRESULT WINAPI d3d8_vertexbuffer_Lock(IDirect3DVertexBuffer8 *iface, UINT offset, UINT size, + BYTE **data, DWORD flags) +{ + struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface); + HRESULT hr; + + TRACE("iface %p, offset %u, size %u, data %p, flags %#x.\n", + iface, offset, size, data, flags); + + wined3d_mutex_lock(); + hr = wined3d_buffer_map(buffer->wined3d_buffer, offset, size, data, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_vertexbuffer_Unlock(IDirect3DVertexBuffer8 *iface) +{ + struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_buffer_unmap(buffer->wined3d_buffer); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_vertexbuffer_GetDesc(IDirect3DVertexBuffer8 *iface, + D3DVERTEXBUFFER_DESC *desc) +{ + struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface); + struct wined3d_resource_desc wined3d_desc; + struct wined3d_resource *wined3d_resource; + + TRACE("iface %p, desc %p.\n", iface, desc); + + wined3d_mutex_lock(); + wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); + wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); + wined3d_mutex_unlock(); + + desc->Type = D3DRTYPE_VERTEXBUFFER; + desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; + desc->Pool = wined3d_desc.pool; + desc->Size = wined3d_desc.size; + desc->FVF = buffer->fvf; + desc->Format = D3DFMT_VERTEXDATA; + + return D3D_OK; +} + +static const IDirect3DVertexBuffer8Vtbl Direct3DVertexBuffer8_Vtbl = +{ + /* IUnknown */ + d3d8_vertexbuffer_QueryInterface, + d3d8_vertexbuffer_AddRef, + d3d8_vertexbuffer_Release, + /* IDirect3DResource8 */ + d3d8_vertexbuffer_GetDevice, + d3d8_vertexbuffer_SetPrivateData, + d3d8_vertexbuffer_GetPrivateData, + d3d8_vertexbuffer_FreePrivateData, + d3d8_vertexbuffer_SetPriority, + d3d8_vertexbuffer_GetPriority, + d3d8_vertexbuffer_PreLoad, + d3d8_vertexbuffer_GetType, + /* IDirect3DVertexBuffer8 */ + d3d8_vertexbuffer_Lock, + d3d8_vertexbuffer_Unlock, + d3d8_vertexbuffer_GetDesc, +}; + +static void STDMETHODCALLTYPE d3d8_vertexbuffer_wined3d_object_destroyed(void *parent) +{ + HeapFree(GetProcessHeap(), 0, parent); +} + +static const struct wined3d_parent_ops d3d8_vertexbuffer_wined3d_parent_ops = +{ + d3d8_vertexbuffer_wined3d_object_destroyed, +}; + +HRESULT vertexbuffer_init(struct d3d8_vertexbuffer *buffer, struct d3d8_device *device, + UINT size, DWORD usage, DWORD fvf, D3DPOOL pool) +{ + HRESULT hr; + + buffer->IDirect3DVertexBuffer8_iface.lpVtbl = &Direct3DVertexBuffer8_Vtbl; + buffer->refcount = 1; + buffer->fvf = fvf; + + 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); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d buffer, hr %#x.\n", hr); + return hr; + } + + buffer->parent_device = &device->IDirect3DDevice8_iface; + IDirect3DDevice8_AddRef(buffer->parent_device); + + return D3D_OK; +} + +struct d3d8_vertexbuffer *unsafe_impl_from_IDirect3DVertexBuffer8(IDirect3DVertexBuffer8 *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == &Direct3DVertexBuffer8_Vtbl); + + return impl_from_IDirect3DVertexBuffer8(iface); +} + +static inline struct d3d8_indexbuffer *impl_from_IDirect3DIndexBuffer8(IDirect3DIndexBuffer8 *iface) +{ + return CONTAINING_RECORD(iface, struct d3d8_indexbuffer, IDirect3DIndexBuffer8_iface); +} + +static HRESULT WINAPI d3d8_indexbuffer_QueryInterface(IDirect3DIndexBuffer8 *iface, REFIID riid, void **object) +{ + TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object); + + if (IsEqualGUID(riid, &IID_IDirect3DIndexBuffer8) + || IsEqualGUID(riid, &IID_IDirect3DResource8) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DIndexBuffer8_AddRef(iface); + *object = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *object = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d8_indexbuffer_AddRef(IDirect3DIndexBuffer8 *iface) +{ + struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface); + ULONG refcount = InterlockedIncrement(&buffer->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, refcount); + + if (refcount == 1) + { + IDirect3DDevice8_AddRef(buffer->parent_device); + wined3d_mutex_lock(); + wined3d_buffer_incref(buffer->wined3d_buffer); + wined3d_mutex_unlock(); + } + + return refcount; +} + +static ULONG WINAPI d3d8_indexbuffer_Release(IDirect3DIndexBuffer8 *iface) +{ + struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface); + ULONG refcount = InterlockedDecrement(&buffer->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, refcount); + + if (!refcount) + { + IDirect3DDevice8 *device = buffer->parent_device; + + wined3d_mutex_lock(); + wined3d_buffer_decref(buffer->wined3d_buffer); + wined3d_mutex_unlock(); + + /* Release the device last, as it may cause the device to be destroyed. */ + IDirect3DDevice8_Release(device); + } + + return refcount; +} + +static HRESULT WINAPI d3d8_indexbuffer_GetDevice(IDirect3DIndexBuffer8 *iface, + IDirect3DDevice8 **device) +{ + struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = buffer->parent_device; + IDirect3DDevice8_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_indexbuffer_SetPrivateData(IDirect3DIndexBuffer8 *iface, + REFGUID guid, const void *data, DWORD data_size, DWORD flags) +{ + struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n", + iface, debugstr_guid(guid), data, data_size, flags); + + wined3d_mutex_lock(); + resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); + hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_indexbuffer_GetPrivateData(IDirect3DIndexBuffer8 *iface, + REFGUID guid, void *data, DWORD *data_size) +{ + struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %p.\n", + iface, debugstr_guid(guid), data, data_size); + + wined3d_mutex_lock(); + resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); + hr = wined3d_resource_get_private_data(resource, guid, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_indexbuffer_FreePrivateData(IDirect3DIndexBuffer8 *iface, REFGUID guid) +{ + struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid)); + + wined3d_mutex_lock(); + resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); + hr = wined3d_resource_free_private_data(resource, guid); + wined3d_mutex_unlock(); + + return hr; +} + +static DWORD WINAPI d3d8_indexbuffer_SetPriority(IDirect3DIndexBuffer8 *iface, DWORD priority) +{ + struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface); + DWORD previous; + + TRACE("iface %p, priority %u.\n", iface, priority); + + wined3d_mutex_lock(); + previous = wined3d_buffer_set_priority(buffer->wined3d_buffer, priority); + wined3d_mutex_unlock(); + + return previous; +} + +static DWORD WINAPI d3d8_indexbuffer_GetPriority(IDirect3DIndexBuffer8 *iface) +{ + struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface); + DWORD priority; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + priority = wined3d_buffer_get_priority(buffer->wined3d_buffer); + wined3d_mutex_unlock(); + + return priority; +} + +static void WINAPI d3d8_indexbuffer_PreLoad(IDirect3DIndexBuffer8 *iface) +{ + struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_buffer_preload(buffer->wined3d_buffer); + wined3d_mutex_unlock(); +} + +static D3DRESOURCETYPE WINAPI d3d8_indexbuffer_GetType(IDirect3DIndexBuffer8 *iface) +{ + TRACE("iface %p.\n", iface); + + return D3DRTYPE_INDEXBUFFER; +} + +static HRESULT WINAPI d3d8_indexbuffer_Lock(IDirect3DIndexBuffer8 *iface, UINT offset, UINT size, + BYTE **data, DWORD flags) +{ + struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface); + HRESULT hr; + + TRACE("iface %p, offset %u, size %u, data %p, flags %#x.\n", + iface, offset, size, data, flags); + + wined3d_mutex_lock(); + hr = wined3d_buffer_map(buffer->wined3d_buffer, offset, size, data, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_indexbuffer_Unlock(IDirect3DIndexBuffer8 *iface) +{ + struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_buffer_unmap(buffer->wined3d_buffer); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_indexbuffer_GetDesc(IDirect3DIndexBuffer8 *iface, + D3DINDEXBUFFER_DESC *desc) +{ + struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface); + struct wined3d_resource_desc wined3d_desc; + struct wined3d_resource *wined3d_resource; + + TRACE("iface %p, desc %p.\n", iface, desc); + + wined3d_mutex_lock(); + wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); + wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); + wined3d_mutex_unlock(); + + desc->Format = d3dformat_from_wined3dformat(buffer->format); + desc->Type = D3DRTYPE_INDEXBUFFER; + desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; + desc->Pool = wined3d_desc.pool; + desc->Size = wined3d_desc.size; + + return D3D_OK; +} + +static const IDirect3DIndexBuffer8Vtbl d3d8_indexbuffer_vtbl = +{ + /* IUnknown */ + d3d8_indexbuffer_QueryInterface, + d3d8_indexbuffer_AddRef, + d3d8_indexbuffer_Release, + /* IDirect3DResource8 */ + d3d8_indexbuffer_GetDevice, + d3d8_indexbuffer_SetPrivateData, + d3d8_indexbuffer_GetPrivateData, + d3d8_indexbuffer_FreePrivateData, + d3d8_indexbuffer_SetPriority, + d3d8_indexbuffer_GetPriority, + d3d8_indexbuffer_PreLoad, + d3d8_indexbuffer_GetType, + /* IDirect3DIndexBuffer8 */ + d3d8_indexbuffer_Lock, + d3d8_indexbuffer_Unlock, + d3d8_indexbuffer_GetDesc, +}; + +static void STDMETHODCALLTYPE d3d8_indexbuffer_wined3d_object_destroyed(void *parent) +{ + HeapFree(GetProcessHeap(), 0, parent); +} + +static const struct wined3d_parent_ops d3d8_indexbuffer_wined3d_parent_ops = +{ + d3d8_indexbuffer_wined3d_object_destroyed, +}; + +HRESULT indexbuffer_init(struct d3d8_indexbuffer *buffer, struct d3d8_device *device, + UINT size, DWORD usage, D3DFORMAT format, D3DPOOL pool) +{ + HRESULT hr; + + buffer->IDirect3DIndexBuffer8_iface.lpVtbl = &d3d8_indexbuffer_vtbl; + buffer->refcount = 1; + 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); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d buffer, hr %#x.\n", hr); + return hr; + } + + buffer->parent_device = &device->IDirect3DDevice8_iface; + IDirect3DDevice8_AddRef(buffer->parent_device); + + return D3D_OK; +} + +struct d3d8_indexbuffer *unsafe_impl_from_IDirect3DIndexBuffer8(IDirect3DIndexBuffer8 *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == &d3d8_indexbuffer_vtbl); + + return impl_from_IDirect3DIndexBuffer8(iface); +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/d3d8.def =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/d3d8.def (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/d3d8.def (revision 46521) @@ -0,0 +1,10 @@ +; File generated automatically from ./dlls/d3d8/d3d8.spec; do not edit! + +LIBRARY d3d8.dll + +EXPORTS + D3D8GetSWInfo + DebugSetMute + Direct3DCreate8 + ValidatePixelShader + ValidateVertexShader Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/d3d8_main.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/d3d8_main.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/d3d8_main.c (revision 46521) @@ -0,0 +1,140 @@ +/* + * Direct3D 8 + * + * Copyright 2005 Oliver Stieber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + * + */ + +#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"); + return 0; +} + +void WINAPI DebugSetMute(void) { + /* nothing to do */ +} + +IDirect3D8 * WINAPI DECLSPEC_HOTPATCH Direct3DCreate8(UINT sdk_version) +{ + struct d3d8 *object; + + TRACE("sdk_version %#x.\n", sdk_version); + + if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)))) + return NULL; + + if (!d3d8_init(object)) + { + WARN("Failed to initialize d3d8.\n"); + HeapFree(GetProcessHeap(), 0, object); + return NULL; + } + + TRACE("Created d3d8 object %p.\n", object); + + return &object->IDirect3D8_iface; +} + +/* At process attach */ +BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv) +{ + TRACE("fdwReason=%d\n", fdwReason); + if (fdwReason == DLL_PROCESS_ATTACH) + DisableThreadLibraryCalls(hInstDLL); + + return TRUE; +} + +/*********************************************************************** + * 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 ret; + static BOOL warned; + + if (TRACE_ON(d3d8) || !warned) { + FIXME("(%p %p %p %d %p): stub\n", vertexshader, reserved1, reserved2, bool, toto); + warned = TRUE; + } + + if (!vertexshader) + return E_FAIL; + + if (reserved1 || reserved2) + return E_FAIL; + + switch(*vertexshader) { + case 0xFFFE0101: + case 0xFFFE0100: + ret=S_OK; + break; + default: + WARN("Invalid shader version token %#x.\n", *vertexshader); + ret=E_FAIL; + } + + return ret; +} + +/*********************************************************************** + * ValidatePixelShader (D3D8.@) + * + * PARAMS + * toto result? + */ +HRESULT WINAPI ValidatePixelShader(DWORD* pixelshader, DWORD* reserved1, BOOL bool, DWORD* toto) +{ + HRESULT ret; + static BOOL warned; + + if (TRACE_ON(d3d8) || !warned) { + FIXME("(%p %p %d %p): stub\n", pixelshader, reserved1, bool, toto); + warned = TRUE; + } + + if (!pixelshader) + return E_FAIL; + + if (reserved1) + return E_FAIL; + + switch(*pixelshader) { + case 0xFFFF0100: + case 0xFFFF0101: + case 0xFFFF0102: + case 0xFFFF0103: + case 0xFFFF0104: + ret=S_OK; + break; + default: + WARN("Invalid shader version token %#x.\n", *pixelshader); + ret=E_FAIL; + } + return ret; +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/d3d8_private.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/d3d8_private.h (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/d3d8_private.h (revision 46521) @@ -0,0 +1,302 @@ +/* + * Direct3D 8 private include file + * + * Copyright 2002-2004 Jason Edmeades + * Copyright 2003-2004 Raphael Junqueira + * Copyright 2004 Christian Costa + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D3D8_PRIVATE_H +#define __WINE_D3D8_PRIVATE_H + +#include +#include + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#define COBJMACROS +#include "windef.h" +#include "winbase.h" +#include "wingdi.h" +#include "wine/debug.h" +#include "d3d8.h" +#include "wine/wined3d.h" + +/* CreateVertexShader can return > 0xFFFF */ +#define VS_HIGHESTFIXEDFXF 0xF0000000 + +/* =========================================================================== + Macros + =========================================================================== */ +/* Not nice, but it lets wined3d support different versions of directx */ +#define WINECAPSTOD3D8CAPS(_pD3D8Caps, _pWineCaps) \ + _pD3D8Caps->DeviceType = (D3DDEVTYPE) _pWineCaps->DeviceType; \ + _pD3D8Caps->AdapterOrdinal = _pWineCaps->AdapterOrdinal; \ + _pD3D8Caps->Caps = _pWineCaps->Caps; \ + _pD3D8Caps->Caps2 = _pWineCaps->Caps2; \ + _pD3D8Caps->Caps3 = _pWineCaps->Caps3; \ + _pD3D8Caps->PresentationIntervals = _pWineCaps->PresentationIntervals; \ + _pD3D8Caps->CursorCaps = _pWineCaps->CursorCaps; \ + _pD3D8Caps->DevCaps = _pWineCaps->DevCaps; \ + _pD3D8Caps->PrimitiveMiscCaps = _pWineCaps->PrimitiveMiscCaps; \ + _pD3D8Caps->RasterCaps = _pWineCaps->RasterCaps; \ + _pD3D8Caps->ZCmpCaps = _pWineCaps->ZCmpCaps; \ + _pD3D8Caps->SrcBlendCaps = _pWineCaps->SrcBlendCaps; \ + _pD3D8Caps->DestBlendCaps = _pWineCaps->DestBlendCaps; \ + _pD3D8Caps->AlphaCmpCaps = _pWineCaps->AlphaCmpCaps; \ + _pD3D8Caps->ShadeCaps = _pWineCaps->ShadeCaps; \ + _pD3D8Caps->TextureCaps = _pWineCaps->TextureCaps; \ + _pD3D8Caps->TextureFilterCaps = _pWineCaps->TextureFilterCaps; \ + _pD3D8Caps->CubeTextureFilterCaps = _pWineCaps->CubeTextureFilterCaps; \ + _pD3D8Caps->VolumeTextureFilterCaps = _pWineCaps->VolumeTextureFilterCaps; \ + _pD3D8Caps->TextureAddressCaps = _pWineCaps->TextureAddressCaps; \ + _pD3D8Caps->VolumeTextureAddressCaps = _pWineCaps->VolumeTextureAddressCaps; \ + _pD3D8Caps->LineCaps = _pWineCaps->LineCaps; \ + _pD3D8Caps->MaxTextureWidth = _pWineCaps->MaxTextureWidth; \ + _pD3D8Caps->MaxTextureHeight = _pWineCaps->MaxTextureHeight; \ + _pD3D8Caps->MaxVolumeExtent = _pWineCaps->MaxVolumeExtent; \ + _pD3D8Caps->MaxTextureRepeat = _pWineCaps->MaxTextureRepeat; \ + _pD3D8Caps->MaxTextureAspectRatio = _pWineCaps->MaxTextureAspectRatio; \ + _pD3D8Caps->MaxAnisotropy = _pWineCaps->MaxAnisotropy; \ + _pD3D8Caps->MaxVertexW = _pWineCaps->MaxVertexW; \ + _pD3D8Caps->GuardBandLeft = _pWineCaps->GuardBandLeft; \ + _pD3D8Caps->GuardBandTop = _pWineCaps->GuardBandTop; \ + _pD3D8Caps->GuardBandRight = _pWineCaps->GuardBandRight; \ + _pD3D8Caps->GuardBandBottom = _pWineCaps->GuardBandBottom; \ + _pD3D8Caps->ExtentsAdjust = _pWineCaps->ExtentsAdjust; \ + _pD3D8Caps->StencilCaps = _pWineCaps->StencilCaps; \ + _pD3D8Caps->FVFCaps = _pWineCaps->FVFCaps; \ + _pD3D8Caps->TextureOpCaps = _pWineCaps->TextureOpCaps; \ + _pD3D8Caps->MaxTextureBlendStages = _pWineCaps->MaxTextureBlendStages; \ + _pD3D8Caps->MaxSimultaneousTextures = _pWineCaps->MaxSimultaneousTextures; \ + _pD3D8Caps->VertexProcessingCaps = _pWineCaps->VertexProcessingCaps; \ + _pD3D8Caps->MaxActiveLights = _pWineCaps->MaxActiveLights; \ + _pD3D8Caps->MaxUserClipPlanes = _pWineCaps->MaxUserClipPlanes; \ + _pD3D8Caps->MaxVertexBlendMatrices = _pWineCaps->MaxVertexBlendMatrices; \ + _pD3D8Caps->MaxVertexBlendMatrixIndex = _pWineCaps->MaxVertexBlendMatrixIndex; \ + _pD3D8Caps->MaxPointSize = _pWineCaps->MaxPointSize; \ + _pD3D8Caps->MaxPrimitiveCount = _pWineCaps->MaxPrimitiveCount; \ + _pD3D8Caps->MaxVertexIndex = _pWineCaps->MaxVertexIndex; \ + _pD3D8Caps->MaxStreams = _pWineCaps->MaxStreams; \ + _pD3D8Caps->MaxStreamStride = _pWineCaps->MaxStreamStride; \ + _pD3D8Caps->VertexShaderVersion = _pWineCaps->VertexShaderVersion; \ + _pD3D8Caps->MaxVertexShaderConst = _pWineCaps->MaxVertexShaderConst; \ + _pD3D8Caps->PixelShaderVersion = _pWineCaps->PixelShaderVersion; \ + _pD3D8Caps->MaxPixelShaderValue = _pWineCaps->PixelShader1xMaxValue; + +void fixup_caps(WINED3DCAPS *pWineCaps) DECLSPEC_HIDDEN; + +struct d3d8 +{ + IDirect3D8 IDirect3D8_iface; + LONG refcount; + struct wined3d *wined3d; +}; + +BOOL d3d8_init(struct d3d8 *d3d8) DECLSPEC_HIDDEN; + +/***************************************************************************** + * IDirect3DDevice8 implementation structure + */ + +#define D3D8_INITIAL_HANDLE_TABLE_SIZE 64 +#define D3D8_INVALID_HANDLE ~0U + +enum d3d8_handle_type +{ + D3D8_HANDLE_FREE, + D3D8_HANDLE_VS, + D3D8_HANDLE_PS, + D3D8_HANDLE_SB, +}; + +struct d3d8_handle_entry +{ + void *object; + enum d3d8_handle_type type; +}; + +struct d3d8_handle_table +{ + struct d3d8_handle_entry *entries; + struct d3d8_handle_entry *free_entries; + UINT table_size; + UINT entry_count; +}; + +struct FvfToDecl +{ + DWORD fvf; + struct d3d8_vertex_declaration *declaration; +}; + +struct d3d8_device +{ + /* IUnknown fields */ + IDirect3DDevice8 IDirect3DDevice8_iface; + struct wined3d_device_parent device_parent; + LONG ref; + struct wined3d_device *wined3d_device; + IDirect3D8 *d3d_parent; + struct d3d8_handle_table handle_table; + + /* FVF management */ + struct FvfToDecl *decls; + UINT numConvertedDecls, declArraySize; + + /* User data draws */ + struct wined3d_buffer *vertex_buffer; + UINT vertex_buffer_size; + UINT vertex_buffer_pos; + struct wined3d_buffer *index_buffer; + UINT index_buffer_size; + UINT index_buffer_pos; + + /* Avoids recursion with nested ReleaseRef to 0 */ + BOOL inDestruction; + BOOL lost; +}; + +HRESULT device_init(struct d3d8_device *device, struct d3d8 *parent, struct wined3d *wined3d, UINT adapter, + D3DDEVTYPE device_type, HWND focus_window, DWORD flags, D3DPRESENT_PARAMETERS *parameters) DECLSPEC_HIDDEN; + +struct d3d8_volume +{ + IDirect3DVolume8 IDirect3DVolume8_iface; + LONG refcount; + struct wined3d_volume *wined3d_volume; + IUnknown *container; + IUnknown *forwardReference; +}; + +HRESULT volume_init(struct d3d8_volume *volume, struct d3d8_device *device, UINT width, UINT height, + UINT depth, DWORD usage, enum wined3d_format_id format, enum wined3d_pool pool) DECLSPEC_HIDDEN; + +struct d3d8_swapchain +{ + IDirect3DSwapChain8 IDirect3DSwapChain8_iface; + LONG refcount; + struct wined3d_swapchain *wined3d_swapchain; + IDirect3DDevice8 *parent_device; +}; + +HRESULT d3d8_swapchain_create(struct d3d8_device *device, struct wined3d_swapchain_desc *desc, + struct d3d8_swapchain **swapchain) DECLSPEC_HIDDEN; + +struct d3d8_surface +{ + IDirect3DSurface8 IDirect3DSurface8_iface; + LONG refcount; + struct wined3d_surface *wined3d_surface; + IDirect3DDevice8 *parent_device; + + /* The surface container */ + IUnknown *container; + + /* If set forward refcounting to this object */ + IUnknown *forwardReference; +}; + +HRESULT surface_init(struct d3d8_surface *surface, struct d3d8_device *device, UINT width, UINT height, + D3DFORMAT format, DWORD flags, DWORD usage, D3DPOOL pool, D3DMULTISAMPLE_TYPE multisample_type, + DWORD multisample_quality) DECLSPEC_HIDDEN; +struct d3d8_surface *unsafe_impl_from_IDirect3DSurface8(IDirect3DSurface8 *iface) DECLSPEC_HIDDEN; + +struct d3d8_vertexbuffer +{ + IDirect3DVertexBuffer8 IDirect3DVertexBuffer8_iface; + LONG refcount; + struct wined3d_buffer *wined3d_buffer; + IDirect3DDevice8 *parent_device; + DWORD fvf; +}; + +HRESULT vertexbuffer_init(struct d3d8_vertexbuffer *buffer, struct d3d8_device *device, + UINT size, DWORD usage, DWORD fvf, D3DPOOL pool) DECLSPEC_HIDDEN; +struct d3d8_vertexbuffer *unsafe_impl_from_IDirect3DVertexBuffer8(IDirect3DVertexBuffer8 *iface) DECLSPEC_HIDDEN; + +struct d3d8_indexbuffer +{ + IDirect3DIndexBuffer8 IDirect3DIndexBuffer8_iface; + LONG refcount; + struct wined3d_buffer *wined3d_buffer; + IDirect3DDevice8 *parent_device; + enum wined3d_format_id format; +}; + +HRESULT indexbuffer_init(struct d3d8_indexbuffer *buffer, struct d3d8_device *device, + UINT size, DWORD usage, D3DFORMAT format, D3DPOOL pool) DECLSPEC_HIDDEN; +struct d3d8_indexbuffer *unsafe_impl_from_IDirect3DIndexBuffer8(IDirect3DIndexBuffer8 *iface) DECLSPEC_HIDDEN; + +struct d3d8_texture +{ + IDirect3DBaseTexture8 IDirect3DBaseTexture8_iface; + LONG refcount; + struct wined3d_texture *wined3d_texture; + IDirect3DDevice8 *parent_device; +}; + +HRESULT cubetexture_init(struct d3d8_texture *texture, struct d3d8_device *device, + UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool) DECLSPEC_HIDDEN; +HRESULT texture_init(struct d3d8_texture *texture, struct d3d8_device *device, + UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool) DECLSPEC_HIDDEN; +HRESULT volumetexture_init(struct d3d8_texture *texture, struct d3d8_device *device, + UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool) DECLSPEC_HIDDEN; +struct d3d8_texture *unsafe_impl_from_IDirect3DBaseTexture8(IDirect3DBaseTexture8 *iface) DECLSPEC_HIDDEN; + +struct d3d8_vertex_declaration +{ + DWORD *elements; + DWORD elements_size; /* Size of elements, in bytes */ + struct wined3d_vertex_declaration *wined3d_vertex_declaration; + DWORD shader_handle; +}; + +void d3d8_vertex_declaration_destroy(struct d3d8_vertex_declaration *declaration) DECLSPEC_HIDDEN; +HRESULT d3d8_vertex_declaration_init(struct d3d8_vertex_declaration *declaration, + struct d3d8_device *device, const DWORD *elements, DWORD shader_handle) DECLSPEC_HIDDEN; +HRESULT d3d8_vertex_declaration_init_fvf(struct d3d8_vertex_declaration *declaration, + struct d3d8_device *device, DWORD fvf) DECLSPEC_HIDDEN; + +struct d3d8_vertex_shader +{ + struct d3d8_vertex_declaration *vertex_declaration; + struct wined3d_shader *wined3d_shader; +}; + +void d3d8_vertex_shader_destroy(struct d3d8_vertex_shader *shader) DECLSPEC_HIDDEN; +HRESULT d3d8_vertex_shader_init(struct d3d8_vertex_shader *shader, struct d3d8_device *device, + const DWORD *declaration, const DWORD *byte_code, DWORD shader_handle, DWORD usage) DECLSPEC_HIDDEN; + +#define D3D8_MAX_VERTEX_SHADER_CONSTANTF 256 + +struct d3d8_pixel_shader +{ + DWORD handle; + struct wined3d_shader *wined3d_shader; +}; + +void d3d8_pixel_shader_destroy(struct d3d8_pixel_shader *shader) DECLSPEC_HIDDEN; +HRESULT d3d8_pixel_shader_init(struct d3d8_pixel_shader *shader, struct d3d8_device *device, + const DWORD *byte_code, DWORD shader_handle) DECLSPEC_HIDDEN; + +D3DFORMAT d3dformat_from_wined3dformat(enum wined3d_format_id format) DECLSPEC_HIDDEN; +enum wined3d_format_id wined3dformat_from_d3dformat(D3DFORMAT format) 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; + +#endif /* __WINE_D3DX8_PRIVATE_H */ Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/device.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/device.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/device.c (revision 46521) @@ -0,0 +1,3154 @@ +/* + * IDirect3DDevice8 implementation + * + * Copyright 2002-2004 Jason Edmeades + * Copyright 2004 Christian Costa + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "config.h" + +#include +#include + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#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); + +D3DFORMAT d3dformat_from_wined3dformat(enum wined3d_format_id format) +{ + BYTE *c = (BYTE *)&format; + + /* Don't translate FOURCC formats */ + if (isprint(c[0]) && isprint(c[1]) && isprint(c[2]) && isprint(c[3])) return format; + + switch(format) + { + case WINED3DFMT_UNKNOWN: return D3DFMT_UNKNOWN; + case WINED3DFMT_B8G8R8_UNORM: return D3DFMT_R8G8B8; + case WINED3DFMT_B8G8R8A8_UNORM: return D3DFMT_A8R8G8B8; + case WINED3DFMT_B8G8R8X8_UNORM: return D3DFMT_X8R8G8B8; + case WINED3DFMT_B5G6R5_UNORM: return D3DFMT_R5G6B5; + case WINED3DFMT_B5G5R5X1_UNORM: return D3DFMT_X1R5G5B5; + case WINED3DFMT_B5G5R5A1_UNORM: return D3DFMT_A1R5G5B5; + case WINED3DFMT_B4G4R4A4_UNORM: return D3DFMT_A4R4G4B4; + case WINED3DFMT_B2G3R3_UNORM: return D3DFMT_R3G3B2; + case WINED3DFMT_A8_UNORM: return D3DFMT_A8; + case WINED3DFMT_B2G3R3A8_UNORM: return D3DFMT_A8R3G3B2; + case WINED3DFMT_B4G4R4X4_UNORM: return D3DFMT_X4R4G4B4; + case WINED3DFMT_R10G10B10A2_UNORM: return D3DFMT_A2B10G10R10; + case WINED3DFMT_R16G16_UNORM: return D3DFMT_G16R16; + case WINED3DFMT_P8_UINT_A8_UNORM: return D3DFMT_A8P8; + case WINED3DFMT_P8_UINT: return D3DFMT_P8; + case WINED3DFMT_L8_UNORM: return D3DFMT_L8; + case WINED3DFMT_L8A8_UNORM: return D3DFMT_A8L8; + case WINED3DFMT_L4A4_UNORM: return D3DFMT_A4L4; + case WINED3DFMT_R8G8_SNORM: return D3DFMT_V8U8; + case WINED3DFMT_R5G5_SNORM_L6_UNORM: return D3DFMT_L6V5U5; + case WINED3DFMT_R8G8_SNORM_L8X8_UNORM: return D3DFMT_X8L8V8U8; + case WINED3DFMT_R8G8B8A8_SNORM: return D3DFMT_Q8W8V8U8; + case WINED3DFMT_R16G16_SNORM: return D3DFMT_V16U16; + case WINED3DFMT_R10G11B11_SNORM: return D3DFMT_W11V11U10; + case WINED3DFMT_R10G10B10_SNORM_A2_UNORM: return D3DFMT_A2W10V10U10; + case WINED3DFMT_D16_LOCKABLE: return D3DFMT_D16_LOCKABLE; + case WINED3DFMT_D32_UNORM: return D3DFMT_D32; + case WINED3DFMT_S1_UINT_D15_UNORM: return D3DFMT_D15S1; + case WINED3DFMT_D24_UNORM_S8_UINT: return D3DFMT_D24S8; + case WINED3DFMT_X8D24_UNORM: return D3DFMT_D24X8; + case WINED3DFMT_S4X4_UINT_D24_UNORM: return D3DFMT_D24X4S4; + case WINED3DFMT_D16_UNORM: return D3DFMT_D16; + case WINED3DFMT_VERTEXDATA: return D3DFMT_VERTEXDATA; + case WINED3DFMT_R16_UINT: return D3DFMT_INDEX16; + case WINED3DFMT_R32_UINT: return D3DFMT_INDEX32; + default: + FIXME("Unhandled wined3d format %#x.\n", format); + return D3DFMT_UNKNOWN; + } +} + +enum wined3d_format_id wined3dformat_from_d3dformat(D3DFORMAT format) +{ + BYTE *c = (BYTE *)&format; + + /* Don't translate FOURCC formats */ + if (isprint(c[0]) && isprint(c[1]) && isprint(c[2]) && isprint(c[3])) return format; + + switch(format) + { + case D3DFMT_UNKNOWN: return WINED3DFMT_UNKNOWN; + case D3DFMT_R8G8B8: return WINED3DFMT_B8G8R8_UNORM; + case D3DFMT_A8R8G8B8: return WINED3DFMT_B8G8R8A8_UNORM; + case D3DFMT_X8R8G8B8: return WINED3DFMT_B8G8R8X8_UNORM; + case D3DFMT_R5G6B5: return WINED3DFMT_B5G6R5_UNORM; + case D3DFMT_X1R5G5B5: return WINED3DFMT_B5G5R5X1_UNORM; + case D3DFMT_A1R5G5B5: return WINED3DFMT_B5G5R5A1_UNORM; + case D3DFMT_A4R4G4B4: return WINED3DFMT_B4G4R4A4_UNORM; + case D3DFMT_R3G3B2: return WINED3DFMT_B2G3R3_UNORM; + case D3DFMT_A8: return WINED3DFMT_A8_UNORM; + case D3DFMT_A8R3G3B2: return WINED3DFMT_B2G3R3A8_UNORM; + case D3DFMT_X4R4G4B4: return WINED3DFMT_B4G4R4X4_UNORM; + case D3DFMT_A2B10G10R10: return WINED3DFMT_R10G10B10A2_UNORM; + case D3DFMT_G16R16: return WINED3DFMT_R16G16_UNORM; + case D3DFMT_A8P8: return WINED3DFMT_P8_UINT_A8_UNORM; + case D3DFMT_P8: return WINED3DFMT_P8_UINT; + case D3DFMT_L8: return WINED3DFMT_L8_UNORM; + case D3DFMT_A8L8: return WINED3DFMT_L8A8_UNORM; + case D3DFMT_A4L4: return WINED3DFMT_L4A4_UNORM; + case D3DFMT_V8U8: return WINED3DFMT_R8G8_SNORM; + case D3DFMT_L6V5U5: return WINED3DFMT_R5G5_SNORM_L6_UNORM; + case D3DFMT_X8L8V8U8: return WINED3DFMT_R8G8_SNORM_L8X8_UNORM; + case D3DFMT_Q8W8V8U8: return WINED3DFMT_R8G8B8A8_SNORM; + case D3DFMT_V16U16: return WINED3DFMT_R16G16_SNORM; + case D3DFMT_W11V11U10: return WINED3DFMT_R10G11B11_SNORM; + case D3DFMT_A2W10V10U10: return WINED3DFMT_R10G10B10_SNORM_A2_UNORM; + case D3DFMT_D16_LOCKABLE: return WINED3DFMT_D16_LOCKABLE; + case D3DFMT_D32: return WINED3DFMT_D32_UNORM; + case D3DFMT_D15S1: return WINED3DFMT_S1_UINT_D15_UNORM; + case D3DFMT_D24S8: return WINED3DFMT_D24_UNORM_S8_UINT; + case D3DFMT_D24X8: return WINED3DFMT_X8D24_UNORM; + case D3DFMT_D24X4S4: return WINED3DFMT_S4X4_UINT_D24_UNORM; + case D3DFMT_D16: return WINED3DFMT_D16_UNORM; + case D3DFMT_VERTEXDATA: return WINED3DFMT_VERTEXDATA; + case D3DFMT_INDEX16: return WINED3DFMT_R16_UINT; + case D3DFMT_INDEX32: return WINED3DFMT_R32_UINT; + default: + FIXME("Unhandled D3DFORMAT %#x\n", format); + return WINED3DFMT_UNKNOWN; + } +} + +static UINT vertex_count_from_primitive_count(D3DPRIMITIVETYPE primitive_type, UINT primitive_count) +{ + switch(primitive_type) + { + case D3DPT_POINTLIST: + return primitive_count; + + case D3DPT_LINELIST: + return primitive_count * 2; + + case D3DPT_LINESTRIP: + return primitive_count + 1; + + case D3DPT_TRIANGLELIST: + return primitive_count * 3; + + case D3DPT_TRIANGLESTRIP: + case D3DPT_TRIANGLEFAN: + return primitive_count + 2; + + default: + FIXME("Unhandled primitive type %#x\n", primitive_type); + return 0; + } +} + +static void present_parameters_from_wined3d_swapchain_desc(D3DPRESENT_PARAMETERS *present_parameters, + const struct wined3d_swapchain_desc *swapchain_desc) +{ + present_parameters->BackBufferWidth = swapchain_desc->backbuffer_width; + present_parameters->BackBufferHeight = swapchain_desc->backbuffer_height; + 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->hDeviceWindow = swapchain_desc->device_window; + present_parameters->Windowed = swapchain_desc->windowed; + present_parameters->EnableAutoDepthStencil = swapchain_desc->enable_auto_depth_stencil; + present_parameters->AutoDepthStencilFormat + = d3dformat_from_wined3dformat(swapchain_desc->auto_depth_stencil_format); + present_parameters->Flags = swapchain_desc->flags; + present_parameters->FullScreen_RefreshRateInHz = swapchain_desc->refresh_rate; + present_parameters->FullScreen_PresentationInterval = swapchain_desc->swap_interval; +} + +static void wined3d_swapchain_desc_from_present_parameters(struct wined3d_swapchain_desc *swapchain_desc, + const D3DPRESENT_PARAMETERS *present_parameters) +{ + swapchain_desc->backbuffer_width = present_parameters->BackBufferWidth; + 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->multisample_type = present_parameters->MultiSampleType; + swapchain_desc->multisample_quality = 0; /* d3d9 only */ + swapchain_desc->swap_effect = 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; + swapchain_desc->auto_depth_stencil_format + = wined3dformat_from_d3dformat(present_parameters->AutoDepthStencilFormat); + swapchain_desc->flags = present_parameters->Flags; + swapchain_desc->refresh_rate = present_parameters->FullScreen_RefreshRateInHz; + swapchain_desc->swap_interval = present_parameters->FullScreen_PresentationInterval; + swapchain_desc->auto_restore_display_mode = TRUE; +} + +/* Handle table functions */ +static DWORD d3d8_allocate_handle(struct d3d8_handle_table *t, void *object, enum d3d8_handle_type type) +{ + struct d3d8_handle_entry *entry; + + if (t->free_entries) + { + DWORD index = t->free_entries - t->entries; + /* Use a free handle */ + entry = t->free_entries; + if (entry->type != D3D8_HANDLE_FREE) + { + ERR("Handle %u(%p) is in the free list, but has type %#x.\n", index, entry, entry->type); + return D3D8_INVALID_HANDLE; + } + t->free_entries = entry->object; + entry->object = object; + entry->type = type; + + return index; + } + + if (!(t->entry_count < t->table_size)) + { + /* 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) + { + ERR("Failed to grow the handle table.\n"); + return D3D8_INVALID_HANDLE; + } + t->entries = new_entries; + t->table_size = new_size; + } + + entry = &t->entries[t->entry_count]; + entry->object = object; + entry->type = type; + + return t->entry_count++; +} + +static void *d3d8_free_handle(struct d3d8_handle_table *t, DWORD handle, enum d3d8_handle_type type) +{ + struct d3d8_handle_entry *entry; + void *object; + + if (handle == D3D8_INVALID_HANDLE || handle >= t->entry_count) + { + WARN("Invalid handle %u passed.\n", handle); + return NULL; + } + + entry = &t->entries[handle]; + if (entry->type != type) + { + WARN("Handle %u(%p) is not of type %#x.\n", handle, entry, type); + return NULL; + } + + object = entry->object; + entry->object = t->free_entries; + entry->type = D3D8_HANDLE_FREE; + t->free_entries = entry; + + return object; +} + +static void *d3d8_get_object(struct d3d8_handle_table *t, DWORD handle, enum d3d8_handle_type type) +{ + struct d3d8_handle_entry *entry; + + if (handle == D3D8_INVALID_HANDLE || handle >= t->entry_count) + { + WARN("Invalid handle %u passed.\n", handle); + return NULL; + } + + entry = &t->entries[handle]; + if (entry->type != type) + { + WARN("Handle %u(%p) is not of type %#x.\n", handle, entry, type); + return NULL; + } + + return entry->object; +} + +static inline struct d3d8_device *impl_from_IDirect3DDevice8(IDirect3DDevice8 *iface) +{ + return CONTAINING_RECORD(iface, struct d3d8_device, IDirect3DDevice8_iface); +} + +static HRESULT WINAPI d3d8_device_QueryInterface(IDirect3DDevice8 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", + iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DDevice8) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DDevice8_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d8_device_AddRef(IDirect3DDevice8 *iface) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + ULONG ref = InterlockedIncrement(&device->ref); + + TRACE("%p increasing refcount to %u.\n", iface, ref); + + return ref; +} + +static ULONG WINAPI d3d8_device_Release(IDirect3DDevice8 *iface) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + ULONG ref; + + if (device->inDestruction) + return 0; + + ref = InterlockedDecrement(&device->ref); + + TRACE("%p decreasing refcount to %u.\n", iface, ref); + + if (!ref) + { + IDirect3D8 *parent = device->d3d_parent; + unsigned i; + + TRACE("Releasing wined3d device %p.\n", device->wined3d_device); + + wined3d_mutex_lock(); + + device->inDestruction = TRUE; + + for (i = 0; i < device->numConvertedDecls; ++i) + { + d3d8_vertex_declaration_destroy(device->decls[i].declaration); + } + HeapFree(GetProcessHeap(), 0, device->decls); + + if (device->vertex_buffer) + wined3d_buffer_decref(device->vertex_buffer); + if (device->index_buffer) + wined3d_buffer_decref(device->index_buffer); + + 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); + + wined3d_mutex_unlock(); + + IDirect3D8_Release(parent); + } + return ref; +} + +static HRESULT WINAPI d3d8_device_TestCooperativeLevel(IDirect3DDevice8 *iface) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p.\n", iface); + + if (device->lost) + { + TRACE("Device is lost.\n"); + return D3DERR_DEVICENOTRESET; + } + + return D3D_OK; +} + +static UINT WINAPI d3d8_device_GetAvailableTextureMem(IDirect3DDevice8 *iface) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + hr = wined3d_device_get_available_texture_mem(device->wined3d_device); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_ResourceManagerDiscardBytes(IDirect3DDevice8 *iface, DWORD byte_count) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, byte_count %u.\n", iface, byte_count); + + if (byte_count) + FIXME("Byte count ignored.\n"); + + wined3d_mutex_lock(); + wined3d_device_evict_managed_resources(device->wined3d_device); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_GetDirect3D(IDirect3DDevice8 *iface, IDirect3D8 **d3d8) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, d3d8 %p.\n", iface, d3d8); + + if (!d3d8) + return D3DERR_INVALIDCALL; + + return IDirect3D8_QueryInterface(device->d3d_parent, &IID_IDirect3D8, (void **)d3d8); +} + +static HRESULT WINAPI d3d8_device_GetDeviceCaps(IDirect3DDevice8 *iface, D3DCAPS8 *caps) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + WINED3DCAPS *wined3d_caps; + HRESULT hr; + + TRACE("iface %p, caps %p.\n", iface, caps); + + if (!caps) + return D3DERR_INVALIDCALL; + + if (!(wined3d_caps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wined3d_caps)))) + return D3DERR_INVALIDCALL; /* well this is what MSDN says to return */ + + wined3d_mutex_lock(); + hr = wined3d_device_get_device_caps(device->wined3d_device, wined3d_caps); + wined3d_mutex_unlock(); + + fixup_caps(wined3d_caps); + WINECAPSTOD3D8CAPS(caps, wined3d_caps) + HeapFree(GetProcessHeap(), 0, wined3d_caps); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetDisplayMode(IDirect3DDevice8 *iface, D3DDISPLAYMODE *mode) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct wined3d_display_mode wined3d_mode; + HRESULT hr; + + TRACE("iface %p, mode %p.\n", iface, mode); + + wined3d_mutex_lock(); + hr = wined3d_device_get_display_mode(device->wined3d_device, 0, &wined3d_mode, NULL); + wined3d_mutex_unlock(); + + if (SUCCEEDED(hr)) + { + mode->Width = wined3d_mode.width; + mode->Height = wined3d_mode.height; + mode->RefreshRate = wined3d_mode.refresh_rate; + mode->Format = d3dformat_from_wined3dformat(wined3d_mode.format_id); + } + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetCreationParameters(IDirect3DDevice8 *iface, + D3DDEVICE_CREATION_PARAMETERS *parameters) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, parameters %p.\n", iface, parameters); + + wined3d_mutex_lock(); + wined3d_device_get_creation_parameters(device->wined3d_device, + (struct wined3d_device_creation_parameters *)parameters); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_SetCursorProperties(IDirect3DDevice8 *iface, + UINT hotspot_x, UINT hotspot_y, IDirect3DSurface8 *bitmap) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_surface *bitmap_impl = unsafe_impl_from_IDirect3DSurface8(bitmap); + HRESULT hr; + + TRACE("iface %p, hotspot_x %u, hotspot_y %u, bitmap %p.\n", + iface, hotspot_x, hotspot_y, bitmap); + + if (!bitmap) + { + WARN("No cursor bitmap, returning D3DERR_INVALIDCALL.\n"); + return D3DERR_INVALIDCALL; + } + + wined3d_mutex_lock(); + hr = wined3d_device_set_cursor_properties(device->wined3d_device, + hotspot_x, hotspot_y, bitmap_impl->wined3d_surface); + wined3d_mutex_unlock(); + + return hr; +} + +static void WINAPI d3d8_device_SetCursorPosition(IDirect3DDevice8 *iface, UINT x, UINT y, DWORD flags) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, x %u, y %u, flags %#x.\n", iface, x, y, flags); + + wined3d_mutex_lock(); + wined3d_device_set_cursor_position(device->wined3d_device, x, y, flags); + wined3d_mutex_unlock(); +} + +static BOOL WINAPI d3d8_device_ShowCursor(IDirect3DDevice8 *iface, BOOL show) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + BOOL ret; + + TRACE("iface %p, show %#x.\n", iface, show); + + wined3d_mutex_lock(); + ret = wined3d_device_show_cursor(device->wined3d_device, show); + wined3d_mutex_unlock(); + + return ret; +} + +static HRESULT WINAPI d3d8_device_CreateAdditionalSwapChain(IDirect3DDevice8 *iface, + D3DPRESENT_PARAMETERS *present_parameters, IDirect3DSwapChain8 **swapchain) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct wined3d_swapchain_desc desc; + struct d3d8_swapchain *object; + + TRACE("iface %p, present_parameters %p, swapchain %p.\n", + iface, present_parameters, swapchain); + + wined3d_swapchain_desc_from_present_parameters(&desc, present_parameters); + if (SUCCEEDED(d3d8_swapchain_create(device, &desc, &object))) + *swapchain = &object->IDirect3DSwapChain8_iface; + present_parameters_from_wined3d_swapchain_desc(present_parameters, &desc); + + return D3D_OK; +} + +static HRESULT CDECL reset_enum_callback(struct wined3d_resource *resource) +{ + struct wined3d_resource_desc desc; + + wined3d_resource_get_desc(resource, &desc); + if (desc.pool == WINED3D_POOL_DEFAULT) + { + struct d3d8_surface *surface; + + if (desc.resource_type == WINED3D_RTYPE_TEXTURE) + { + IUnknown *parent = wined3d_resource_get_parent(resource); + IDirect3DBaseTexture8 *texture; + + if (SUCCEEDED(IUnknown_QueryInterface(parent, &IID_IDirect3DBaseTexture8, (void **)&texture))) + { + IDirect3DBaseTexture8_Release(texture); + WARN("Texture %p (resource %p) in pool D3DPOOL_DEFAULT blocks the Reset call.\n", texture, resource); + return D3DERR_DEVICELOST; + } + + return D3D_OK; + } + + if (desc.resource_type != WINED3D_RTYPE_SURFACE) + { + WARN("Resource %p in pool D3DPOOL_DEFAULT blocks the Reset call.\n", resource); + return D3DERR_DEVICELOST; + } + + surface = wined3d_resource_get_parent(resource); + if (surface->refcount) + { + WARN("Surface %p (resource %p) in pool D3DPOOL_DEFAULT blocks the Reset call.\n", surface, resource); + return D3DERR_DEVICELOST; + } + + WARN("Surface %p (resource %p) is an implicit resource with ref 0.\n", surface, resource); + } + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_Reset(IDirect3DDevice8 *iface, + D3DPRESENT_PARAMETERS *present_parameters) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct wined3d_swapchain_desc swapchain_desc; + HRESULT hr; + + TRACE("iface %p, present_parameters %p.\n", iface, present_parameters); + + wined3d_mutex_lock(); + + if (device->vertex_buffer) + { + wined3d_buffer_decref(device->vertex_buffer); + device->vertex_buffer = NULL; + device->vertex_buffer_size = 0; + } + if (device->index_buffer) + { + wined3d_buffer_decref(device->index_buffer); + device->index_buffer = NULL; + device->index_buffer_size = 0; + } + + wined3d_swapchain_desc_from_present_parameters(&swapchain_desc, present_parameters); + if (SUCCEEDED(hr = wined3d_device_reset(device->wined3d_device, &swapchain_desc, + NULL, reset_enum_callback, TRUE))) + { + wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_POINTSIZE_MIN, 0); + device->lost = FALSE; + } + else + { + device->lost = TRUE; + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_Present(IDirect3DDevice8 *iface, const RECT *src_rect, + const RECT *dst_rect, HWND dst_window_override, const RGNDATA *dirty_region) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, src_rect %s, dst_rect %s, dst_window_override %p, dirty_region %p.\n", + iface, wine_dbgstr_rect(src_rect), wine_dbgstr_rect(dst_rect), dst_window_override, dirty_region); + + wined3d_mutex_lock(); + hr = wined3d_device_present(device->wined3d_device, src_rect, dst_rect, + dst_window_override, dirty_region, 0); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetBackBuffer(IDirect3DDevice8 *iface, + UINT backbuffer_idx, D3DBACKBUFFER_TYPE backbuffer_type, IDirect3DSurface8 **backbuffer) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct wined3d_surface *wined3d_surface = NULL; + struct d3d8_surface *surface_impl; + HRESULT hr; + + TRACE("iface %p, backbuffer_idx %u, backbuffer_type %#x, backbuffer %p.\n", + iface, backbuffer_idx, backbuffer_type, backbuffer); + + wined3d_mutex_lock(); + hr = wined3d_device_get_back_buffer(device->wined3d_device, 0, backbuffer_idx, + (enum wined3d_backbuffer_type)backbuffer_type, &wined3d_surface); + if (SUCCEEDED(hr) && wined3d_surface && backbuffer) + { + surface_impl = wined3d_surface_get_parent(wined3d_surface); + *backbuffer = &surface_impl->IDirect3DSurface8_iface; + IDirect3DSurface8_AddRef(*backbuffer); + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetRasterStatus(IDirect3DDevice8 *iface, D3DRASTER_STATUS *raster_status) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, raster_status %p.\n", iface, raster_status); + + wined3d_mutex_lock(); + hr = wined3d_device_get_raster_status(device->wined3d_device, 0, (struct wined3d_raster_status *)raster_status); + wined3d_mutex_unlock(); + + return hr; +} + +static void WINAPI d3d8_device_SetGammaRamp(IDirect3DDevice8 *iface, DWORD flags, const D3DGAMMARAMP *ramp) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, flags %#x, ramp %p.\n", iface, flags, ramp); + + /* Note: D3DGAMMARAMP is compatible with struct wined3d_gamma_ramp. */ + wined3d_mutex_lock(); + wined3d_device_set_gamma_ramp(device->wined3d_device, 0, flags, (const struct wined3d_gamma_ramp *)ramp); + wined3d_mutex_unlock(); +} + +static void WINAPI d3d8_device_GetGammaRamp(IDirect3DDevice8 *iface, D3DGAMMARAMP *ramp) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, ramp %p.\n", iface, ramp); + + /* Note: D3DGAMMARAMP is compatible with struct wined3d_gamma_ramp. */ + wined3d_mutex_lock(); + wined3d_device_get_gamma_ramp(device->wined3d_device, 0, (struct wined3d_gamma_ramp *)ramp); + wined3d_mutex_unlock(); +} + +static HRESULT WINAPI d3d8_device_CreateTexture(IDirect3DDevice8 *iface, + UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, IDirect3DTexture8 **texture) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_texture *object; + HRESULT hr; + + TRACE("iface %p, width %u, height %u, levels %u, usage %#x, format %#x, pool %#x, texture %p.\n", + iface, width, height, levels, usage, format, pool, texture); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!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); + return hr; + } + + TRACE("Created texture %p.\n", object); + *texture = (IDirect3DTexture8 *)&object->IDirect3DBaseTexture8_iface; + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_CreateVolumeTexture(IDirect3DDevice8 *iface, + UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, IDirect3DVolumeTexture8 **texture) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_texture *object; + HRESULT hr; + + TRACE("iface %p, width %u, height %u, depth %u, levels %u, usage %#x, format %#x, pool %#x, texture %p.\n", + iface, width, height, depth, levels, usage, format, pool, texture); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!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); + return hr; + } + + TRACE("Created volume texture %p.\n", object); + *texture = (IDirect3DVolumeTexture8 *)&object->IDirect3DBaseTexture8_iface; + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_CreateCubeTexture(IDirect3DDevice8 *iface, UINT edge_length, + UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool, IDirect3DCubeTexture8 **texture) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_texture *object; + HRESULT hr; + + TRACE("iface %p, edge_length %u, levels %u, usage %#x, format %#x, pool %#x, texture %p.\n", + iface, edge_length, levels, usage, format, pool, texture); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!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); + return hr; + } + + TRACE("Created cube texture %p.\n", object); + *texture = (IDirect3DCubeTexture8 *)&object->IDirect3DBaseTexture8_iface; + + return hr; +} + +static HRESULT WINAPI d3d8_device_CreateVertexBuffer(IDirect3DDevice8 *iface, UINT size, + DWORD usage, DWORD fvf, D3DPOOL pool, IDirect3DVertexBuffer8 **buffer) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_vertexbuffer *object; + HRESULT hr; + + 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) + 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); + return hr; + } + + TRACE("Created vertex buffer %p.\n", object); + *buffer = &object->IDirect3DVertexBuffer8_iface; + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_CreateIndexBuffer(IDirect3DDevice8 *iface, UINT size, + DWORD usage, D3DFORMAT format, D3DPOOL pool, IDirect3DIndexBuffer8 **buffer) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_indexbuffer *object; + HRESULT hr; + + 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) + 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); + return hr; + } + + TRACE("Created index buffer %p.\n", object); + *buffer = &object->IDirect3DIndexBuffer8_iface; + + return D3D_OK; +} + +static HRESULT d3d8_device_create_surface(struct d3d8_device *device, UINT width, UINT height, + D3DFORMAT format, DWORD flags, IDirect3DSurface8 **surface, UINT usage, D3DPOOL pool, + D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality) +{ + struct d3d8_surface *object; + HRESULT hr; + + TRACE("device %p, width %u, height %u, format %#x, flags %#x, surface %p,\n" + "\tusage %#x, pool %#x, multisample_type %#x, multisample_quality %u.\n", + device, width, height, format, flags, surface, + usage, pool, multisample_type, multisample_quality); + + if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)))) + { + FIXME("Failed to allocate surface memory.\n"); + return D3DERR_OUTOFVIDEOMEMORY; + } + + if (FAILED(hr = surface_init(object, device, width, height, format, + flags, usage, pool, multisample_type, multisample_quality))) + { + WARN("Failed to initialize surface, hr %#x.\n", hr); + HeapFree(GetProcessHeap(), 0, object); + return hr; + } + + TRACE("Created surface %p.\n", object); + *surface = &object->IDirect3DSurface8_iface; + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_CreateRenderTarget(IDirect3DDevice8 *iface, UINT width, + UINT height, D3DFORMAT format, D3DMULTISAMPLE_TYPE multisample_type, BOOL lockable, + IDirect3DSurface8 **surface) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + DWORD flags = 0; + + TRACE("iface %p, width %u, height %u, format %#x, multisample_type %#x, lockable %#x, surface %p.\n", + iface, width, height, format, multisample_type, lockable, surface); + + if (lockable) + flags |= WINED3D_SURFACE_MAPPABLE; + + return d3d8_device_create_surface(device, width, height, format, flags, surface, + D3DUSAGE_RENDERTARGET, D3DPOOL_DEFAULT, multisample_type, 0); +} + +static HRESULT WINAPI d3d8_device_CreateDepthStencilSurface(IDirect3DDevice8 *iface, + UINT width, UINT height, D3DFORMAT format, D3DMULTISAMPLE_TYPE multisample_type, + IDirect3DSurface8 **surface) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, width %u, height %u, format %#x, multisample_type %#x, surface %p.\n", + iface, width, height, format, multisample_type, surface); + + /* TODO: Verify that Discard is false */ + return d3d8_device_create_surface(device, width, height, format, WINED3D_SURFACE_MAPPABLE, + surface, D3DUSAGE_DEPTHSTENCIL, D3DPOOL_DEFAULT, multisample_type, 0); +} + +/* IDirect3DDevice8Impl::CreateImageSurface returns surface with pool type SYSTEMMEM */ +static HRESULT WINAPI d3d8_device_CreateImageSurface(IDirect3DDevice8 *iface, UINT width, + UINT height, D3DFORMAT format, IDirect3DSurface8 **surface) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, width %u, height %u, format %#x, surface %p.\n", + iface, width, height, format, surface); + + return d3d8_device_create_surface(device, width, height, format, WINED3D_SURFACE_MAPPABLE, + surface, 0, D3DPOOL_SYSTEMMEM, D3DMULTISAMPLE_NONE, 0); +} + +static HRESULT WINAPI d3d8_device_CopyRects(IDirect3DDevice8 *iface, + IDirect3DSurface8 *src_surface, const RECT *src_rects, UINT rect_count, + IDirect3DSurface8 *dst_surface, const POINT *dst_points) +{ + struct d3d8_surface *src = unsafe_impl_from_IDirect3DSurface8(src_surface); + struct d3d8_surface *dst = unsafe_impl_from_IDirect3DSurface8(dst_surface); + enum wined3d_format_id src_format, dst_format; + struct wined3d_resource_desc wined3d_desc; + struct wined3d_resource *wined3d_resource; + UINT src_w, src_h; + HRESULT hr; + + TRACE("iface %p, src_surface %p, src_rects %p, rect_count %u, dst_surface %p, dst_points %p.\n", + iface, src_surface, src_rects, rect_count, dst_surface, dst_points); + + /* Check that the source texture is in WINED3D_POOL_SYSTEM_MEM and the + * destination texture is in WINED3D_POOL_DEFAULT. */ + + wined3d_mutex_lock(); + wined3d_resource = wined3d_surface_get_resource(src->wined3d_surface); + wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); + if (wined3d_desc.usage & WINED3DUSAGE_DEPTHSTENCIL) + { + WARN("Source %p is a depth stencil surface, returning D3DERR_INVALIDCALL.\n", src_surface); + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + src_format = wined3d_desc.format; + src_w = wined3d_desc.width; + src_h = wined3d_desc.height; + + wined3d_resource = wined3d_surface_get_resource(dst->wined3d_surface); + wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); + if (wined3d_desc.usage & WINED3DUSAGE_DEPTHSTENCIL) + { + WARN("Destination %p is a depth stencil surface, returning D3DERR_INVALIDCALL.\n", dst_surface); + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + dst_format = wined3d_desc.format; + + /* Check that the source and destination formats match */ + if (src_format != dst_format && WINED3DFMT_UNKNOWN != dst_format) + { + WARN("Source %p format must match the destination %p format, returning D3DERR_INVALIDCALL.\n", + src_surface, dst_surface); + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + else if (WINED3DFMT_UNKNOWN == dst_format) + { + TRACE("Converting destination surface from WINED3DFMT_UNKNOWN to the source format.\n"); + if (FAILED(hr = wined3d_surface_update_desc(dst->wined3d_surface, wined3d_desc.width, wined3d_desc.height, + src_format, wined3d_desc.multisample_type, wined3d_desc.multisample_quality))) + { + WARN("Failed to update surface desc, hr %#x.\n", hr); + wined3d_mutex_unlock(); + return hr; + } + } + + /* Quick if complete copy ... */ + if (!rect_count && !src_rects && !dst_points) + { + RECT rect = {0, 0, src_w, src_h}; + wined3d_surface_blt(dst->wined3d_surface, &rect, + src->wined3d_surface, &rect, 0, NULL, WINED3D_TEXF_POINT); + } + else + { + unsigned int i; + /* Copy rect by rect */ + if (src_rects && dst_points) + { + for (i = 0; i < rect_count; ++i) + { + UINT w = src_rects[i].right - src_rects[i].left; + UINT h = src_rects[i].bottom - src_rects[i].top; + RECT dst_rect = {dst_points[i].x, dst_points[i].y, + dst_points[i].x + w, dst_points[i].y + h}; + + wined3d_surface_blt(dst->wined3d_surface, &dst_rect, + src->wined3d_surface, &src_rects[i], 0, NULL, WINED3D_TEXF_POINT); + } + } + else + { + for (i = 0; i < rect_count; ++i) + { + UINT w = src_rects[i].right - src_rects[i].left; + UINT h = src_rects[i].bottom - src_rects[i].top; + RECT dst_rect = {0, 0, w, h}; + + wined3d_surface_blt(dst->wined3d_surface, &dst_rect, + src->wined3d_surface, &src_rects[i], 0, NULL, WINED3D_TEXF_POINT); + } + } + } + wined3d_mutex_unlock(); + + return WINED3D_OK; +} + +static HRESULT WINAPI d3d8_device_UpdateTexture(IDirect3DDevice8 *iface, + IDirect3DBaseTexture8 *src_texture, IDirect3DBaseTexture8 *dst_texture) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_texture *src_impl, *dst_impl; + HRESULT hr; + + TRACE("iface %p, src_texture %p, dst_texture %p.\n", iface, src_texture, dst_texture); + + src_impl = unsafe_impl_from_IDirect3DBaseTexture8(src_texture); + dst_impl = unsafe_impl_from_IDirect3DBaseTexture8(dst_texture); + + wined3d_mutex_lock(); + hr = wined3d_device_update_texture(device->wined3d_device, + src_impl->wined3d_texture, dst_impl->wined3d_texture); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetFrontBuffer(IDirect3DDevice8 *iface, IDirect3DSurface8 *dst_surface) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_surface *dst_impl = unsafe_impl_from_IDirect3DSurface8(dst_surface); + HRESULT hr; + + TRACE("iface %p, dst_surface %p.\n", iface, dst_surface); + + if (!dst_surface) + { + WARN("Invalid destination surface passed.\n"); + return D3DERR_INVALIDCALL; + } + + wined3d_mutex_lock(); + hr = wined3d_device_get_front_buffer_data(device->wined3d_device, 0, dst_impl->wined3d_surface); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_SetRenderTarget(IDirect3DDevice8 *iface, + IDirect3DSurface8 *render_target, IDirect3DSurface8 *depth_stencil) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_surface *rt_impl = unsafe_impl_from_IDirect3DSurface8(render_target); + struct d3d8_surface *ds_impl = unsafe_impl_from_IDirect3DSurface8(depth_stencil); + struct wined3d_surface *original_ds = NULL; + HRESULT hr = D3D_OK; + + TRACE("iface %p, render_target %p, depth_stencil %p.\n", iface, render_target, depth_stencil); + + wined3d_mutex_lock(); + + if (ds_impl) + { + struct wined3d_resource_desc ds_desc, rt_desc; + struct wined3d_resource *wined3d_resource; + struct wined3d_surface *original_rt = NULL; + + /* If no render target is passed in check the size against the current RT */ + if (!render_target) + { + if (!(original_rt = wined3d_device_get_render_target(device->wined3d_device, 0))) + { + wined3d_mutex_unlock(); + return D3DERR_NOTFOUND; + } + wined3d_resource = wined3d_surface_get_resource(original_rt); + } + else + wined3d_resource = wined3d_surface_get_resource(rt_impl->wined3d_surface); + wined3d_resource_get_desc(wined3d_resource, &rt_desc); + + wined3d_resource = wined3d_surface_get_resource(ds_impl->wined3d_surface); + wined3d_resource_get_desc(wined3d_resource, &ds_desc); + + if (ds_desc.width < rt_desc.width || ds_desc.height < rt_desc.height) + { + WARN("Depth stencil is smaller than the render target, returning D3DERR_INVALIDCALL\n"); + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + } + + original_ds = wined3d_device_get_depth_stencil(device->wined3d_device); + wined3d_device_set_depth_stencil(device->wined3d_device, ds_impl ? ds_impl->wined3d_surface : NULL); + if (render_target) + { + hr = wined3d_device_set_render_target(device->wined3d_device, 0, rt_impl->wined3d_surface, TRUE); + if (FAILED(hr)) + wined3d_device_set_depth_stencil(device->wined3d_device, original_ds); + } + + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetRenderTarget(IDirect3DDevice8 *iface, IDirect3DSurface8 **render_target) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct wined3d_surface *wined3d_surface; + struct d3d8_surface *surface_impl; + HRESULT hr; + + TRACE("iface %p, render_target %p.\n", iface, render_target); + + if (!render_target) + return D3DERR_INVALIDCALL; + + wined3d_mutex_lock(); + if ((wined3d_surface = wined3d_device_get_render_target(device->wined3d_device, 0))) + { + surface_impl = wined3d_surface_get_parent(wined3d_surface); + *render_target = &surface_impl->IDirect3DSurface8_iface; + IDirect3DSurface8_AddRef(*render_target); + hr = D3D_OK; + } + else + { + ERR("Failed to get wined3d render target.\n"); + *render_target = NULL; + hr = D3DERR_NOTFOUND; + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetDepthStencilSurface(IDirect3DDevice8 *iface, IDirect3DSurface8 **depth_stencil) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct wined3d_surface *wined3d_surface; + struct d3d8_surface *surface_impl; + HRESULT hr = D3D_OK; + + TRACE("iface %p, depth_stencil %p.\n", iface, depth_stencil); + + if (!depth_stencil) + return D3DERR_INVALIDCALL; + + wined3d_mutex_lock(); + if ((wined3d_surface = wined3d_device_get_depth_stencil(device->wined3d_device))) + { + surface_impl = wined3d_surface_get_parent(wined3d_surface); + *depth_stencil = &surface_impl->IDirect3DSurface8_iface; + IDirect3DSurface8_AddRef(*depth_stencil); + } + else + { + hr = WINED3DERR_NOTFOUND; + *depth_stencil = NULL; + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_BeginScene(IDirect3DDevice8 *iface) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + hr = wined3d_device_begin_scene(device->wined3d_device); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI DECLSPEC_HOTPATCH d3d8_device_EndScene(IDirect3DDevice8 *iface) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + hr = wined3d_device_end_scene(device->wined3d_device); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_Clear(IDirect3DDevice8 *iface, DWORD rect_count, + const D3DRECT *rects, DWORD flags, D3DCOLOR color, float z, DWORD stencil) +{ + const struct wined3d_color c = + { + ((color >> 16) & 0xff) / 255.0f, + ((color >> 8) & 0xff) / 255.0f, + (color & 0xff) / 255.0f, + ((color >> 24) & 0xff) / 255.0f, + }; + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, rect_count %u, rects %p, flags %#x, color 0x%08x, z %.8e, stencil %u.\n", + iface, rect_count, rects, flags, color, z, stencil); + + wined3d_mutex_lock(); + hr = wined3d_device_clear(device->wined3d_device, rect_count, (const RECT *)rects, flags, &c, z, stencil); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_SetTransform(IDirect3DDevice8 *iface, + D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix); + + /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */ + wined3d_mutex_lock(); + wined3d_device_set_transform(device->wined3d_device, state, (const struct wined3d_matrix *)matrix); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_GetTransform(IDirect3DDevice8 *iface, + D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix); + + /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */ + wined3d_mutex_lock(); + wined3d_device_get_transform(device->wined3d_device, state, (struct wined3d_matrix *)matrix); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_MultiplyTransform(IDirect3DDevice8 *iface, + D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix); + + /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */ + wined3d_mutex_lock(); + wined3d_device_multiply_transform(device->wined3d_device, state, (const struct wined3d_matrix *)matrix); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_SetViewport(IDirect3DDevice8 *iface, const D3DVIEWPORT8 *viewport) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, viewport %p.\n", iface, viewport); + + /* Note: D3DVIEWPORT8 is compatible with struct wined3d_viewport. */ + wined3d_mutex_lock(); + wined3d_device_set_viewport(device->wined3d_device, (const struct wined3d_viewport *)viewport); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_GetViewport(IDirect3DDevice8 *iface, D3DVIEWPORT8 *viewport) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, viewport %p.\n", iface, viewport); + + /* Note: D3DVIEWPORT8 is compatible with struct wined3d_viewport. */ + wined3d_mutex_lock(); + wined3d_device_get_viewport(device->wined3d_device, (struct wined3d_viewport *)viewport); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_SetMaterial(IDirect3DDevice8 *iface, const D3DMATERIAL8 *material) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, material %p.\n", iface, material); + + /* Note: D3DMATERIAL8 is compatible with struct wined3d_material. */ + wined3d_mutex_lock(); + wined3d_device_set_material(device->wined3d_device, (const struct wined3d_material *)material); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_GetMaterial(IDirect3DDevice8 *iface, D3DMATERIAL8 *material) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, material %p.\n", iface, material); + + /* Note: D3DMATERIAL8 is compatible with struct wined3d_material. */ + wined3d_mutex_lock(); + wined3d_device_get_material(device->wined3d_device, (struct wined3d_material *)material); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_SetLight(IDirect3DDevice8 *iface, DWORD index, const D3DLIGHT8 *light) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, index %u, light %p.\n", iface, index, light); + + /* Note: D3DLIGHT8 is compatible with struct wined3d_light. */ + wined3d_mutex_lock(); + hr = wined3d_device_set_light(device->wined3d_device, index, (const struct wined3d_light *)light); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetLight(IDirect3DDevice8 *iface, DWORD index, D3DLIGHT8 *light) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, index %u, light %p.\n", iface, index, light); + + /* Note: D3DLIGHT8 is compatible with struct wined3d_light. */ + wined3d_mutex_lock(); + hr = wined3d_device_get_light(device->wined3d_device, index, (struct wined3d_light *)light); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_LightEnable(IDirect3DDevice8 *iface, DWORD index, BOOL enable) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, index %u, enable %#x.\n", iface, index, enable); + + wined3d_mutex_lock(); + hr = wined3d_device_set_light_enable(device->wined3d_device, index, enable); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetLightEnable(IDirect3DDevice8 *iface, DWORD index, BOOL *enable) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, index %u, enable %p.\n", iface, index, enable); + + wined3d_mutex_lock(); + hr = wined3d_device_get_light_enable(device->wined3d_device, index, enable); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_SetClipPlane(IDirect3DDevice8 *iface, DWORD index, const float *plane) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, index %u, plane %p.\n", iface, index, plane); + + wined3d_mutex_lock(); + hr = wined3d_device_set_clip_plane(device->wined3d_device, index, (const struct wined3d_vec4 *)plane); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetClipPlane(IDirect3DDevice8 *iface, DWORD index, float *plane) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, index %u, plane %p.\n", iface, index, plane); + + wined3d_mutex_lock(); + hr = wined3d_device_get_clip_plane(device->wined3d_device, index, (struct wined3d_vec4 *)plane); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_SetRenderState(IDirect3DDevice8 *iface, + D3DRENDERSTATETYPE state, DWORD value) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, state %#x, value %#x.\n", iface, state, value); + + wined3d_mutex_lock(); + switch (state) + { + case D3DRS_ZBIAS: + wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_DEPTHBIAS, value); + break; + + default: + wined3d_device_set_render_state(device->wined3d_device, state, value); + } + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_GetRenderState(IDirect3DDevice8 *iface, + D3DRENDERSTATETYPE state, DWORD *value) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + + TRACE("iface %p, state %#x, value %p.\n", iface, state, value); + + wined3d_mutex_lock(); + switch (state) + { + case D3DRS_ZBIAS: + *value = wined3d_device_get_render_state(device->wined3d_device, WINED3D_RS_DEPTHBIAS); + break; + + default: + *value = wined3d_device_get_render_state(device->wined3d_device, state); + } + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_BeginStateBlock(IDirect3DDevice8 *iface) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + hr = wined3d_device_begin_stateblock(device->wined3d_device); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_EndStateBlock(IDirect3DDevice8 *iface, DWORD *token) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct wined3d_stateblock *stateblock; + HRESULT hr; + + TRACE("iface %p, token %p.\n", iface, token); + + /* Tell wineD3D to endstateblock before anything else (in case we run out + * of memory later and cause locking problems) + */ + wined3d_mutex_lock(); + hr = wined3d_device_end_stateblock(device->wined3d_device, &stateblock); + if (FAILED(hr)) + { + WARN("IWineD3DDevice_EndStateBlock returned an error\n"); + wined3d_mutex_unlock(); + return hr; + } + + *token = d3d8_allocate_handle(&device->handle_table, stateblock, D3D8_HANDLE_SB); + wined3d_mutex_unlock(); + + if (*token == D3D8_INVALID_HANDLE) + { + ERR("Failed to create a handle\n"); + wined3d_mutex_lock(); + wined3d_stateblock_decref(stateblock); + wined3d_mutex_unlock(); + return E_FAIL; + } + ++*token; + + TRACE("Returning %#x (%p).\n", *token, stateblock); + + return hr; +} + +static HRESULT WINAPI d3d8_device_ApplyStateBlock(IDirect3DDevice8 *iface, DWORD token) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct wined3d_stateblock *stateblock; + + TRACE("iface %p, token %#x.\n", iface, token); + + if (!token) + return D3D_OK; + + wined3d_mutex_lock(); + stateblock = d3d8_get_object(&device->handle_table, token - 1, D3D8_HANDLE_SB); + if (!stateblock) + { + WARN("Invalid handle (%#x) passed.\n", token); + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + wined3d_stateblock_apply(stateblock); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_CaptureStateBlock(IDirect3DDevice8 *iface, DWORD token) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct wined3d_stateblock *stateblock; + + TRACE("iface %p, token %#x.\n", iface, token); + + wined3d_mutex_lock(); + stateblock = d3d8_get_object(&device->handle_table, token - 1, D3D8_HANDLE_SB); + if (!stateblock) + { + WARN("Invalid handle (%#x) passed.\n", token); + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + wined3d_stateblock_capture(stateblock); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_DeleteStateBlock(IDirect3DDevice8 *iface, DWORD token) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct wined3d_stateblock *stateblock; + + TRACE("iface %p, token %#x.\n", iface, token); + + wined3d_mutex_lock(); + stateblock = d3d8_free_handle(&device->handle_table, token - 1, D3D8_HANDLE_SB); + + if (!stateblock) + { + WARN("Invalid handle (%#x) passed.\n", token); + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + + if (wined3d_stateblock_decref(stateblock)) + { + ERR("Stateblock %p has references left, this shouldn't happen.\n", stateblock); + } + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_CreateStateBlock(IDirect3DDevice8 *iface, + D3DSTATEBLOCKTYPE type, DWORD *handle) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct wined3d_stateblock *stateblock; + HRESULT hr; + + TRACE("iface %p, type %#x, handle %p.\n", iface, type, handle); + + if (type != D3DSBT_ALL + && type != D3DSBT_PIXELSTATE + && type != D3DSBT_VERTEXSTATE) + { + WARN("Unexpected stateblock type, returning D3DERR_INVALIDCALL\n"); + return D3DERR_INVALIDCALL; + } + + wined3d_mutex_lock(); + hr = wined3d_stateblock_create(device->wined3d_device, (enum wined3d_stateblock_type)type, &stateblock); + if (FAILED(hr)) + { + wined3d_mutex_unlock(); + ERR("IWineD3DDevice_CreateStateBlock failed, hr %#x\n", hr); + return hr; + } + + *handle = d3d8_allocate_handle(&device->handle_table, stateblock, D3D8_HANDLE_SB); + wined3d_mutex_unlock(); + + if (*handle == D3D8_INVALID_HANDLE) + { + ERR("Failed to allocate a handle.\n"); + wined3d_mutex_lock(); + wined3d_stateblock_decref(stateblock); + wined3d_mutex_unlock(); + return E_FAIL; + } + ++*handle; + + TRACE("Returning %#x (%p).\n", *handle, stateblock); + + return hr; +} + +static HRESULT WINAPI d3d8_device_SetClipStatus(IDirect3DDevice8 *iface, const D3DCLIPSTATUS8 *clip_status) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, clip_status %p.\n", iface, clip_status); + /* FIXME: Verify that D3DCLIPSTATUS8 ~= struct wined3d_clip_status. */ + + wined3d_mutex_lock(); + hr = wined3d_device_set_clip_status(device->wined3d_device, (const struct wined3d_clip_status *)clip_status); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetClipStatus(IDirect3DDevice8 *iface, D3DCLIPSTATUS8 *clip_status) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, clip_status %p.\n", iface, clip_status); + + wined3d_mutex_lock(); + hr = wined3d_device_get_clip_status(device->wined3d_device, (struct wined3d_clip_status *)clip_status); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetTexture(IDirect3DDevice8 *iface, DWORD stage, IDirect3DBaseTexture8 **texture) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct wined3d_texture *wined3d_texture; + struct d3d8_texture *texture_impl; + + TRACE("iface %p, stage %u, texture %p.\n", iface, stage, texture); + + if (!texture) + return D3DERR_INVALIDCALL; + + wined3d_mutex_lock(); + if ((wined3d_texture = wined3d_device_get_texture(device->wined3d_device, stage))) + { + texture_impl = wined3d_texture_get_parent(wined3d_texture); + *texture = &texture_impl->IDirect3DBaseTexture8_iface; + IDirect3DBaseTexture8_AddRef(*texture); + } + else + { + *texture = NULL; + } + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_SetTexture(IDirect3DDevice8 *iface, DWORD stage, IDirect3DBaseTexture8 *texture) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_texture *texture_impl; + HRESULT hr; + + TRACE("iface %p, stage %u, texture %p.\n", iface, stage, texture); + + texture_impl = unsafe_impl_from_IDirect3DBaseTexture8(texture); + + wined3d_mutex_lock(); + hr = wined3d_device_set_texture(device->wined3d_device, stage, + texture_impl ? texture_impl->wined3d_texture : NULL); + wined3d_mutex_unlock(); + + return hr; +} + +static const struct tss_lookup +{ + BOOL sampler_state; + enum wined3d_texture_stage_state state; +} +tss_lookup[] = +{ + {FALSE, WINED3D_TSS_INVALID}, /* 0, unused */ + {FALSE, WINED3D_TSS_COLOR_OP}, /* 1, D3DTSS_COLOROP */ + {FALSE, WINED3D_TSS_COLOR_ARG1}, /* 2, D3DTSS_COLORARG1 */ + {FALSE, WINED3D_TSS_COLOR_ARG2}, /* 3, D3DTSS_COLORARG2 */ + {FALSE, WINED3D_TSS_ALPHA_OP}, /* 4, D3DTSS_ALPHAOP */ + {FALSE, WINED3D_TSS_ALPHA_ARG1}, /* 5, D3DTSS_ALPHAARG1 */ + {FALSE, WINED3D_TSS_ALPHA_ARG2}, /* 6, D3DTSS_ALPHAARG2 */ + {FALSE, WINED3D_TSS_BUMPENV_MAT00}, /* 7, D3DTSS_BUMPENVMAT00 */ + {FALSE, WINED3D_TSS_BUMPENV_MAT01}, /* 8, D3DTSS_BUMPENVMAT01 */ + {FALSE, WINED3D_TSS_BUMPENV_MAT10}, /* 9, D3DTSS_BUMPENVMAT10 */ + {FALSE, WINED3D_TSS_BUMPENV_MAT11}, /* 10, D3DTSS_BUMPENVMAT11 */ + {FALSE, WINED3D_TSS_TEXCOORD_INDEX}, /* 11, D3DTSS_TEXCOORDINDEX */ + {FALSE, WINED3D_TSS_INVALID}, /* 12, unused */ + {TRUE, WINED3D_SAMP_ADDRESS_U}, /* 13, D3DTSS_ADDRESSU */ + {TRUE, WINED3D_SAMP_ADDRESS_V}, /* 14, D3DTSS_ADDRESSV */ + {TRUE, WINED3D_SAMP_BORDER_COLOR}, /* 15, D3DTSS_BORDERCOLOR */ + {TRUE, WINED3D_SAMP_MAG_FILTER}, /* 16, D3DTSS_MAGFILTER */ + {TRUE, WINED3D_SAMP_MIN_FILTER}, /* 17, D3DTSS_MINFILTER */ + {TRUE, WINED3D_SAMP_MIP_FILTER}, /* 18, D3DTSS_MIPFILTER */ + {TRUE, WINED3D_SAMP_MIPMAP_LOD_BIAS}, /* 19, D3DTSS_MIPMAPLODBIAS */ + {TRUE, WINED3D_SAMP_MAX_MIP_LEVEL}, /* 20, D3DTSS_MAXMIPLEVEL */ + {TRUE, WINED3D_SAMP_MAX_ANISOTROPY}, /* 21, D3DTSS_MAXANISOTROPY */ + {FALSE, WINED3D_TSS_BUMPENV_LSCALE}, /* 22, D3DTSS_BUMPENVLSCALE */ + {FALSE, WINED3D_TSS_BUMPENV_LOFFSET}, /* 23, D3DTSS_BUMPENVLOFFSET */ + {FALSE, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS}, /* 24, D3DTSS_TEXTURETRANSFORMFLAGS */ + {TRUE, WINED3D_SAMP_ADDRESS_W}, /* 25, D3DTSS_ADDRESSW */ + {FALSE, WINED3D_TSS_COLOR_ARG0}, /* 26, D3DTSS_COLORARG0 */ + {FALSE, WINED3D_TSS_ALPHA_ARG0}, /* 27, D3DTSS_ALPHAARG0 */ + {FALSE, WINED3D_TSS_RESULT_ARG}, /* 28, D3DTSS_RESULTARG */ +}; + +static HRESULT WINAPI d3d8_device_GetTextureStageState(IDirect3DDevice8 *iface, + DWORD stage, D3DTEXTURESTAGESTATETYPE Type, DWORD *value) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + const struct tss_lookup *l; + + TRACE("iface %p, stage %u, state %#x, value %p.\n", iface, stage, Type, value); + + if (Type >= sizeof(tss_lookup) / sizeof(*tss_lookup)) + { + WARN("Invalid Type %#x passed.\n", Type); + return D3D_OK; + } + + l = &tss_lookup[Type]; + + wined3d_mutex_lock(); + if (l->sampler_state) + *value = wined3d_device_get_sampler_state(device->wined3d_device, stage, l->state); + else + *value = wined3d_device_get_texture_stage_state(device->wined3d_device, stage, l->state); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_SetTextureStageState(IDirect3DDevice8 *iface, + DWORD stage, D3DTEXTURESTAGESTATETYPE type, DWORD value) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + const struct tss_lookup *l; + + TRACE("iface %p, stage %u, state %#x, value %#x.\n", iface, stage, type, value); + + if (type >= sizeof(tss_lookup) / sizeof(*tss_lookup)) + { + WARN("Invalid type %#x passed.\n", type); + return D3D_OK; + } + + l = &tss_lookup[type]; + + wined3d_mutex_lock(); + if (l->sampler_state) + wined3d_device_set_sampler_state(device->wined3d_device, stage, l->state, value); + else + wined3d_device_set_texture_stage_state(device->wined3d_device, stage, l->state, value); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_ValidateDevice(IDirect3DDevice8 *iface, DWORD *pass_count) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, pass_count %p.\n", iface, pass_count); + + wined3d_mutex_lock(); + hr = wined3d_device_validate_device(device->wined3d_device, pass_count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetInfo(IDirect3DDevice8 *iface, + DWORD info_id, void *info, DWORD info_size) +{ + FIXME("iface %p, info_id %#x, info %p, info_size %u stub!\n", iface, info_id, info, info_size); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_SetPaletteEntries(IDirect3DDevice8 *iface, + UINT palette_idx, const PALETTEENTRY *entries) +{ + WARN("iface %p, palette_idx %u, entries %p unimplemented\n", iface, palette_idx, entries); + + /* GPUs stopped supporting palettized textures with the Shader Model 1 generation. Wined3d + * does not have a d3d8/9-style palette API */ + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_GetPaletteEntries(IDirect3DDevice8 *iface, + UINT palette_idx, PALETTEENTRY *entries) +{ + FIXME("iface %p, palette_idx %u, entries %p unimplemented.\n", iface, palette_idx, entries); + + return D3DERR_INVALIDCALL; +} + +static HRESULT WINAPI d3d8_device_SetCurrentTexturePalette(IDirect3DDevice8 *iface, UINT palette_idx) +{ + WARN("iface %p, palette_idx %u unimplemented.\n", iface, palette_idx); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_GetCurrentTexturePalette(IDirect3DDevice8 *iface, UINT *palette_idx) +{ + FIXME("iface %p, palette_idx %p unimplemented.\n", iface, palette_idx); + + return D3DERR_INVALIDCALL; +} + +static HRESULT WINAPI d3d8_device_DrawPrimitive(IDirect3DDevice8 *iface, + D3DPRIMITIVETYPE primitive_type, UINT start_vertex, UINT primitive_count) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, primitive_type %#x, start_vertex %u, primitive_count %u.\n", + iface, primitive_type, start_vertex, primitive_count); + + wined3d_mutex_lock(); + wined3d_device_set_primitive_type(device->wined3d_device, primitive_type); + hr = wined3d_device_draw_primitive(device->wined3d_device, start_vertex, + vertex_count_from_primitive_count(primitive_type, primitive_count)); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_DrawIndexedPrimitive(IDirect3DDevice8 *iface, + D3DPRIMITIVETYPE primitive_type, UINT min_vertex_idx, UINT vertex_count, + UINT start_idx, UINT primitive_count) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, primitive_type %#x, min_vertex_idx %u, vertex_count %u, start_idx %u, primitive_count %u.\n", + iface, primitive_type, min_vertex_idx, vertex_count, start_idx, primitive_count); + + wined3d_mutex_lock(); + wined3d_device_set_primitive_type(device->wined3d_device, primitive_type); + hr = wined3d_device_draw_indexed_primitive(device->wined3d_device, start_idx, + vertex_count_from_primitive_count(primitive_type, primitive_count)); + wined3d_mutex_unlock(); + + return hr; +} + +static void STDMETHODCALLTYPE d3d8_null_wined3d_object_destroyed(void *parent) {} + +static const struct wined3d_parent_ops d3d8_null_wined3d_parent_ops = +{ + d3d8_null_wined3d_object_destroyed, +}; + +/* The caller is responsible for wined3d locking */ +static HRESULT d3d8_device_prepare_vertex_buffer(struct d3d8_device *device, UINT min_size) +{ + HRESULT hr; + + if (device->vertex_buffer_size < min_size || !device->vertex_buffer) + { + UINT size = max(device->vertex_buffer_size * 2, min_size); + 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)) + { + ERR("(%p) wined3d_buffer_create_vb failed with hr = %08x\n", device, hr); + return hr; + } + + if (device->vertex_buffer) + wined3d_buffer_decref(device->vertex_buffer); + + device->vertex_buffer = buffer; + device->vertex_buffer_size = size; + device->vertex_buffer_pos = 0; + } + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_DrawPrimitiveUP(IDirect3DDevice8 *iface, + D3DPRIMITIVETYPE primitive_type, UINT primitive_count, const void *data, + UINT stride) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + UINT vtx_count = vertex_count_from_primitive_count(primitive_type, primitive_count); + UINT size = vtx_count * stride; + UINT vb_pos, align; + BYTE *buffer_data; + + TRACE("iface %p, primitive_type %#x, primitive_count %u, data %p, stride %u.\n", + iface, primitive_type, primitive_count, data, stride); + + if (!primitive_count) + { + WARN("primitive_count is 0, returning D3D_OK\n"); + return D3D_OK; + } + + wined3d_mutex_lock(); + hr = d3d8_device_prepare_vertex_buffer(device, size); + if (FAILED(hr)) + goto done; + + vb_pos = device->vertex_buffer_pos; + align = vb_pos % stride; + if (align) align = stride - align; + if (vb_pos + size + align > device->vertex_buffer_size) + vb_pos = 0; + else + vb_pos += align; + + hr = wined3d_buffer_map(device->vertex_buffer, vb_pos, size, &buffer_data, + vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD); + if (FAILED(hr)) + goto done; + memcpy(buffer_data, data, size); + wined3d_buffer_unmap(device->vertex_buffer); + device->vertex_buffer_pos = vb_pos + size; + + hr = wined3d_device_set_stream_source(device->wined3d_device, 0, device->vertex_buffer, 0, stride); + if (FAILED(hr)) + goto done; + + wined3d_device_set_primitive_type(device->wined3d_device, primitive_type); + 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); + +done: + wined3d_mutex_unlock(); + return hr; +} + +/* The caller is responsible for wined3d locking */ +static HRESULT d3d8_device_prepare_index_buffer(struct d3d8_device *device, UINT min_size) +{ + HRESULT hr; + + if (device->index_buffer_size < min_size || !device->index_buffer) + { + UINT size = max(device->index_buffer_size * 2, min_size); + 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)) + { + ERR("(%p) wined3d_buffer_create_ib failed with hr = %08x\n", device, hr); + return hr; + } + + if (device->index_buffer) + wined3d_buffer_decref(device->index_buffer); + + device->index_buffer = buffer; + device->index_buffer_size = size; + device->index_buffer_pos = 0; + } + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_DrawIndexedPrimitiveUP(IDirect3DDevice8 *iface, + D3DPRIMITIVETYPE primitive_type, UINT min_vertex_idx, UINT vertex_count, + UINT primitive_count, const void *index_data, D3DFORMAT index_format, + const void *vertex_data, UINT vertex_stride) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + BYTE *buffer_data; + + UINT idx_count = vertex_count_from_primitive_count(primitive_type, primitive_count); + UINT idx_fmt_size = index_format == D3DFMT_INDEX16 ? 2 : 4; + UINT idx_size = idx_count * idx_fmt_size; + UINT ib_pos; + + UINT vtx_size = vertex_count * vertex_stride; + UINT vb_pos, align; + + TRACE("iface %p, primitive_type %#x, min_vertex_idx %u, vertex_count %u, primitive_count %u,\n" + "index_data %p, index_format %#x, vertex_data %p, vertex_stride %u.\n", + iface, primitive_type, min_vertex_idx, vertex_count, primitive_count, + index_data, index_format, vertex_data, vertex_stride); + + if (!primitive_count) + { + WARN("primitive_count is 0, returning D3D_OK\n"); + return D3D_OK; + } + + wined3d_mutex_lock(); + + hr = d3d8_device_prepare_vertex_buffer(device, vtx_size); + if (FAILED(hr)) + goto done; + + vb_pos = device->vertex_buffer_pos; + align = vb_pos % vertex_stride; + if (align) align = vertex_stride - align; + if (vb_pos + vtx_size + align > device->vertex_buffer_size) + vb_pos = 0; + else + vb_pos += align; + + hr = wined3d_buffer_map(device->vertex_buffer, vb_pos, vtx_size, &buffer_data, + vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD); + if (FAILED(hr)) + goto done; + memcpy(buffer_data, vertex_data, vtx_size); + wined3d_buffer_unmap(device->vertex_buffer); + device->vertex_buffer_pos = vb_pos + vtx_size; + + hr = d3d8_device_prepare_index_buffer(device, idx_size); + if (FAILED(hr)) + goto done; + + ib_pos = device->index_buffer_pos; + align = ib_pos % idx_fmt_size; + if (align) align = idx_fmt_size - align; + if (ib_pos + idx_size + align > device->index_buffer_size) + ib_pos = 0; + else + ib_pos += align; + + hr = wined3d_buffer_map(device->index_buffer, ib_pos, idx_size, &buffer_data, + ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD); + if (FAILED(hr)) + goto done; + memcpy(buffer_data, index_data, idx_size); + wined3d_buffer_unmap(device->index_buffer); + device->index_buffer_pos = ib_pos + idx_size; + + hr = wined3d_device_set_stream_source(device->wined3d_device, 0, device->vertex_buffer, 0, vertex_stride); + if (FAILED(hr)) + goto done; + + wined3d_device_set_index_buffer(device->wined3d_device, device->index_buffer, + wined3dformat_from_d3dformat(index_format)); + wined3d_device_set_base_vertex_index(device->wined3d_device, vb_pos / vertex_stride); + + wined3d_device_set_primitive_type(device->wined3d_device, primitive_type); + hr = wined3d_device_draw_indexed_primitive(device->wined3d_device, ib_pos / idx_fmt_size, idx_count); + + wined3d_device_set_stream_source(device->wined3d_device, 0, NULL, 0, 0); + wined3d_device_set_index_buffer(device->wined3d_device, NULL, WINED3DFMT_UNKNOWN); + wined3d_device_set_base_vertex_index(device->wined3d_device, 0); + +done: + wined3d_mutex_unlock(); + return hr; +} + +static HRESULT WINAPI d3d8_device_ProcessVertices(IDirect3DDevice8 *iface, UINT src_start_idx, + UINT dst_idx, UINT vertex_count, IDirect3DVertexBuffer8 *dst_buffer, DWORD flags) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_vertexbuffer *dst = unsafe_impl_from_IDirect3DVertexBuffer8(dst_buffer); + HRESULT hr; + + TRACE("iface %p, src_start_idx %u, dst_idx %u, vertex_count %u, dst_buffer %p, flags %#x.\n", + iface, src_start_idx, dst_idx, vertex_count, dst_buffer, flags); + + wined3d_mutex_lock(); + hr = wined3d_device_process_vertices(device->wined3d_device, src_start_idx, dst_idx, + vertex_count, dst->wined3d_buffer, NULL, flags, dst->fvf); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_CreateVertexShader(IDirect3DDevice8 *iface, + const DWORD *declaration, const DWORD *byte_code, DWORD *shader, DWORD usage) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_vertex_shader *object; + DWORD shader_handle; + DWORD handle; + HRESULT hr; + + 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) + { + *shader = 0; + return E_OUTOFMEMORY; + } + + wined3d_mutex_lock(); + handle = d3d8_allocate_handle(&device->handle_table, object, D3D8_HANDLE_VS); + wined3d_mutex_unlock(); + if (handle == D3D8_INVALID_HANDLE) + { + ERR("Failed to allocate vertex shader handle.\n"); + HeapFree(GetProcessHeap(), 0, object); + *shader = 0; + return E_OUTOFMEMORY; + } + + shader_handle = handle + VS_HIGHESTFIXEDFXF + 1; + + hr = d3d8_vertex_shader_init(object, device, declaration, byte_code, shader_handle, usage); + if (FAILED(hr)) + { + WARN("Failed to initialize vertex shader, hr %#x.\n", hr); + wined3d_mutex_lock(); + d3d8_free_handle(&device->handle_table, handle, D3D8_HANDLE_VS); + wined3d_mutex_unlock(); + HeapFree(GetProcessHeap(), 0, object); + *shader = 0; + return hr; + } + + TRACE("Created vertex shader %p (handle %#x).\n", object, shader_handle); + *shader = shader_handle; + + return D3D_OK; +} + +static struct d3d8_vertex_declaration *d3d8_device_get_fvf_declaration(struct d3d8_device *device, DWORD fvf) +{ + struct d3d8_vertex_declaration *d3d8_declaration; + struct FvfToDecl *convertedDecls = device->decls; + int p, low, high; /* deliberately signed */ + HRESULT hr; + + TRACE("Searching for declaration for fvf %08x... ", fvf); + + low = 0; + high = device->numConvertedDecls - 1; + while (low <= high) + { + p = (low + high) >> 1; + TRACE("%d ", p); + + if (convertedDecls[p].fvf == fvf) + { + TRACE("found %p\n", convertedDecls[p].declaration); + return convertedDecls[p].declaration; + } + + if (convertedDecls[p].fvf < fvf) + low = p + 1; + else + high = p - 1; + } + TRACE("not found. Creating and inserting at position %d.\n", low); + + if (!(d3d8_declaration = HeapAlloc(GetProcessHeap(), 0, 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); + return NULL; + } + + if (device->declArraySize == device->numConvertedDecls) + { + UINT grow = device->declArraySize / 2; + + convertedDecls = HeapReAlloc(GetProcessHeap(), 0, convertedDecls, + sizeof(*convertedDecls) * (device->numConvertedDecls + grow)); + if (!convertedDecls) + { + d3d8_vertex_declaration_destroy(d3d8_declaration); + return NULL; + } + device->decls = convertedDecls; + device->declArraySize += grow; + } + + memmove(convertedDecls + low + 1, convertedDecls + low, + sizeof(*convertedDecls) * (device->numConvertedDecls - low)); + convertedDecls[low].declaration = d3d8_declaration; + convertedDecls[low].fvf = fvf; + ++device->numConvertedDecls; + + TRACE("Returning %p. %u decls in array.\n", d3d8_declaration, device->numConvertedDecls); + + return d3d8_declaration; +} + +static HRESULT WINAPI d3d8_device_SetVertexShader(IDirect3DDevice8 *iface, DWORD shader) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_vertex_shader *shader_impl; + + TRACE("iface %p, shader %#x.\n", iface, shader); + + if (VS_HIGHESTFIXEDFXF >= shader) + { + TRACE("Setting FVF, %#x\n", shader); + + wined3d_mutex_lock(); + wined3d_device_set_vertex_declaration(device->wined3d_device, + d3d8_device_get_fvf_declaration(device, shader)->wined3d_vertex_declaration); + wined3d_device_set_vertex_shader(device->wined3d_device, NULL); + wined3d_mutex_unlock(); + + return D3D_OK; + } + + TRACE("Setting shader\n"); + + wined3d_mutex_lock(); + if (!(shader_impl = d3d8_get_object(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS))) + { + WARN("Invalid handle (%#x) passed.\n", shader); + wined3d_mutex_unlock(); + + return D3DERR_INVALIDCALL; + } + + wined3d_device_set_vertex_declaration(device->wined3d_device, + shader_impl->vertex_declaration->wined3d_vertex_declaration); + wined3d_device_set_vertex_shader(device->wined3d_device, shader_impl->wined3d_shader); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_GetVertexShader(IDirect3DDevice8 *iface, DWORD *shader) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct wined3d_vertex_declaration *wined3d_declaration; + struct d3d8_vertex_declaration *d3d8_declaration; + + TRACE("iface %p, shader %p.\n", iface, shader); + + wined3d_mutex_lock(); + if ((wined3d_declaration = wined3d_device_get_vertex_declaration(device->wined3d_device))) + { + d3d8_declaration = wined3d_vertex_declaration_get_parent(wined3d_declaration); + *shader = d3d8_declaration->shader_handle; + } + else + { + *shader = 0; + } + wined3d_mutex_unlock(); + + TRACE("Returning %#x.\n", *shader); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_DeleteVertexShader(IDirect3DDevice8 *iface, DWORD shader) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_vertex_shader *shader_impl; + + TRACE("iface %p, shader %#x.\n", iface, shader); + + wined3d_mutex_lock(); + if (!(shader_impl = d3d8_free_handle(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS))) + { + WARN("Invalid handle (%#x) passed.\n", shader); + wined3d_mutex_unlock(); + + return D3DERR_INVALIDCALL; + } + + if (shader_impl->wined3d_shader + && wined3d_device_get_vertex_shader(device->wined3d_device) == shader_impl->wined3d_shader) + IDirect3DDevice8_SetVertexShader(iface, 0); + + wined3d_mutex_unlock(); + + d3d8_vertex_shader_destroy(shader_impl); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_SetVertexShaderConstant(IDirect3DDevice8 *iface, + DWORD start_register, const void *data, DWORD count) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, start_register %u, data %p, count %u.\n", + iface, start_register, data, count); + + if (start_register + count > D3D8_MAX_VERTEX_SHADER_CONSTANTF) + { + WARN("Trying to access %u constants, but d3d8 only supports %u\n", + start_register + count, D3D8_MAX_VERTEX_SHADER_CONSTANTF); + return D3DERR_INVALIDCALL; + } + + wined3d_mutex_lock(); + hr = wined3d_device_set_vs_consts_f(device->wined3d_device, start_register, data, count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetVertexShaderConstant(IDirect3DDevice8 *iface, + DWORD start_register, void *data, DWORD count) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, start_register %u, data %p, count %u.\n", + iface, start_register, data, count); + + if (start_register + count > D3D8_MAX_VERTEX_SHADER_CONSTANTF) + { + WARN("Trying to access %u constants, but d3d8 only supports %u\n", + start_register + count, D3D8_MAX_VERTEX_SHADER_CONSTANTF); + return D3DERR_INVALIDCALL; + } + + wined3d_mutex_lock(); + hr = wined3d_device_get_vs_consts_f(device->wined3d_device, start_register, data, count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetVertexShaderDeclaration(IDirect3DDevice8 *iface, + DWORD shader, void *data, DWORD *data_size) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_vertex_declaration *declaration; + struct d3d8_vertex_shader *shader_impl; + + TRACE("iface %p, shader %#x, data %p, data_size %p.\n", + iface, shader, data, data_size); + + wined3d_mutex_lock(); + shader_impl = d3d8_get_object(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS); + wined3d_mutex_unlock(); + + if (!shader_impl) + { + WARN("Invalid handle (%#x) passed.\n", shader); + return D3DERR_INVALIDCALL; + } + declaration = shader_impl->vertex_declaration; + + if (!data) + { + *data_size = declaration->elements_size; + return D3D_OK; + } + + /* MSDN claims that if *data_size is smaller than the required size + * we should write the required size and return D3DERR_MOREDATA. + * That's not actually true. */ + if (*data_size < declaration->elements_size) + return D3DERR_INVALIDCALL; + + memcpy(data, declaration->elements, declaration->elements_size); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_GetVertexShaderFunction(IDirect3DDevice8 *iface, + DWORD shader, void *data, DWORD *data_size) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_vertex_shader *shader_impl = NULL; + HRESULT hr; + + TRACE("iface %p, shader %#x, data %p, data_size %p.\n", + iface, shader, data, data_size); + + wined3d_mutex_lock(); + if (!(shader_impl = d3d8_get_object(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS))) + { + WARN("Invalid handle (%#x) passed.\n", shader); + wined3d_mutex_unlock(); + + return D3DERR_INVALIDCALL; + } + + if (!shader_impl->wined3d_shader) + { + wined3d_mutex_unlock(); + *data_size = 0; + return D3D_OK; + } + + hr = wined3d_shader_get_byte_code(shader_impl->wined3d_shader, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_SetIndices(IDirect3DDevice8 *iface, + IDirect3DIndexBuffer8 *buffer, UINT base_vertex_idx) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_indexbuffer *ib = unsafe_impl_from_IDirect3DIndexBuffer8(buffer); + + TRACE("iface %p, buffer %p, base_vertex_idx %u.\n", iface, buffer, base_vertex_idx); + + /* WineD3D takes an INT(due to d3d9), but d3d8 uses UINTs. Do I have to add a check here that + * the UINT doesn't cause an overflow in the INT? It seems rather unlikely because such large + * vertex buffers can't be created to address them with an index that requires the 32nd bit + * (4 Byte minimum vertex size * 2^31-1 -> 8 gb buffer. The index sign would be the least + * problem) + */ + wined3d_mutex_lock(); + wined3d_device_set_base_vertex_index(device->wined3d_device, base_vertex_idx); + wined3d_device_set_index_buffer(device->wined3d_device, + ib ? ib->wined3d_buffer : NULL, + ib ? ib->format : WINED3DFMT_UNKNOWN); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_GetIndices(IDirect3DDevice8 *iface, + IDirect3DIndexBuffer8 **buffer, UINT *base_vertex_index) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + enum wined3d_format_id wined3d_format; + struct wined3d_buffer *wined3d_buffer; + struct d3d8_indexbuffer *buffer_impl; + + TRACE("iface %p, buffer %p, base_vertex_index %p.\n", iface, buffer, base_vertex_index); + + if (!buffer) + return D3DERR_INVALIDCALL; + + /* The case from UINT to INT is safe because d3d8 will never set negative values */ + wined3d_mutex_lock(); + *base_vertex_index = wined3d_device_get_base_vertex_index(device->wined3d_device); + if ((wined3d_buffer = wined3d_device_get_index_buffer(device->wined3d_device, &wined3d_format))) + { + buffer_impl = wined3d_buffer_get_parent(wined3d_buffer); + *buffer = &buffer_impl->IDirect3DIndexBuffer8_iface; + IDirect3DIndexBuffer8_AddRef(*buffer); + } + else + { + *buffer = NULL; + } + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_CreatePixelShader(IDirect3DDevice8 *iface, + const DWORD *byte_code, DWORD *shader) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_pixel_shader *object; + DWORD shader_handle; + DWORD handle; + HRESULT hr; + + TRACE("iface %p, byte_code %p, shader %p.\n", iface, byte_code, shader); + + if (!shader) + return D3DERR_INVALIDCALL; + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!object) + return E_OUTOFMEMORY; + + wined3d_mutex_lock(); + handle = d3d8_allocate_handle(&device->handle_table, object, D3D8_HANDLE_PS); + wined3d_mutex_unlock(); + if (handle == D3D8_INVALID_HANDLE) + { + ERR("Failed to allocate pixel shader handle.\n"); + HeapFree(GetProcessHeap(), 0, object); + return E_OUTOFMEMORY; + } + + shader_handle = handle + VS_HIGHESTFIXEDFXF + 1; + + hr = d3d8_pixel_shader_init(object, device, byte_code, shader_handle); + if (FAILED(hr)) + { + WARN("Failed to initialize pixel shader, hr %#x.\n", hr); + wined3d_mutex_lock(); + d3d8_free_handle(&device->handle_table, handle, D3D8_HANDLE_PS); + wined3d_mutex_unlock(); + HeapFree(GetProcessHeap(), 0, object); + *shader = 0; + return hr; + } + + TRACE("Created pixel shader %p (handle %#x).\n", object, shader_handle); + *shader = shader_handle; + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_SetPixelShader(IDirect3DDevice8 *iface, DWORD shader) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_pixel_shader *shader_impl; + + TRACE("iface %p, shader %#x.\n", iface, shader); + + wined3d_mutex_lock(); + + if (!shader) + { + wined3d_device_set_pixel_shader(device->wined3d_device, NULL); + wined3d_mutex_unlock(); + return D3D_OK; + } + + if (!(shader_impl = d3d8_get_object(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_PS))) + { + WARN("Invalid handle (%#x) passed.\n", shader); + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + + TRACE("Setting shader %p.\n", shader_impl); + wined3d_device_set_pixel_shader(device->wined3d_device, shader_impl->wined3d_shader); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_GetPixelShader(IDirect3DDevice8 *iface, DWORD *shader) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct wined3d_shader *object; + + TRACE("iface %p, shader %p.\n", iface, shader); + + if (!shader) + return D3DERR_INVALIDCALL; + + wined3d_mutex_lock(); + if ((object = wined3d_device_get_pixel_shader(device->wined3d_device))) + { + struct d3d8_pixel_shader *d3d8_shader; + d3d8_shader = wined3d_shader_get_parent(object); + *shader = d3d8_shader->handle; + } + else + { + *shader = 0; + } + wined3d_mutex_unlock(); + + TRACE("Returning %#x.\n", *shader); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_DeletePixelShader(IDirect3DDevice8 *iface, DWORD shader) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_pixel_shader *shader_impl; + + TRACE("iface %p, shader %#x.\n", iface, shader); + + wined3d_mutex_lock(); + + if (!(shader_impl = d3d8_free_handle(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_PS))) + { + WARN("Invalid handle (%#x) passed.\n", shader); + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + + if (wined3d_device_get_pixel_shader(device->wined3d_device) == shader_impl->wined3d_shader) + IDirect3DDevice8_SetPixelShader(iface, 0); + + wined3d_mutex_unlock(); + + d3d8_pixel_shader_destroy(shader_impl); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_SetPixelShaderConstant(IDirect3DDevice8 *iface, + DWORD start_register, const void *data, DWORD count) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, start_register %u, data %p, count %u.\n", + iface, start_register, data, count); + + wined3d_mutex_lock(); + hr = wined3d_device_set_ps_consts_f(device->wined3d_device, start_register, data, count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetPixelShaderConstant(IDirect3DDevice8 *iface, + DWORD start_register, void *data, DWORD count) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + HRESULT hr; + + TRACE("iface %p, start_register %u, data %p, count %u.\n", + iface, start_register, data, count); + + wined3d_mutex_lock(); + hr = wined3d_device_get_ps_consts_f(device->wined3d_device, start_register, data, count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetPixelShaderFunction(IDirect3DDevice8 *iface, + DWORD shader, void *data, DWORD *data_size) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_pixel_shader *shader_impl = NULL; + HRESULT hr; + + TRACE("iface %p, shader %#x, data %p, data_size %p.\n", + iface, shader, data, data_size); + + wined3d_mutex_lock(); + if (!(shader_impl = d3d8_get_object(&device->handle_table, shader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_PS))) + { + WARN("Invalid handle (%#x) passed.\n", shader); + wined3d_mutex_unlock(); + + return D3DERR_INVALIDCALL; + } + + hr = wined3d_shader_get_byte_code(shader_impl->wined3d_shader, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_DrawRectPatch(IDirect3DDevice8 *iface, UINT handle, + const float *segment_count, const D3DRECTPATCH_INFO *patch_info) +{ + FIXME("iface %p, handle %#x, segment_count %p, patch_info %p unimplemented.\n", + iface, handle, segment_count, patch_info); + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_DrawTriPatch(IDirect3DDevice8 *iface, UINT handle, + const float *segment_count, const D3DTRIPATCH_INFO *patch_info) +{ + FIXME("iface %p, handle %#x, segment_count %p, patch_info %p unimplemented.\n", + iface, handle, segment_count, patch_info); + return D3D_OK; +} + +static HRESULT WINAPI d3d8_device_DeletePatch(IDirect3DDevice8 *iface, UINT handle) +{ + FIXME("iface %p, handle %#x unimplemented.\n", iface, handle); + return D3DERR_INVALIDCALL; +} + +static HRESULT WINAPI d3d8_device_SetStreamSource(IDirect3DDevice8 *iface, + UINT stream_idx, IDirect3DVertexBuffer8 *buffer, UINT stride) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_vertexbuffer *buffer_impl = unsafe_impl_from_IDirect3DVertexBuffer8(buffer); + HRESULT hr; + + TRACE("iface %p, stream_idx %u, buffer %p, stride %u.\n", + iface, stream_idx, buffer, stride); + + wined3d_mutex_lock(); + hr = wined3d_device_set_stream_source(device->wined3d_device, stream_idx, + buffer_impl ? buffer_impl->wined3d_buffer : NULL, 0, stride); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_device_GetStreamSource(IDirect3DDevice8 *iface, + UINT stream_idx, IDirect3DVertexBuffer8 **buffer, UINT *stride) +{ + struct d3d8_device *device = impl_from_IDirect3DDevice8(iface); + struct d3d8_vertexbuffer *buffer_impl; + struct wined3d_buffer *wined3d_buffer = NULL; + HRESULT hr; + + TRACE("iface %p, stream_idx %u, buffer %p, stride %p.\n", + iface, stream_idx, buffer, stride); + + if (!buffer) + return D3DERR_INVALIDCALL; + + wined3d_mutex_lock(); + hr = wined3d_device_get_stream_source(device->wined3d_device, stream_idx, &wined3d_buffer, 0, stride); + if (SUCCEEDED(hr) && wined3d_buffer) + { + buffer_impl = wined3d_buffer_get_parent(wined3d_buffer); + *buffer = &buffer_impl->IDirect3DVertexBuffer8_iface; + IDirect3DVertexBuffer8_AddRef(*buffer); + wined3d_buffer_decref(wined3d_buffer); + } + else + { + if (FAILED(hr)) + ERR("Failed to get wined3d stream source, hr %#x.\n", hr); + *buffer = NULL; + } + wined3d_mutex_unlock(); + + return hr; +} + +static const struct IDirect3DDevice8Vtbl d3d8_device_vtbl = +{ + d3d8_device_QueryInterface, + d3d8_device_AddRef, + d3d8_device_Release, + d3d8_device_TestCooperativeLevel, + d3d8_device_GetAvailableTextureMem, + d3d8_device_ResourceManagerDiscardBytes, + d3d8_device_GetDirect3D, + d3d8_device_GetDeviceCaps, + d3d8_device_GetDisplayMode, + d3d8_device_GetCreationParameters, + d3d8_device_SetCursorProperties, + d3d8_device_SetCursorPosition, + d3d8_device_ShowCursor, + d3d8_device_CreateAdditionalSwapChain, + d3d8_device_Reset, + d3d8_device_Present, + d3d8_device_GetBackBuffer, + d3d8_device_GetRasterStatus, + d3d8_device_SetGammaRamp, + d3d8_device_GetGammaRamp, + d3d8_device_CreateTexture, + d3d8_device_CreateVolumeTexture, + d3d8_device_CreateCubeTexture, + d3d8_device_CreateVertexBuffer, + d3d8_device_CreateIndexBuffer, + d3d8_device_CreateRenderTarget, + d3d8_device_CreateDepthStencilSurface, + d3d8_device_CreateImageSurface, + d3d8_device_CopyRects, + d3d8_device_UpdateTexture, + d3d8_device_GetFrontBuffer, + d3d8_device_SetRenderTarget, + d3d8_device_GetRenderTarget, + d3d8_device_GetDepthStencilSurface, + d3d8_device_BeginScene, + d3d8_device_EndScene, + d3d8_device_Clear, + d3d8_device_SetTransform, + d3d8_device_GetTransform, + d3d8_device_MultiplyTransform, + d3d8_device_SetViewport, + d3d8_device_GetViewport, + d3d8_device_SetMaterial, + d3d8_device_GetMaterial, + d3d8_device_SetLight, + d3d8_device_GetLight, + d3d8_device_LightEnable, + d3d8_device_GetLightEnable, + d3d8_device_SetClipPlane, + d3d8_device_GetClipPlane, + d3d8_device_SetRenderState, + d3d8_device_GetRenderState, + d3d8_device_BeginStateBlock, + d3d8_device_EndStateBlock, + d3d8_device_ApplyStateBlock, + d3d8_device_CaptureStateBlock, + d3d8_device_DeleteStateBlock, + d3d8_device_CreateStateBlock, + d3d8_device_SetClipStatus, + d3d8_device_GetClipStatus, + d3d8_device_GetTexture, + d3d8_device_SetTexture, + d3d8_device_GetTextureStageState, + d3d8_device_SetTextureStageState, + d3d8_device_ValidateDevice, + d3d8_device_GetInfo, + d3d8_device_SetPaletteEntries, + d3d8_device_GetPaletteEntries, + d3d8_device_SetCurrentTexturePalette, + d3d8_device_GetCurrentTexturePalette, + d3d8_device_DrawPrimitive, + d3d8_device_DrawIndexedPrimitive, + d3d8_device_DrawPrimitiveUP, + d3d8_device_DrawIndexedPrimitiveUP, + d3d8_device_ProcessVertices, + d3d8_device_CreateVertexShader, + d3d8_device_SetVertexShader, + d3d8_device_GetVertexShader, + d3d8_device_DeleteVertexShader, + d3d8_device_SetVertexShaderConstant, + d3d8_device_GetVertexShaderConstant, + d3d8_device_GetVertexShaderDeclaration, + d3d8_device_GetVertexShaderFunction, + d3d8_device_SetStreamSource, + d3d8_device_GetStreamSource, + d3d8_device_SetIndices, + d3d8_device_GetIndices, + d3d8_device_CreatePixelShader, + d3d8_device_SetPixelShader, + d3d8_device_GetPixelShader, + d3d8_device_DeletePixelShader, + d3d8_device_SetPixelShaderConstant, + d3d8_device_GetPixelShaderConstant, + d3d8_device_GetPixelShaderFunction, + d3d8_device_DrawRectPatch, + d3d8_device_DrawTriPatch, + d3d8_device_DeletePatch, +}; + +static inline struct d3d8_device *device_from_device_parent(struct wined3d_device_parent *device_parent) +{ + return CONTAINING_RECORD(device_parent, struct d3d8_device, device_parent); +} + +static void CDECL device_parent_wined3d_device_created(struct wined3d_device_parent *device_parent, + struct wined3d_device *device) +{ + TRACE("device_parent %p, device %p\n", device_parent, device); +} + +static void CDECL device_parent_mode_changed(struct wined3d_device_parent *device_parent) +{ + TRACE("device_parent %p.\n", device_parent); +} + +static HRESULT CDECL device_parent_create_texture_surface(struct wined3d_device_parent *device_parent, + void *container_parent, const struct wined3d_resource_desc *desc, UINT sub_resource_idx, + DWORD flags, struct wined3d_surface **surface) +{ + struct d3d8_device *device = device_from_device_parent(device_parent); + struct d3d8_surface *d3d_surface; + HRESULT hr; + + TRACE("device_parent %p, container_parent %p, desc %p, sub_resource_idx %u, flags %#x, surface %p.\n", + device_parent, container_parent, desc, sub_resource_idx, flags, surface); + + if (FAILED(hr = d3d8_device_create_surface(device, desc->width, desc->height, + d3dformat_from_wined3dformat(desc->format), flags, (IDirect3DSurface8 **)&d3d_surface, + desc->usage, desc->pool, desc->multisample_type, desc->multisample_quality))) + { + WARN("Failed to create surface, hr %#x.\n", hr); + return hr; + } + + *surface = d3d_surface->wined3d_surface; + wined3d_surface_incref(*surface); + + d3d_surface->container = container_parent; + IDirect3DDevice8_Release(d3d_surface->parent_device); + d3d_surface->parent_device = NULL; + + IDirect3DSurface8_Release(&d3d_surface->IDirect3DSurface8_iface); + d3d_surface->forwardReference = container_parent; + + return hr; +} + +static HRESULT CDECL device_parent_create_swapchain_surface(struct wined3d_device_parent *device_parent, + void *container_parent, const struct wined3d_resource_desc *desc, struct wined3d_surface **surface) +{ + struct d3d8_device *device = device_from_device_parent(device_parent); + struct wined3d_resource_desc texture_desc; + struct d3d8_surface *d3d_surface; + struct wined3d_texture *texture; + HRESULT hr; + + TRACE("device_parent %p, container_parent %p, desc %p, surface %p.\n", + device_parent, container_parent, desc, surface); + + texture_desc = *desc; + texture_desc.resource_type = WINED3D_RTYPE_TEXTURE; + if (FAILED(hr = wined3d_texture_create_2d(device->wined3d_device, &texture_desc, 1, + WINED3D_SURFACE_MAPPABLE, &device->IDirect3DDevice8_iface, &d3d8_null_wined3d_parent_ops, &texture))) + { + WARN("Failed to create texture, hr %#x.\n", hr); + return hr; + } + + *surface = wined3d_surface_from_resource(wined3d_texture_get_sub_resource(texture, 0)); + wined3d_surface_incref(*surface); + wined3d_texture_decref(texture); + + d3d_surface = wined3d_surface_get_parent(*surface); + d3d_surface->forwardReference = NULL; + d3d_surface->parent_device = &device->IDirect3DDevice8_iface; + + return hr; +} + +static HRESULT CDECL device_parent_create_volume(struct wined3d_device_parent *device_parent, + void *container_parent, UINT width, UINT height, UINT depth, enum wined3d_format_id format, + enum wined3d_pool pool, DWORD usage, struct wined3d_volume **volume) +{ + struct d3d8_device *device = device_from_device_parent(device_parent); + struct d3d8_volume *object; + HRESULT hr; + + TRACE("device_parent %p, container_parent %p, width %u, height %u, depth %u, " + "format %#x, pool %#x, usage %#x, volume %p.\n", + device_parent, container_parent, width, height, depth, + format, pool, usage, volume); + + /* Allocate the storage for the device */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!object) + { + FIXME("Allocation of memory failed\n"); + *volume = NULL; + return D3DERR_OUTOFVIDEOMEMORY; + } + + hr = volume_init(object, device, width, height, depth, usage, format, pool); + if (FAILED(hr)) + { + WARN("Failed to initialize volume, hr %#x.\n", hr); + HeapFree(GetProcessHeap(), 0, object); + return hr; + } + + *volume = object->wined3d_volume; + wined3d_volume_incref(*volume); + IDirect3DVolume8_Release(&object->IDirect3DVolume8_iface); + + object->container = container_parent; + object->forwardReference = container_parent; + + TRACE("Created volume %p.\n", object); + + return hr; +} + +static HRESULT CDECL device_parent_create_swapchain(struct wined3d_device_parent *device_parent, + struct wined3d_swapchain_desc *desc, struct wined3d_swapchain **swapchain) +{ + struct d3d8_device *device = device_from_device_parent(device_parent); + struct d3d8_swapchain *d3d_swapchain; + HRESULT hr; + + TRACE("device_parent %p, desc %p, swapchain %p.\n", device_parent, desc, swapchain); + + if (FAILED(hr = d3d8_swapchain_create(device, desc, &d3d_swapchain))) + { + WARN("Failed to create swapchain, hr %#x.\n", hr); + *swapchain = NULL; + return hr; + } + + *swapchain = d3d_swapchain->wined3d_swapchain; + wined3d_swapchain_incref(*swapchain); + IDirect3DSwapChain8_Release(&d3d_swapchain->IDirect3DSwapChain8_iface); + + return hr; +} + +static const struct wined3d_device_parent_ops d3d8_wined3d_device_parent_ops = +{ + device_parent_wined3d_device_created, + device_parent_mode_changed, + device_parent_create_swapchain_surface, + device_parent_create_texture_surface, + device_parent_create_volume, + device_parent_create_swapchain, +}; + +static void setup_fpu(void) +{ +#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) + WORD cw; + __asm__ volatile ("fnstcw %0" : "=m" (cw)); + cw = (cw & ~0xf3f) | 0x3f; + __asm__ volatile ("fldcw %0" : : "m" (cw)); +#elif defined(__i386__) && defined(_MSC_VER) + WORD cw; + __asm fnstcw cw; + cw = (cw & ~0xf3f) | 0x3f; + __asm fldcw cw; +#elif defined(RT_ARCH_AMD64) + unsigned int currentControl = 0; + _controlfp_s(¤tControl, 0x3f, 0xf3f); +#else + FIXME("FPU setup not implemented for this platform.\n"); +#endif +} + +HRESULT device_init(struct d3d8_device *device, struct d3d8 *parent, struct wined3d *wined3d, UINT adapter, + D3DDEVTYPE device_type, HWND focus_window, DWORD flags, D3DPRESENT_PARAMETERS *parameters) +{ + struct wined3d_swapchain_desc swapchain_desc; + HRESULT hr; + + 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) + { + ERR("Failed to allocate handle table memory.\n"); + return E_OUTOFMEMORY; + } + device->handle_table.table_size = D3D8_INITIAL_HANDLE_TABLE_SIZE; + + if (!(flags & D3DCREATE_FPU_PRESERVE)) setup_fpu(); + + wined3d_mutex_lock(); + hr = wined3d_device_create(wined3d, adapter, device_type, focus_window, flags, 4, + &device->device_parent, &device->wined3d_device); + if (FAILED(hr)) + { + WARN("Failed to create wined3d device, hr %#x.\n", hr); + wined3d_mutex_unlock(); + HeapFree(GetProcessHeap(), 0, device->handle_table.entries); + return hr; + } + + if (!parameters->Windowed) + { + HWND device_window = parameters->hDeviceWindow; + + if (!focus_window) + focus_window = device_window; + if (FAILED(hr = wined3d_device_acquire_focus_window(device->wined3d_device, focus_window))) + { + 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); + return hr; + } + + if (!device_window) + device_window = focus_window; + wined3d_device_setup_fullscreen_window(device->wined3d_device, device_window, + parameters->BackBufferWidth, + parameters->BackBufferHeight); + } + + if (flags & D3DCREATE_MULTITHREADED) + wined3d_device_set_multithreaded(device->wined3d_device); + + wined3d_swapchain_desc_from_present_parameters(&swapchain_desc, parameters); + + hr = wined3d_device_init_3d(device->wined3d_device, &swapchain_desc); + if (FAILED(hr)) + { + WARN("Failed to initialize 3D, hr %#x.\n", hr); + wined3d_device_release_focus_window(device->wined3d_device); + wined3d_device_decref(device->wined3d_device); + wined3d_mutex_unlock(); + HeapFree(GetProcessHeap(), 0, device->handle_table.entries); + return hr; + } + + wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_POINTSIZE_MIN, 0); + wined3d_mutex_unlock(); + + 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) + { + ERR("Failed to allocate FVF vertex declaration map memory.\n"); + hr = E_OUTOFMEMORY; + goto err; + } + + device->d3d_parent = &parent->IDirect3D8_iface; + IDirect3D8_AddRef(device->d3d_parent); + + return D3D_OK; + +err: + wined3d_mutex_lock(); + wined3d_device_uninit_3d(device->wined3d_device); + wined3d_device_release_focus_window(device->wined3d_device); + wined3d_device_decref(device->wined3d_device); + wined3d_mutex_unlock(); + HeapFree(GetProcessHeap(), 0, device->handle_table.entries); + return hr; +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/directx.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/directx.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/directx.c (revision 46521) @@ -0,0 +1,419 @@ +/* + * IDirect3D8 implementation + * + * Copyright 2002-2004 Jason Edmeades + * Copyright 2003-2004 Raphael Junqueira + * Copyright 2004 Christian Costa + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "config.h" + +#include + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#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); +} + +static HRESULT WINAPI d3d8_QueryInterface(IDirect3D8 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3D8) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3D8_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d8_AddRef(IDirect3D8 *iface) +{ + struct d3d8 *d3d8 = impl_from_IDirect3D8(iface); + ULONG refcount = InterlockedIncrement(&d3d8->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, refcount); + + return refcount; +} + +static ULONG WINAPI d3d8_Release(IDirect3D8 *iface) +{ + struct d3d8 *d3d8 = impl_from_IDirect3D8(iface); + ULONG refcount = InterlockedDecrement(&d3d8->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, refcount); + + if (!refcount) + { + wined3d_mutex_lock(); + wined3d_decref(d3d8->wined3d); + wined3d_mutex_unlock(); + + HeapFree(GetProcessHeap(), 0, d3d8); + } + + return refcount; +} + +static HRESULT WINAPI d3d8_RegisterSoftwareDevice(IDirect3D8 *iface, void *init_function) +{ + struct d3d8 *d3d8 = impl_from_IDirect3D8(iface); + HRESULT hr; + + TRACE("iface %p, init_function %p.\n", iface, init_function); + + wined3d_mutex_lock(); + hr = wined3d_register_software_device(d3d8->wined3d, init_function); + wined3d_mutex_unlock(); + + return hr; +} + +static UINT WINAPI d3d8_GetAdapterCount(IDirect3D8 *iface) +{ + struct d3d8 *d3d8 = impl_from_IDirect3D8(iface); + HRESULT hr; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + hr = wined3d_get_adapter_count(d3d8->wined3d); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_GetAdapterIdentifier(IDirect3D8 *iface, UINT adapter, + DWORD flags, D3DADAPTER_IDENTIFIER8 *identifier) +{ + struct d3d8 *d3d8 = impl_from_IDirect3D8(iface); + struct wined3d_adapter_identifier adapter_id; + HRESULT hr; + + TRACE("iface %p, adapter %u, flags %#x, identifier %p.\n", + iface, adapter, flags, identifier); + + adapter_id.driver = identifier->Driver; + adapter_id.driver_size = sizeof(identifier->Driver); + adapter_id.description = identifier->Description; + adapter_id.description_size = sizeof(identifier->Description); + adapter_id.device_name = NULL; /* d3d9 only */ + adapter_id.device_name_size = 0; /* d3d9 only */ + + wined3d_mutex_lock(); + hr = wined3d_get_adapter_identifier(d3d8->wined3d, adapter, flags, &adapter_id); + wined3d_mutex_unlock(); + + identifier->DriverVersion = adapter_id.driver_version; + identifier->VendorId = adapter_id.vendor_id; + identifier->DeviceId = adapter_id.device_id; + identifier->SubSysId = adapter_id.subsystem_id; + identifier->Revision = adapter_id.revision; + memcpy(&identifier->DeviceIdentifier, &adapter_id.device_identifier, sizeof(identifier->DeviceIdentifier)); + identifier->WHQLLevel = adapter_id.whql_level; + + return hr; +} + +static UINT WINAPI d3d8_GetAdapterModeCount(IDirect3D8 *iface, UINT adapter) +{ + struct d3d8 *d3d8 = impl_from_IDirect3D8(iface); + HRESULT hr; + + TRACE("iface %p, adapter %u.\n", iface, adapter); + + wined3d_mutex_lock(); + hr = wined3d_get_adapter_mode_count(d3d8->wined3d, adapter, + WINED3DFMT_UNKNOWN, WINED3D_SCANLINE_ORDERING_UNKNOWN); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_EnumAdapterModes(IDirect3D8 *iface, UINT adapter, UINT mode_idx, D3DDISPLAYMODE *mode) +{ + struct d3d8 *d3d8 = impl_from_IDirect3D8(iface); + struct wined3d_display_mode wined3d_mode; + HRESULT hr; + + TRACE("iface %p, adapter %u, mode_idx %u, mode %p.\n", + iface, adapter, mode_idx, mode); + + wined3d_mutex_lock(); + hr = wined3d_enum_adapter_modes(d3d8->wined3d, adapter, WINED3DFMT_UNKNOWN, + WINED3D_SCANLINE_ORDERING_UNKNOWN, mode_idx, &wined3d_mode); + wined3d_mutex_unlock(); + + if (SUCCEEDED(hr)) + { + mode->Width = wined3d_mode.width; + mode->Height = wined3d_mode.height; + mode->RefreshRate = wined3d_mode.refresh_rate; + mode->Format = d3dformat_from_wined3dformat(wined3d_mode.format_id); + } + + return hr; +} + +static HRESULT WINAPI d3d8_GetAdapterDisplayMode(IDirect3D8 *iface, UINT adapter, D3DDISPLAYMODE *mode) +{ + struct d3d8 *d3d8 = impl_from_IDirect3D8(iface); + struct wined3d_display_mode wined3d_mode; + HRESULT hr; + + TRACE("iface %p, adapter %u, mode %p.\n", + iface, adapter, mode); + + wined3d_mutex_lock(); + hr = wined3d_get_adapter_display_mode(d3d8->wined3d, adapter, &wined3d_mode, NULL); + wined3d_mutex_unlock(); + + if (SUCCEEDED(hr)) + { + mode->Width = wined3d_mode.width; + mode->Height = wined3d_mode.height; + mode->RefreshRate = wined3d_mode.refresh_rate; + mode->Format = d3dformat_from_wined3dformat(wined3d_mode.format_id); + } + + return hr; +} + +static HRESULT WINAPI d3d8_CheckDeviceType(IDirect3D8 *iface, UINT adapter, D3DDEVTYPE device_type, + D3DFORMAT display_format, D3DFORMAT backbuffer_format, BOOL windowed) +{ + struct d3d8 *d3d8 = impl_from_IDirect3D8(iface); + HRESULT hr; + + TRACE("iface %p, adapter %u, device_type %#x, display_format %#x, backbuffer_format %#x, windowed %#x.\n", + iface, adapter, device_type, display_format, backbuffer_format, windowed); + + wined3d_mutex_lock(); + hr = wined3d_check_device_type(d3d8->wined3d, adapter, device_type, wined3dformat_from_d3dformat(display_format), + wined3dformat_from_d3dformat(backbuffer_format), windowed); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_CheckDeviceFormat(IDirect3D8 *iface, UINT adapter, D3DDEVTYPE device_type, + D3DFORMAT adapter_format, DWORD usage, D3DRESOURCETYPE resource_type, D3DFORMAT format) +{ + struct d3d8 *d3d8 = impl_from_IDirect3D8(iface); + enum wined3d_resource_type wined3d_rtype; + HRESULT hr; + + TRACE("iface %p, adapter %u, device_type %#x, adapter_format %#x, usage %#x, resource_type %#x, format %#x.\n", + iface, adapter, device_type, adapter_format, usage, resource_type, format); + + switch (resource_type) + { + case D3DRTYPE_VERTEXBUFFER: + case D3DRTYPE_INDEXBUFFER: + wined3d_rtype = WINED3D_RTYPE_BUFFER; + break; + + default: + wined3d_rtype = resource_type; + break; + } + + wined3d_mutex_lock(); + hr = wined3d_check_device_format(d3d8->wined3d, adapter, device_type, wined3dformat_from_d3dformat(adapter_format), + usage, wined3d_rtype, wined3dformat_from_d3dformat(format)); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_CheckDeviceMultiSampleType(IDirect3D8 *iface, UINT adapter, D3DDEVTYPE device_type, + D3DFORMAT format, BOOL windowed, D3DMULTISAMPLE_TYPE multisample_type) +{ + struct d3d8 *d3d8 = impl_from_IDirect3D8(iface); + HRESULT hr; + + TRACE("iface %p, adapter %u, device_type %#x, format %#x, windowed %#x, multisample_type %#x.\n", + iface, adapter, device_type, format, windowed, multisample_type); + + wined3d_mutex_lock(); + hr = wined3d_check_device_multisample_type(d3d8->wined3d, adapter, device_type, + wined3dformat_from_d3dformat(format), windowed, + (enum wined3d_multisample_type)multisample_type, NULL); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_CheckDepthStencilMatch(IDirect3D8 *iface, UINT adapter, D3DDEVTYPE device_type, + D3DFORMAT adapter_format, D3DFORMAT rt_format, D3DFORMAT ds_format) +{ + struct d3d8 *d3d8 = impl_from_IDirect3D8(iface); + HRESULT hr; + + TRACE("iface %p, adapter %u, device_type %#x, adapter_format %#x, rt_format %#x, ds_format %#x.\n", + iface, adapter, device_type, adapter_format, rt_format, ds_format); + + wined3d_mutex_lock(); + hr = wined3d_check_depth_stencil_match(d3d8->wined3d, adapter, device_type, + wined3dformat_from_d3dformat(adapter_format), wined3dformat_from_d3dformat(rt_format), + wined3dformat_from_d3dformat(ds_format)); + wined3d_mutex_unlock(); + + return hr; +} + +void fixup_caps(WINED3DCAPS *caps) +{ + /* D3D8 doesn't support SM 2.0 or higher, so clamp to 1.x */ + if (caps->PixelShaderVersion) + caps->PixelShaderVersion = D3DPS_VERSION(1,4); + else + caps->PixelShaderVersion = D3DPS_VERSION(0,0); + if (caps->VertexShaderVersion) + caps->VertexShaderVersion = D3DVS_VERSION(1,1); + else + caps->VertexShaderVersion = D3DVS_VERSION(0,0); + caps->MaxVertexShaderConst = min(D3D8_MAX_VERTEX_SHADER_CONSTANTF, caps->MaxVertexShaderConst); + + caps->StencilCaps &= ~WINED3DSTENCILCAPS_TWOSIDED; +} + +static HRESULT WINAPI d3d8_GetDeviceCaps(IDirect3D8 *iface, UINT adapter, D3DDEVTYPE device_type, D3DCAPS8 *caps) +{ + struct d3d8 *d3d8 = impl_from_IDirect3D8(iface); + WINED3DCAPS *wined3d_caps; + HRESULT hr; + + TRACE("iface %p, adapter %u, device_type %#x, caps %p.\n", iface, adapter, device_type, caps); + + if (!caps) + return D3DERR_INVALIDCALL; + + if (!(wined3d_caps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wined3d_caps)))) + return D3DERR_INVALIDCALL; + + wined3d_mutex_lock(); + hr = wined3d_get_device_caps(d3d8->wined3d, adapter, device_type, wined3d_caps); + wined3d_mutex_unlock(); + + fixup_caps(wined3d_caps); + WINECAPSTOD3D8CAPS(caps, wined3d_caps) + HeapFree(GetProcessHeap(), 0, wined3d_caps); + + return hr; +} + +static HMONITOR WINAPI d3d8_GetAdapterMonitor(IDirect3D8 *iface, UINT adapter) +{ + struct d3d8 *d3d8 = impl_from_IDirect3D8(iface); + HMONITOR ret; + + TRACE("iface %p, adapter %u.\n", iface, adapter); + + wined3d_mutex_lock(); + ret = wined3d_get_adapter_monitor(d3d8->wined3d, adapter); + wined3d_mutex_unlock(); + + return ret; +} + +static HRESULT WINAPI d3d8_CreateDevice(IDirect3D8 *iface, UINT adapter, + D3DDEVTYPE device_type, HWND focus_window, DWORD flags, D3DPRESENT_PARAMETERS *parameters, + IDirect3DDevice8 **device) +{ + struct d3d8 *d3d8 = impl_from_IDirect3D8(iface); + struct d3d8_device *object; + HRESULT hr; + + 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) + 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); + return hr; + } + + TRACE("Created device %p.\n", object); + *device = &object->IDirect3DDevice8_iface; + + return D3D_OK; +} + +static const struct IDirect3D8Vtbl d3d8_vtbl = +{ + /* IUnknown */ + d3d8_QueryInterface, + d3d8_AddRef, + d3d8_Release, + /* IDirect3D8 */ + d3d8_RegisterSoftwareDevice, + d3d8_GetAdapterCount, + d3d8_GetAdapterIdentifier, + d3d8_GetAdapterModeCount, + d3d8_EnumAdapterModes, + d3d8_GetAdapterDisplayMode, + d3d8_CheckDeviceType, + d3d8_CheckDeviceFormat, + d3d8_CheckDeviceMultiSampleType, + d3d8_CheckDepthStencilMatch, + d3d8_GetDeviceCaps, + d3d8_GetAdapterMonitor, + d3d8_CreateDevice, +}; + +BOOL d3d8_init(struct d3d8 *d3d8) +{ + DWORD flags = WINED3D_LEGACY_DEPTH_BIAS | WINED3D_VIDMEM_ACCOUNTING; + + d3d8->IDirect3D8_iface.lpVtbl = &d3d8_vtbl; + d3d8->refcount = 1; + + wined3d_mutex_lock(); + d3d8->wined3d = wined3d_create(8, flags); + wined3d_mutex_unlock(); + if (!d3d8->wined3d) + return FALSE; + + return TRUE; +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/shader.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/shader.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/shader.c (revision 46521) @@ -0,0 +1,170 @@ +/* + * Copyright 2002-2003 Jason Edmeades + * Raphael Junqueira + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * 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); +} + +void d3d8_vertex_shader_destroy(struct d3d8_vertex_shader *shader) +{ + TRACE("shader %p.\n", shader); + + if (shader->wined3d_shader) + { + wined3d_mutex_lock(); + wined3d_shader_decref(shader->wined3d_shader); + wined3d_mutex_unlock(); + } + else + { + d3d8_vertexshader_wined3d_object_destroyed(shader); + } +} + +static const struct wined3d_parent_ops d3d8_vertexshader_wined3d_parent_ops = +{ + d3d8_vertexshader_wined3d_object_destroyed, +}; + +static HRESULT d3d8_vertexshader_create_vertexdeclaration(struct d3d8_device *device, + const DWORD *declaration, DWORD shader_handle, struct d3d8_vertex_declaration **decl_ptr) +{ + struct d3d8_vertex_declaration *object; + HRESULT hr; + + 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) + 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); + return hr; + } + + TRACE("Created vertex declaration %p.\n", object); + *decl_ptr = object; + + return D3D_OK; +} + +HRESULT d3d8_vertex_shader_init(struct d3d8_vertex_shader *shader, struct d3d8_device *device, + const DWORD *declaration, const DWORD *byte_code, DWORD shader_handle, DWORD usage) +{ + const DWORD *token = declaration; + HRESULT hr; + + /* Test if the vertex declaration is valid. */ + while (D3DVSD_END() != *token) + { + D3DVSD_TOKENTYPE token_type = ((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT); + + if (token_type == D3DVSD_TOKEN_STREAMDATA && !(token_type & 0x10000000)) + { + DWORD type = ((*token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT); + DWORD reg = ((*token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT); + + if (reg == D3DVSDE_NORMAL && type != D3DVSDT_FLOAT3 && !byte_code) + { + WARN("Attempt to use a non-FLOAT3 normal with the fixed function function\n"); + return D3DERR_INVALIDCALL; + } + } + token += parse_token(token); + } + + hr = d3d8_vertexshader_create_vertexdeclaration(device, declaration, shader_handle, &shader->vertex_declaration); + if (FAILED(hr)) + { + WARN("Failed to create vertex declaration, hr %#x.\n", hr); + return hr; + } + + if (byte_code) + { + if (usage) FIXME("Usage %#x not implemented.\n", usage); + + wined3d_mutex_lock(); + hr = wined3d_shader_create_vs(device->wined3d_device, byte_code, NULL /* output signature */, + shader, &d3d8_vertexshader_wined3d_parent_ops, &shader->wined3d_shader, 1); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d vertex shader, hr %#x.\n", hr); + d3d8_vertex_declaration_destroy(shader->vertex_declaration); + return hr; + } + + load_local_constants(declaration, shader->wined3d_shader); + } + + return D3D_OK; +} + +static void STDMETHODCALLTYPE d3d8_pixelshader_wined3d_object_destroyed(void *parent) +{ + HeapFree(GetProcessHeap(), 0, parent); +} + +void d3d8_pixel_shader_destroy(struct d3d8_pixel_shader *shader) +{ + TRACE("shader %p.\n", shader); + + wined3d_mutex_lock(); + wined3d_shader_decref(shader->wined3d_shader); + wined3d_mutex_unlock(); +} + +static const struct wined3d_parent_ops d3d8_pixelshader_wined3d_parent_ops = +{ + d3d8_pixelshader_wined3d_object_destroyed, +}; + +HRESULT d3d8_pixel_shader_init(struct d3d8_pixel_shader *shader, struct d3d8_device *device, + const DWORD *byte_code, DWORD shader_handle) +{ + HRESULT hr; + + shader->handle = shader_handle; + + wined3d_mutex_lock(); + hr = wined3d_shader_create_ps(device->wined3d_device, byte_code, NULL, shader, + &d3d8_pixelshader_wined3d_parent_ops, &shader->wined3d_shader, 1); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d pixel shader, hr %#x.\n", hr); + return hr; + } + + return D3D_OK; +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/surface.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/surface.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/surface.c (revision 46521) @@ -0,0 +1,368 @@ +/* + * IDirect3DSurface8 implementation + * + * Copyright 2005 Oliver Stieber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * 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); +} + +static HRESULT WINAPI d3d8_surface_QueryInterface(IDirect3DSurface8 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DSurface8) + || IsEqualGUID(riid, &IID_IDirect3DResource8) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DSurface8_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d8_surface_AddRef(IDirect3DSurface8 *iface) +{ + struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface); + + TRACE("iface %p.\n", iface); + + if (surface->forwardReference) + { + /* Forward refcounting */ + TRACE("Forwarding to %p.\n", surface->forwardReference); + return IUnknown_AddRef(surface->forwardReference); + } + else + { + /* No container, handle our own refcounting */ + ULONG ref = InterlockedIncrement(&surface->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, ref); + + if (ref == 1) + { + if (surface->parent_device) + IDirect3DDevice8_AddRef(surface->parent_device); + wined3d_mutex_lock(); + wined3d_surface_incref(surface->wined3d_surface); + wined3d_mutex_unlock(); + } + + return ref; + } +} + +static ULONG WINAPI d3d8_surface_Release(IDirect3DSurface8 *iface) +{ + struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface); + + TRACE("iface %p.\n", iface); + + if (surface->forwardReference) + { + /* Forward refcounting */ + TRACE("Forwarding to %p.\n", surface->forwardReference); + return IUnknown_Release(surface->forwardReference); + } + else + { + /* No container, handle our own refcounting */ + ULONG ref = InterlockedDecrement(&surface->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, ref); + + if (!ref) + { + IDirect3DDevice8 *parent_device = surface->parent_device; + + /* Implicit surfaces are destroyed with the device, not if refcount reaches 0. */ + wined3d_mutex_lock(); + wined3d_surface_decref(surface->wined3d_surface); + wined3d_mutex_unlock(); + + if (parent_device) + IDirect3DDevice8_Release(parent_device); + } + + return ref; + } +} + +static HRESULT WINAPI d3d8_surface_GetDevice(IDirect3DSurface8 *iface, IDirect3DDevice8 **device) +{ + struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + if (surface->forwardReference) + { + IDirect3DResource8 *resource; + HRESULT hr; + + hr = IUnknown_QueryInterface(surface->forwardReference, &IID_IDirect3DResource8, (void **)&resource); + if (SUCCEEDED(hr)) + { + hr = IDirect3DResource8_GetDevice(resource, device); + IDirect3DResource8_Release(resource); + + TRACE("Returning device %p.\n", *device); + } + + return hr; + } + + *device = surface->parent_device; + IDirect3DDevice8_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_surface_SetPrivateData(IDirect3DSurface8 *iface, REFGUID guid, + const void *data, DWORD data_size, DWORD flags) +{ + struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n", + iface, debugstr_guid(guid), data, data_size, flags); + + wined3d_mutex_lock(); + resource = wined3d_surface_get_resource(surface->wined3d_surface); + hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_surface_GetPrivateData(IDirect3DSurface8 *iface, REFGUID guid, + void *data, DWORD *data_size) +{ + struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %p.\n", + iface, debugstr_guid(guid), data, data_size); + + wined3d_mutex_lock(); + resource = wined3d_surface_get_resource(surface->wined3d_surface); + hr = wined3d_resource_get_private_data(resource, guid, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_surface_FreePrivateData(IDirect3DSurface8 *iface, REFGUID guid) +{ + struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid)); + + wined3d_mutex_lock(); + resource = wined3d_surface_get_resource(surface->wined3d_surface); + hr = wined3d_resource_free_private_data(resource, guid); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_surface_GetContainer(IDirect3DSurface8 *iface, REFIID riid, void **container) +{ + struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface); + HRESULT hr; + + TRACE("iface %p, riid %s, container %p.\n", iface, debugstr_guid(riid), container); + + if (!surface->container) + return E_NOINTERFACE; + + hr = IUnknown_QueryInterface(surface->container, riid, container); + + TRACE("Returning %p.\n", *container); + + return hr; +} + +static HRESULT WINAPI d3d8_surface_GetDesc(IDirect3DSurface8 *iface, D3DSURFACE_DESC *desc) +{ + struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface); + struct wined3d_resource_desc wined3d_desc; + struct wined3d_resource *wined3d_resource; + + TRACE("iface %p, desc %p.\n", iface, desc); + + wined3d_mutex_lock(); + wined3d_resource = wined3d_surface_get_resource(surface->wined3d_surface); + wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); + wined3d_mutex_unlock(); + + desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); + desc->Type = wined3d_desc.resource_type; + desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; + desc->Pool = wined3d_desc.pool; + desc->Size = wined3d_desc.size; + desc->MultiSampleType = wined3d_desc.multisample_type; + desc->Width = wined3d_desc.width; + desc->Height = wined3d_desc.height; + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_surface_LockRect(IDirect3DSurface8 *iface, + D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) +{ + struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface); + struct wined3d_map_desc map_desc; + HRESULT hr; + + TRACE("iface %p, locked_rect %p, rect %s, flags %#x.\n", + iface, locked_rect, wine_dbgstr_rect(rect), flags); + + wined3d_mutex_lock(); + if (rect) + { + D3DSURFACE_DESC desc; + IDirect3DSurface8_GetDesc(iface, &desc); + + if ((rect->left < 0) + || (rect->top < 0) + || (rect->left >= rect->right) + || (rect->top >= rect->bottom) + || (rect->right > desc.Width) + || (rect->bottom > desc.Height)) + { + WARN("Trying to lock an invalid rectangle, returning D3DERR_INVALIDCALL\n"); + wined3d_mutex_unlock(); + + return D3DERR_INVALIDCALL; + } + } + + hr = wined3d_surface_map(surface->wined3d_surface, &map_desc, rect, flags); + wined3d_mutex_unlock(); + + locked_rect->Pitch = map_desc.row_pitch; + locked_rect->pBits = map_desc.data; + + return hr; +} + +static HRESULT WINAPI d3d8_surface_UnlockRect(IDirect3DSurface8 *iface) +{ + struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface); + HRESULT hr; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + hr = wined3d_surface_unmap(surface->wined3d_surface); + wined3d_mutex_unlock(); + + switch(hr) + { + case WINEDDERR_NOTLOCKED: return D3DERR_INVALIDCALL; + default: return hr; + } +} + +static const IDirect3DSurface8Vtbl d3d8_surface_vtbl = +{ + /* IUnknown */ + d3d8_surface_QueryInterface, + d3d8_surface_AddRef, + d3d8_surface_Release, + /* IDirect3DResource8 */ + d3d8_surface_GetDevice, + d3d8_surface_SetPrivateData, + d3d8_surface_GetPrivateData, + d3d8_surface_FreePrivateData, + /* IDirect3DSurface8 */ + d3d8_surface_GetContainer, + d3d8_surface_GetDesc, + d3d8_surface_LockRect, + d3d8_surface_UnlockRect, +}; + +static void STDMETHODCALLTYPE surface_wined3d_object_destroyed(void *parent) +{ + HeapFree(GetProcessHeap(), 0, parent); +} + +static const struct wined3d_parent_ops d3d8_surface_wined3d_parent_ops = +{ + surface_wined3d_object_destroyed, +}; + +HRESULT surface_init(struct d3d8_surface *surface, struct d3d8_device *device, UINT width, UINT height, + D3DFORMAT format, DWORD flags, DWORD usage, D3DPOOL pool, D3DMULTISAMPLE_TYPE multisample_type, + DWORD multisample_quality) +{ + HRESULT hr; + + surface->IDirect3DSurface8_iface.lpVtbl = &d3d8_surface_vtbl; + surface->refcount = 1; + + /* FIXME: Check MAX bounds of MultisampleQuality. */ + if (multisample_quality > 0) + { + FIXME("Multisample quality set to %u, substituting 0.\n", multisample_quality); + multisample_quality = 0; + } + + wined3d_mutex_lock(); + hr = wined3d_surface_create(device->wined3d_device, width, height, wined3dformat_from_d3dformat(format), + usage & WINED3DUSAGE_MASK, (enum wined3d_pool)pool, multisample_type, multisample_quality, + flags, surface, &d3d8_surface_wined3d_parent_ops, &surface->wined3d_surface); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d surface, hr %#x.\n", hr); + return hr; + } + + surface->parent_device = &device->IDirect3DDevice8_iface; + IDirect3DDevice8_AddRef(surface->parent_device); + + return D3D_OK; +} + +struct d3d8_surface *unsafe_impl_from_IDirect3DSurface8(IDirect3DSurface8 *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == &d3d8_surface_vtbl); + + return impl_from_IDirect3DSurface8(iface); +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/swapchain.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/swapchain.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/swapchain.c (revision 46521) @@ -0,0 +1,199 @@ +/* + * IDirect3DSwapChain8 implementation + * + * Copyright 2005 Oliver Stieber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * 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); +} + +static HRESULT WINAPI d3d8_swapchain_QueryInterface(IDirect3DSwapChain8 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DSwapChain8) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DSwapChain8_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d8_swapchain_AddRef(IDirect3DSwapChain8 *iface) +{ + struct d3d8_swapchain *swapchain = impl_from_IDirect3DSwapChain8(iface); + ULONG ref = InterlockedIncrement(&swapchain->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, ref); + + if (ref == 1) + { + if (swapchain->parent_device) + IDirect3DDevice8_AddRef(swapchain->parent_device); + wined3d_mutex_lock(); + wined3d_swapchain_incref(swapchain->wined3d_swapchain); + wined3d_mutex_unlock(); + } + + return ref; +} + +static ULONG WINAPI d3d8_swapchain_Release(IDirect3DSwapChain8 *iface) +{ + struct d3d8_swapchain *swapchain = impl_from_IDirect3DSwapChain8(iface); + ULONG ref = InterlockedDecrement(&swapchain->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, ref); + + if (!ref) + { + IDirect3DDevice8 *parent_device = swapchain->parent_device; + + wined3d_mutex_lock(); + wined3d_swapchain_decref(swapchain->wined3d_swapchain); + wined3d_mutex_unlock(); + + if (parent_device) + IDirect3DDevice8_Release(parent_device); + } + return ref; +} + +static HRESULT WINAPI d3d8_swapchain_Present(IDirect3DSwapChain8 *iface, + const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override, + const RGNDATA *dirty_region) +{ + struct d3d8_swapchain *swapchain = impl_from_IDirect3DSwapChain8(iface); + HRESULT hr; + + TRACE("iface %p, src_rect %s, dst_rect %s, dst_window_override %p, dirty_region %p.\n", + iface, wine_dbgstr_rect(src_rect), wine_dbgstr_rect(dst_rect), dst_window_override, dirty_region); + + wined3d_mutex_lock(); + hr = wined3d_swapchain_present(swapchain->wined3d_swapchain, src_rect, + dst_rect, dst_window_override, dirty_region, 0); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_swapchain_GetBackBuffer(IDirect3DSwapChain8 *iface, + UINT backbuffer_idx, D3DBACKBUFFER_TYPE backbuffer_type, IDirect3DSurface8 **backbuffer) +{ + struct d3d8_swapchain *swapchain = impl_from_IDirect3DSwapChain8(iface); + struct wined3d_surface *wined3d_surface = NULL; + struct d3d8_surface *surface_impl; + HRESULT hr = D3D_OK; + + TRACE("iface %p, backbuffer_idx %u, backbuffer_type %#x, backbuffer %p.\n", + iface, backbuffer_idx, backbuffer_type, backbuffer); + + wined3d_mutex_lock(); + if ((wined3d_surface = wined3d_swapchain_get_back_buffer(swapchain->wined3d_swapchain, + backbuffer_idx, (enum wined3d_backbuffer_type)backbuffer_type))) + { + surface_impl = wined3d_surface_get_parent(wined3d_surface); + *backbuffer = &surface_impl->IDirect3DSurface8_iface; + IDirect3DSurface8_AddRef(*backbuffer); + } + else + { + hr = D3DERR_INVALIDCALL; + } + wined3d_mutex_unlock(); + + return hr; +} + +static const IDirect3DSwapChain8Vtbl d3d8_swapchain_vtbl = +{ + d3d8_swapchain_QueryInterface, + d3d8_swapchain_AddRef, + d3d8_swapchain_Release, + d3d8_swapchain_Present, + d3d8_swapchain_GetBackBuffer +}; + +static void STDMETHODCALLTYPE d3d8_swapchain_wined3d_object_released(void *parent) +{ + HeapFree(GetProcessHeap(), 0, parent); +} + +static const struct wined3d_parent_ops d3d8_swapchain_wined3d_parent_ops = +{ + d3d8_swapchain_wined3d_object_released, +}; + +static HRESULT swapchain_init(struct d3d8_swapchain *swapchain, struct d3d8_device *device, + struct wined3d_swapchain_desc *desc) +{ + HRESULT hr; + + swapchain->refcount = 1; + swapchain->IDirect3DSwapChain8_iface.lpVtbl = &d3d8_swapchain_vtbl; + + wined3d_mutex_lock(); + hr = wined3d_swapchain_create(device->wined3d_device, desc, swapchain, + &d3d8_swapchain_wined3d_parent_ops, &swapchain->wined3d_swapchain); + wined3d_mutex_unlock(); + + if (FAILED(hr)) + { + WARN("Failed to create wined3d swapchain, hr %#x.\n", hr); + return hr; + } + + swapchain->parent_device = &device->IDirect3DDevice8_iface; + IDirect3DDevice8_AddRef(swapchain->parent_device); + + return D3D_OK; +} + +HRESULT d3d8_swapchain_create(struct d3d8_device *device, struct wined3d_swapchain_desc *desc, + struct d3d8_swapchain **swapchain) +{ + struct d3d8_swapchain *object; + HRESULT hr; + + if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 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); + return hr; + } + + TRACE("Created swapchain %p.\n", object); + *swapchain = object; + + return D3D_OK; +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/texture.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/texture.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/texture.c (revision 46521) @@ -0,0 +1,1299 @@ +/* + * Copyright 2005 Oliver Stieber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * 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); +} + +static inline struct d3d8_texture *impl_from_IDirect3DCubeTexture8(IDirect3DCubeTexture8 *iface) +{ + return CONTAINING_RECORD(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); +} + +static HRESULT WINAPI d3d8_texture_2d_QueryInterface(IDirect3DTexture8 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DTexture8) + || IsEqualGUID(riid, &IID_IDirect3DBaseTexture8) + || IsEqualGUID(riid, &IID_IDirect3DResource8) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DTexture8_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d8_texture_2d_AddRef(IDirect3DTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + ULONG ref = InterlockedIncrement(&texture->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, ref); + + if (ref == 1) + { + IDirect3DDevice8_AddRef(texture->parent_device); + wined3d_mutex_lock(); + wined3d_texture_incref(texture->wined3d_texture); + wined3d_mutex_unlock(); + } + + return ref; +} + +static ULONG WINAPI d3d8_texture_2d_Release(IDirect3DTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + ULONG ref = InterlockedDecrement(&texture->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, ref); + + if (!ref) + { + IDirect3DDevice8 *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. */ + IDirect3DDevice8_Release(parent_device); + } + return ref; +} + +static HRESULT WINAPI d3d8_texture_2d_GetDevice(IDirect3DTexture8 *iface, IDirect3DDevice8 **device) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = texture->parent_device; + IDirect3DDevice8_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_texture_2d_SetPrivateData(IDirect3DTexture8 *iface, + REFGUID guid, const void *data, DWORD data_size, DWORD flags) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n", + iface, debugstr_guid(guid), data, data_size, flags); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_texture_2d_GetPrivateData(IDirect3DTexture8 *iface, + REFGUID guid, void *data, DWORD *data_size) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %p.\n", + iface, debugstr_guid(guid), data, data_size); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_get_private_data(resource, guid, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_texture_2d_FreePrivateData(IDirect3DTexture8 *iface, REFGUID guid) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid)); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_free_private_data(resource, guid); + wined3d_mutex_unlock(); + + return hr; +} + +static DWORD WINAPI d3d8_texture_2d_SetPriority(IDirect3DTexture8 *iface, DWORD priority) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + DWORD ret; + + TRACE("iface %p, priority %u.\n", iface, priority); + + wined3d_mutex_lock(); + ret = wined3d_texture_set_priority(texture->wined3d_texture, priority); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d8_texture_2d_GetPriority(IDirect3DTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_priority(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +static void WINAPI d3d8_texture_2d_PreLoad(IDirect3DTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_texture_preload(texture->wined3d_texture); + wined3d_mutex_unlock(); +} + +static D3DRESOURCETYPE WINAPI d3d8_texture_2d_GetType(IDirect3DTexture8 *iface) +{ + TRACE("iface %p.\n", iface); + + return D3DRTYPE_TEXTURE; +} + +static DWORD WINAPI d3d8_texture_2d_SetLOD(IDirect3DTexture8 *iface, DWORD lod) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + DWORD ret; + + TRACE("iface %p, lod %u.\n", iface, lod); + + wined3d_mutex_lock(); + ret = wined3d_texture_set_lod(texture->wined3d_texture, lod); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d8_texture_2d_GetLOD(IDirect3DTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_lod(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d8_texture_2d_GetLevelCount(IDirect3DTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_level_count(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +static HRESULT WINAPI d3d8_texture_2d_GetLevelDesc(IDirect3DTexture8 *iface, UINT level, D3DSURFACE_DESC *desc) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + struct wined3d_resource *sub_resource; + HRESULT hr = D3D_OK; + + TRACE("iface %p, level %u, desc %p.\n", iface, level, desc); + + wined3d_mutex_lock(); + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + hr = D3DERR_INVALIDCALL; + else + { + struct wined3d_resource_desc wined3d_desc; + + wined3d_resource_get_desc(sub_resource, &wined3d_desc); + desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); + desc->Type = wined3d_desc.resource_type; + desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; + desc->Pool = wined3d_desc.pool; + desc->Size = wined3d_desc.size; + desc->MultiSampleType = wined3d_desc.multisample_type; + desc->Width = wined3d_desc.width; + desc->Height = wined3d_desc.height; + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_texture_2d_GetSurfaceLevel(IDirect3DTexture8 *iface, + UINT level, IDirect3DSurface8 **surface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + struct wined3d_resource *sub_resource; + struct d3d8_surface *surface_impl; + + TRACE("iface %p, level %u, surface %p.\n", iface, level, surface); + + wined3d_mutex_lock(); + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + { + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + + surface_impl = wined3d_resource_get_parent(sub_resource); + *surface = &surface_impl->IDirect3DSurface8_iface; + IDirect3DSurface8_AddRef(*surface); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_texture_2d_LockRect(IDirect3DTexture8 *iface, UINT level, + D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + struct wined3d_resource *sub_resource; + struct d3d8_surface *surface_impl; + HRESULT hr; + + TRACE("iface %p, level %u, locked_rect %p, rect %p, flags %#x.\n", + iface, level, locked_rect, rect, flags); + + wined3d_mutex_lock(); + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + hr = D3DERR_INVALIDCALL; + else + { + surface_impl = wined3d_resource_get_parent(sub_resource); + hr = IDirect3DSurface8_LockRect(&surface_impl->IDirect3DSurface8_iface, locked_rect, rect, flags); + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_texture_2d_UnlockRect(IDirect3DTexture8 *iface, UINT level) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + struct wined3d_resource *sub_resource; + struct d3d8_surface *surface_impl; + HRESULT hr; + + TRACE("iface %p, level %u.\n", iface, level); + + wined3d_mutex_lock(); + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + hr = D3DERR_INVALIDCALL; + else + { + surface_impl = wined3d_resource_get_parent(sub_resource); + hr = IDirect3DSurface8_UnlockRect(&surface_impl->IDirect3DSurface8_iface); + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_texture_2d_AddDirtyRect(IDirect3DTexture8 *iface, const RECT *dirty_rect) +{ + struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); + HRESULT hr; + + TRACE("iface %p, dirty_rect %s.\n", + iface, wine_dbgstr_rect(dirty_rect)); + + wined3d_mutex_lock(); + if (!dirty_rect) + hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, NULL); + else + { + struct wined3d_box dirty_region; + + dirty_region.left = dirty_rect->left; + dirty_region.top = dirty_rect->top; + dirty_region.right = dirty_rect->right; + dirty_region.bottom = dirty_rect->bottom; + dirty_region.front = 0; + dirty_region.back = 1; + hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, &dirty_region); + } + wined3d_mutex_unlock(); + + return hr; +} + +static const IDirect3DTexture8Vtbl Direct3DTexture8_Vtbl = +{ + /* IUnknown */ + d3d8_texture_2d_QueryInterface, + d3d8_texture_2d_AddRef, + d3d8_texture_2d_Release, + /* IDirect3DResource8 */ + d3d8_texture_2d_GetDevice, + d3d8_texture_2d_SetPrivateData, + d3d8_texture_2d_GetPrivateData, + d3d8_texture_2d_FreePrivateData, + d3d8_texture_2d_SetPriority, + d3d8_texture_2d_GetPriority, + d3d8_texture_2d_PreLoad, + d3d8_texture_2d_GetType, + /* IDirect3dBaseTexture8 */ + d3d8_texture_2d_SetLOD, + d3d8_texture_2d_GetLOD, + d3d8_texture_2d_GetLevelCount, + /* IDirect3DTexture8 */ + d3d8_texture_2d_GetLevelDesc, + d3d8_texture_2d_GetSurfaceLevel, + d3d8_texture_2d_LockRect, + d3d8_texture_2d_UnlockRect, + d3d8_texture_2d_AddDirtyRect, +}; + +static HRESULT WINAPI d3d8_texture_cube_QueryInterface(IDirect3DCubeTexture8 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DCubeTexture8) + || IsEqualGUID(riid, &IID_IDirect3DBaseTexture8) + || IsEqualGUID(riid, &IID_IDirect3DResource8) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DCubeTexture8_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d8_texture_cube_AddRef(IDirect3DCubeTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + ULONG ref = InterlockedIncrement(&texture->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, ref); + + if (ref == 1) + { + IDirect3DDevice8_AddRef(texture->parent_device); + wined3d_mutex_lock(); + wined3d_texture_incref(texture->wined3d_texture); + wined3d_mutex_unlock(); + } + + return ref; +} + +static ULONG WINAPI d3d8_texture_cube_Release(IDirect3DCubeTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + ULONG ref = InterlockedDecrement(&texture->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, ref); + + if (!ref) + { + IDirect3DDevice8 *parent_device = texture->parent_device; + + TRACE("Releasing child %p.\n", texture->wined3d_texture); + + 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. */ + IDirect3DDevice8_Release(parent_device); + } + return ref; +} + +static HRESULT WINAPI d3d8_texture_cube_GetDevice(IDirect3DCubeTexture8 *iface, IDirect3DDevice8 **device) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = texture->parent_device; + IDirect3DDevice8_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_texture_cube_SetPrivateData(IDirect3DCubeTexture8 *iface, + REFGUID guid, const void *data, DWORD data_size, DWORD flags) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n", + iface, debugstr_guid(guid), data, data_size, flags); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_texture_cube_GetPrivateData(IDirect3DCubeTexture8 *iface, + REFGUID guid, void *data, DWORD *data_size) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %p.\n", + iface, debugstr_guid(guid), data, data_size); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_get_private_data(resource, guid, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_texture_cube_FreePrivateData(IDirect3DCubeTexture8 *iface, REFGUID guid) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid)); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_free_private_data(resource, guid); + wined3d_mutex_unlock(); + + return hr; +} + +static DWORD WINAPI d3d8_texture_cube_SetPriority(IDirect3DCubeTexture8 *iface, DWORD priority) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + DWORD ret; + + TRACE("iface %p, priority %u.\n", iface, priority); + + wined3d_mutex_lock(); + ret = wined3d_texture_set_priority(texture->wined3d_texture, priority); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d8_texture_cube_GetPriority(IDirect3DCubeTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_priority(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +static void WINAPI d3d8_texture_cube_PreLoad(IDirect3DCubeTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_texture_preload(texture->wined3d_texture); + wined3d_mutex_unlock(); +} + +static D3DRESOURCETYPE WINAPI d3d8_texture_cube_GetType(IDirect3DCubeTexture8 *iface) +{ + TRACE("iface %p.\n", iface); + + return D3DRTYPE_CUBETEXTURE; +} + +static DWORD WINAPI d3d8_texture_cube_SetLOD(IDirect3DCubeTexture8 *iface, DWORD lod) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + DWORD ret; + + TRACE("iface %p, lod %u.\n", iface, lod); + + wined3d_mutex_lock(); + ret = wined3d_texture_set_lod(texture->wined3d_texture, lod); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d8_texture_cube_GetLOD(IDirect3DCubeTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_lod(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d8_texture_cube_GetLevelCount(IDirect3DCubeTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_level_count(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +static HRESULT WINAPI d3d8_texture_cube_GetLevelDesc(IDirect3DCubeTexture8 *iface, UINT level, D3DSURFACE_DESC *desc) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + struct wined3d_resource *sub_resource; + HRESULT hr = D3D_OK; + + TRACE("iface %p, level %u, desc %p.\n", iface, level, desc); + + wined3d_mutex_lock(); + if (level >= wined3d_texture_get_level_count(texture->wined3d_texture)) + { + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + hr = D3DERR_INVALIDCALL; + else + { + struct wined3d_resource_desc wined3d_desc; + + wined3d_resource_get_desc(sub_resource, &wined3d_desc); + desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); + desc->Type = wined3d_desc.resource_type; + desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; + desc->Pool = wined3d_desc.pool; + desc->Size = wined3d_desc.size; + desc->MultiSampleType = wined3d_desc.multisample_type; + desc->Width = wined3d_desc.width; + desc->Height = wined3d_desc.height; + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_texture_cube_GetCubeMapSurface(IDirect3DCubeTexture8 *iface, + D3DCUBEMAP_FACES face, UINT level, IDirect3DSurface8 **surface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + struct wined3d_resource *sub_resource; + struct d3d8_surface *surface_impl; + UINT sub_resource_idx; + DWORD level_count; + + TRACE("iface %p, face %#x, level %u, surface %p.\n", iface, face, level, surface); + + wined3d_mutex_lock(); + level_count = wined3d_texture_get_level_count(texture->wined3d_texture); + if (level >= level_count) + { + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + + sub_resource_idx = level_count * face + level; + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx))) + { + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + + surface_impl = wined3d_resource_get_parent(sub_resource); + *surface = &surface_impl->IDirect3DSurface8_iface; + IDirect3DSurface8_AddRef(*surface); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_texture_cube_LockRect(IDirect3DCubeTexture8 *iface, + D3DCUBEMAP_FACES face, UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect, + DWORD flags) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + struct wined3d_resource *sub_resource; + struct d3d8_surface *surface_impl; + UINT sub_resource_idx; + HRESULT hr; + + TRACE("iface %p, face %#x, level %u, locked_rect %p, rect %p, flags %#x.\n", + iface, face, level, locked_rect, rect, flags); + + wined3d_mutex_lock(); + sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level; + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx))) + hr = D3DERR_INVALIDCALL; + else + { + surface_impl = wined3d_resource_get_parent(sub_resource); + hr = IDirect3DSurface8_LockRect(&surface_impl->IDirect3DSurface8_iface, locked_rect, rect, flags); + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_texture_cube_UnlockRect(IDirect3DCubeTexture8 *iface, + D3DCUBEMAP_FACES face, UINT level) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + struct wined3d_resource *sub_resource; + struct d3d8_surface *surface_impl; + UINT sub_resource_idx; + HRESULT hr; + + TRACE("iface %p, face %#x, level %u.\n", iface, face, level); + + wined3d_mutex_lock(); + sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level; + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx))) + hr = D3DERR_INVALIDCALL; + else + { + surface_impl = wined3d_resource_get_parent(sub_resource); + hr = IDirect3DSurface8_UnlockRect(&surface_impl->IDirect3DSurface8_iface); + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_texture_cube_AddDirtyRect(IDirect3DCubeTexture8 *iface, + D3DCUBEMAP_FACES face, const RECT *dirty_rect) +{ + struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface); + HRESULT hr; + + TRACE("iface %p, face %#x, dirty_rect %s.\n", + iface, face, wine_dbgstr_rect(dirty_rect)); + + wined3d_mutex_lock(); + if (!dirty_rect) + hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, face, NULL); + else + { + struct wined3d_box dirty_region; + + dirty_region.left = dirty_rect->left; + dirty_region.top = dirty_rect->top; + dirty_region.right = dirty_rect->right; + dirty_region.bottom = dirty_rect->bottom; + dirty_region.front = 0; + dirty_region.back = 1; + hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, face, &dirty_region); + } + wined3d_mutex_unlock(); + + return hr; +} + +static const IDirect3DCubeTexture8Vtbl Direct3DCubeTexture8_Vtbl = +{ + /* IUnknown */ + d3d8_texture_cube_QueryInterface, + d3d8_texture_cube_AddRef, + d3d8_texture_cube_Release, + /* IDirect3DResource8 */ + d3d8_texture_cube_GetDevice, + d3d8_texture_cube_SetPrivateData, + d3d8_texture_cube_GetPrivateData, + d3d8_texture_cube_FreePrivateData, + d3d8_texture_cube_SetPriority, + d3d8_texture_cube_GetPriority, + d3d8_texture_cube_PreLoad, + d3d8_texture_cube_GetType, + /* IDirect3DBaseTexture8 */ + d3d8_texture_cube_SetLOD, + d3d8_texture_cube_GetLOD, + d3d8_texture_cube_GetLevelCount, + /* IDirect3DCubeTexture8 */ + d3d8_texture_cube_GetLevelDesc, + d3d8_texture_cube_GetCubeMapSurface, + d3d8_texture_cube_LockRect, + d3d8_texture_cube_UnlockRect, + d3d8_texture_cube_AddDirtyRect, +}; + +static HRESULT WINAPI d3d8_texture_3d_QueryInterface(IDirect3DVolumeTexture8 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DVolumeTexture8) + || IsEqualGUID(riid, &IID_IDirect3DBaseTexture8) + || IsEqualGUID(riid, &IID_IDirect3DResource8) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DVolumeTexture8_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d8_texture_3d_AddRef(IDirect3DVolumeTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + ULONG ref = InterlockedIncrement(&texture->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, ref); + + if (ref == 1) + { + IDirect3DDevice8_AddRef(texture->parent_device); + wined3d_mutex_lock(); + wined3d_texture_incref(texture->wined3d_texture); + wined3d_mutex_unlock(); + } + + return ref; +} + +static ULONG WINAPI d3d8_texture_3d_Release(IDirect3DVolumeTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + ULONG ref = InterlockedDecrement(&texture->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, ref); + + if (!ref) + { + IDirect3DDevice8 *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. */ + IDirect3DDevice8_Release(parent_device); + } + return ref; +} + +static HRESULT WINAPI d3d8_texture_3d_GetDevice(IDirect3DVolumeTexture8 *iface, IDirect3DDevice8 **device) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = texture->parent_device; + IDirect3DDevice8_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_texture_3d_SetPrivateData(IDirect3DVolumeTexture8 *iface, + REFGUID guid, const void *data, DWORD data_size, DWORD flags) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n", + iface, debugstr_guid(guid), data, data_size, flags); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_texture_3d_GetPrivateData(IDirect3DVolumeTexture8 *iface, + REFGUID guid, void *data, DWORD *data_size) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %p.\n", + iface, debugstr_guid(guid), data, data_size); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_get_private_data(resource, guid, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_texture_3d_FreePrivateData(IDirect3DVolumeTexture8 *iface, REFGUID guid) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid)); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_free_private_data(resource, guid); + wined3d_mutex_unlock(); + + return hr; +} + +static DWORD WINAPI d3d8_texture_3d_SetPriority(IDirect3DVolumeTexture8 *iface, DWORD priority) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + DWORD ret; + + TRACE("iface %p, priority %u.\n", iface, priority); + + wined3d_mutex_lock(); + ret = wined3d_texture_set_priority(texture->wined3d_texture, priority); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d8_texture_3d_GetPriority(IDirect3DVolumeTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_priority(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +static void WINAPI d3d8_texture_3d_PreLoad(IDirect3DVolumeTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_texture_preload(texture->wined3d_texture); + wined3d_mutex_unlock(); +} + +static D3DRESOURCETYPE WINAPI d3d8_texture_3d_GetType(IDirect3DVolumeTexture8 *iface) +{ + TRACE("iface %p.\n", iface); + + return D3DRTYPE_VOLUMETEXTURE; +} + +static DWORD WINAPI d3d8_texture_3d_SetLOD(IDirect3DVolumeTexture8 *iface, DWORD lod) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + DWORD ret; + + TRACE("iface %p, lod %u.\n", iface, lod); + + wined3d_mutex_lock(); + ret = wined3d_texture_set_lod(texture->wined3d_texture, lod); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d8_texture_3d_GetLOD(IDirect3DVolumeTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_lod(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d8_texture_3d_GetLevelCount(IDirect3DVolumeTexture8 *iface) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_level_count(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +static HRESULT WINAPI d3d8_texture_3d_GetLevelDesc(IDirect3DVolumeTexture8 *iface, UINT level, D3DVOLUME_DESC *desc) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + struct wined3d_resource *sub_resource; + HRESULT hr = D3D_OK; + + TRACE("iface %p, level %u, desc %p.\n", iface, level, desc); + + wined3d_mutex_lock(); + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + hr = D3DERR_INVALIDCALL; + else + { + struct wined3d_resource_desc wined3d_desc; + + wined3d_resource_get_desc(sub_resource, &wined3d_desc); + desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); + desc->Type = wined3d_desc.resource_type; + desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; + desc->Pool = wined3d_desc.pool; + desc->Size = wined3d_desc.size; + desc->Width = wined3d_desc.width; + desc->Height = wined3d_desc.height; + desc->Depth = wined3d_desc.depth; + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_texture_3d_GetVolumeLevel(IDirect3DVolumeTexture8 *iface, + UINT level, IDirect3DVolume8 **volume) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + struct wined3d_resource *sub_resource; + struct d3d8_volume *volume_impl; + + TRACE("iface %p, level %u, volume %p.\n", iface, level, volume); + + wined3d_mutex_lock(); + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + { + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + + volume_impl = wined3d_resource_get_parent(sub_resource); + *volume = &volume_impl->IDirect3DVolume8_iface; + IDirect3DVolume8_AddRef(*volume); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_texture_3d_LockBox(IDirect3DVolumeTexture8 *iface, + UINT level, D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + struct wined3d_resource *sub_resource; + struct d3d8_volume *volume_impl; + HRESULT hr; + + TRACE("iface %p, level %u, locked_box %p, box %p, flags %#x.\n", + iface, level, locked_box, box, flags); + + wined3d_mutex_lock(); + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + hr = D3DERR_INVALIDCALL; + else + { + volume_impl = wined3d_resource_get_parent(sub_resource); + hr = IDirect3DVolume8_LockBox(&volume_impl->IDirect3DVolume8_iface, locked_box, box, flags); + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_texture_3d_UnlockBox(IDirect3DVolumeTexture8 *iface, UINT level) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + struct wined3d_resource *sub_resource; + struct d3d8_volume *volume_impl; + HRESULT hr; + + TRACE("iface %p, level %u.\n", iface, level); + + wined3d_mutex_lock(); + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + hr = D3DERR_INVALIDCALL; + else + { + volume_impl = wined3d_resource_get_parent(sub_resource); + hr = IDirect3DVolume8_UnlockBox(&volume_impl->IDirect3DVolume8_iface); + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_texture_3d_AddDirtyBox(IDirect3DVolumeTexture8 *iface, const D3DBOX *dirty_box) +{ + struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); + HRESULT hr; + + TRACE("iface %p, dirty_box %p.\n", iface, dirty_box); + + wined3d_mutex_lock(); + hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, (const struct wined3d_box *)dirty_box); + wined3d_mutex_unlock(); + + return hr; +} + +static const IDirect3DVolumeTexture8Vtbl Direct3DVolumeTexture8_Vtbl = +{ + /* IUnknown */ + d3d8_texture_3d_QueryInterface, + d3d8_texture_3d_AddRef, + d3d8_texture_3d_Release, + /* IDirect3DResource8 */ + d3d8_texture_3d_GetDevice, + d3d8_texture_3d_SetPrivateData, + d3d8_texture_3d_GetPrivateData, + d3d8_texture_3d_FreePrivateData, + d3d8_texture_3d_SetPriority, + d3d8_texture_3d_GetPriority, + d3d8_texture_3d_PreLoad, + d3d8_texture_3d_GetType, + /* IDirect3DBaseTexture8 */ + d3d8_texture_3d_SetLOD, + d3d8_texture_3d_GetLOD, + d3d8_texture_3d_GetLevelCount, + /* IDirect3DVolumeTexture8 */ + d3d8_texture_3d_GetLevelDesc, + d3d8_texture_3d_GetVolumeLevel, + d3d8_texture_3d_LockBox, + d3d8_texture_3d_UnlockBox, + d3d8_texture_3d_AddDirtyBox +}; + +struct d3d8_texture *unsafe_impl_from_IDirect3DBaseTexture8(IDirect3DBaseTexture8 *iface) +{ + if (!iface) + return NULL; + + /* SetTexture() in particular doesn't do a lot of validation on the pointer + * that gets passed in, and passing an invalid pointer works as long as the + * application doesn't try to actually render anything with it, so we print + * a WARN and return NULL instead of having the usual assert() here. + * One application affected by this is Fishdom 2. */ + if (iface->lpVtbl != (const IDirect3DBaseTexture8Vtbl *)&Direct3DTexture8_Vtbl + && iface->lpVtbl != (const IDirect3DBaseTexture8Vtbl *)&Direct3DCubeTexture8_Vtbl + && iface->lpVtbl != (const IDirect3DBaseTexture8Vtbl *)&Direct3DVolumeTexture8_Vtbl) + { + WARN("%p is not a valid IDirect3DBaseTexture8 interface.\n", iface); + return NULL; + } + + return CONTAINING_RECORD(iface, struct d3d8_texture, IDirect3DBaseTexture8_iface); +} + +static void STDMETHODCALLTYPE d3d8_texture_wined3d_object_destroyed(void *parent) +{ + HeapFree(GetProcessHeap(), 0, parent); +} + +static const struct wined3d_parent_ops d3d8_texture_wined3d_parent_ops = +{ + d3d8_texture_wined3d_object_destroyed, +}; + +HRESULT texture_init(struct d3d8_texture *texture, struct d3d8_device *device, + UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool) +{ + struct wined3d_resource_desc desc; + DWORD surface_flags = 0; + HRESULT hr; + + texture->IDirect3DBaseTexture8_iface.lpVtbl = (const IDirect3DBaseTexture8Vtbl *)&Direct3DTexture8_Vtbl; + texture->refcount = 1; + + desc.resource_type = WINED3D_RTYPE_TEXTURE; + desc.format = wined3dformat_from_d3dformat(format); + desc.multisample_type = WINED3D_MULTISAMPLE_NONE; + desc.multisample_quality = 0; + desc.usage = usage & WINED3DUSAGE_MASK; + desc.pool = pool; + desc.width = width; + desc.height = height; + desc.depth = 1; + desc.size = 0; + + if (pool != D3DPOOL_DEFAULT || (usage & D3DUSAGE_DYNAMIC)) + surface_flags |= WINED3D_SURFACE_MAPPABLE; + + wined3d_mutex_lock(); + hr = wined3d_texture_create_2d(device->wined3d_device, &desc, levels, surface_flags, + texture, &d3d8_texture_wined3d_parent_ops, &texture->wined3d_texture); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d texture, hr %#x.\n", hr); + return hr; + } + + texture->parent_device = &device->IDirect3DDevice8_iface; + IDirect3DDevice8_AddRef(texture->parent_device); + + return D3D_OK; +} + +HRESULT cubetexture_init(struct d3d8_texture *texture, struct d3d8_device *device, + UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool) +{ + struct wined3d_resource_desc desc; + DWORD surface_flags = 0; + HRESULT hr; + + texture->IDirect3DBaseTexture8_iface.lpVtbl = (const IDirect3DBaseTexture8Vtbl *)&Direct3DCubeTexture8_Vtbl; + texture->refcount = 1; + + desc.resource_type = WINED3D_RTYPE_CUBE_TEXTURE; + desc.format = wined3dformat_from_d3dformat(format); + desc.multisample_type = WINED3D_MULTISAMPLE_NONE; + desc.multisample_quality = 0; + desc.usage = usage & WINED3DUSAGE_MASK; + desc.pool = pool; + desc.width = edge_length; + desc.height = edge_length; + desc.depth = 1; + desc.size = 0; + + if (pool != D3DPOOL_DEFAULT || (usage & D3DUSAGE_DYNAMIC)) + surface_flags |= WINED3D_SURFACE_MAPPABLE; + + wined3d_mutex_lock(); + hr = wined3d_texture_create_cube(device->wined3d_device, &desc, levels, surface_flags, + texture, &d3d8_texture_wined3d_parent_ops, &texture->wined3d_texture); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d cube texture, hr %#x.\n", hr); + return hr; + } + + texture->parent_device = &device->IDirect3DDevice8_iface; + IDirect3DDevice8_AddRef(texture->parent_device); + + return D3D_OK; +} + +HRESULT volumetexture_init(struct d3d8_texture *texture, struct d3d8_device *device, + UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool) +{ + struct wined3d_resource_desc desc; + HRESULT hr; + + texture->IDirect3DBaseTexture8_iface.lpVtbl = (const IDirect3DBaseTexture8Vtbl *)&Direct3DVolumeTexture8_Vtbl; + texture->refcount = 1; + + desc.resource_type = WINED3D_RTYPE_VOLUME_TEXTURE; + desc.format = wined3dformat_from_d3dformat(format); + desc.multisample_type = WINED3D_MULTISAMPLE_NONE; + desc.multisample_quality = 0; + desc.usage = usage & WINED3DUSAGE_MASK; + desc.pool = pool; + desc.width = width; + desc.height = height; + desc.depth = depth; + desc.size = 0; + + wined3d_mutex_lock(); + hr = wined3d_texture_create_3d(device->wined3d_device, &desc, levels, + texture, &d3d8_texture_wined3d_parent_ops, &texture->wined3d_texture); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d volume texture, hr %#x.\n", hr); + return hr; + } + + texture->parent_device = &device->IDirect3DDevice8_iface; + IDirect3DDevice8_AddRef(texture->parent_device); + + return D3D_OK; +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/version.rc =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/version.rc (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/version.rc (revision 46521) @@ -0,0 +1,26 @@ +/* + * Copyright 2001 Ove Kaaven + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#define WINE_FILEDESCRIPTION_STR "Wine Direct3D" +#define WINE_FILENAME_STR "d3d8.dll" +#define WINE_FILEVERSION 5,3,1,904 +#define WINE_FILEVERSION_STR "5.3.1.904" +#define WINE_PRODUCTVERSION 5,3,1,904 +#define WINE_PRODUCTVERSION_STR "5.3.1.904" + +#include "wine/wine_common_ver.rc" Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/vertexdeclaration.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/vertexdeclaration.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/vertexdeclaration.c (revision 46521) @@ -0,0 +1,391 @@ +/* + * IDirect3DVertexDeclaration8 implementation + * + * Copyright 2007 Henri Verbeet + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +/* 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); + +#ifdef VBOX_WINE_WITHOUT_LIBWINE +typedef DWORD D3DVSDT_TYPE; +typedef DWORD D3DVSDE_REGISTER; +#endif + +static const char *debug_d3dvsdt_type(D3DVSDT_TYPE d3dvsdt_type) +{ + switch (d3dvsdt_type) + { +#define D3DVSDT_TYPE_TO_STR(u) case u: return #u + D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT1); + D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT2); + D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT3); + D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT4); + D3DVSDT_TYPE_TO_STR(D3DVSDT_D3DCOLOR); + D3DVSDT_TYPE_TO_STR(D3DVSDT_UBYTE4); + D3DVSDT_TYPE_TO_STR(D3DVSDT_SHORT2); + D3DVSDT_TYPE_TO_STR(D3DVSDT_SHORT4); +#undef D3DVSDT_TYPE_TO_STR + default: + FIXME("Unrecognized D3DVSDT_TYPE %#x\n", d3dvsdt_type); + return "unrecognized"; + } +} + +static const char *debug_d3dvsde_register(D3DVSDE_REGISTER d3dvsde_register) +{ + switch (d3dvsde_register) + { +#define D3DVSDE_REGISTER_TO_STR(u) case u: return #u + D3DVSDE_REGISTER_TO_STR(D3DVSDE_POSITION); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_BLENDWEIGHT); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_BLENDINDICES); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_NORMAL); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_PSIZE); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_DIFFUSE); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_SPECULAR); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD0); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD1); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD2); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD3); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD4); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD5); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD6); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD7); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_POSITION2); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_NORMAL2); +#undef D3DVSDE_REGISTER_TO_STR + default: + FIXME("Unrecognized D3DVSDE_REGISTER %#x\n", d3dvsde_register); + return "unrecognized"; + } +} + +size_t parse_token(const DWORD* pToken) +{ + const DWORD token = *pToken; + size_t tokenlen = 1; + + switch ((token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) { /* maybe a macro to inverse ... */ + case D3DVSD_TOKEN_NOP: + TRACE(" 0x%08x NOP()\n", token); + break; + + case D3DVSD_TOKEN_STREAM: + if (token & D3DVSD_STREAMTESSMASK) + { + TRACE(" 0x%08x STREAM_TESS()\n", token); + } else { + TRACE(" 0x%08x STREAM(%u)\n", token, ((token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT)); + } + break; + + case D3DVSD_TOKEN_STREAMDATA: + if (token & 0x10000000) + { + TRACE(" 0x%08x SKIP(%u)\n", token, ((token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT)); + } else { + DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT); + DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT); + TRACE(" 0x%08x REG(%s, %s)\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type)); + } + break; + + case D3DVSD_TOKEN_TESSELLATOR: + if (token & 0x10000000) + { + DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT); + DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT); + TRACE(" 0x%08x TESSUV(%s) as %s\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type)); + } else { + DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT); + DWORD regout = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT); + DWORD regin = ((token & D3DVSD_VERTEXREGINMASK) >> D3DVSD_VERTEXREGINSHIFT); + TRACE(" 0x%08x TESSNORMAL(%s, %s) as %s\n", token, debug_d3dvsde_register(regin), + debug_d3dvsde_register(regout), debug_d3dvsdt_type(type)); + } + break; + + case D3DVSD_TOKEN_CONSTMEM: + { + DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT); + tokenlen = (4 * count) + 1; + } + break; + + case D3DVSD_TOKEN_EXT: + { + DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT); + DWORD extinfo = ((token & D3DVSD_EXTINFOMASK) >> D3DVSD_EXTINFOSHIFT); + TRACE(" 0x%08x EXT(%u, %u)\n", token, count, extinfo); + /* todo ... print extension */ + tokenlen = count + 1; + } + break; + + case D3DVSD_TOKEN_END: + TRACE(" 0x%08x END()\n", token); + break; + + default: + TRACE(" 0x%08x UNKNOWN\n", token); + /* arg error */ + } + + return tokenlen; +} + +void load_local_constants(const DWORD *d3d8_elements, struct wined3d_shader *wined3d_vertex_shader) +{ + const DWORD *token = d3d8_elements; + + while (*token != D3DVSD_END()) + { + if (((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) == D3DVSD_TOKEN_CONSTMEM) + { + DWORD count = ((*token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT); + DWORD constant_idx = ((*token & D3DVSD_CONSTADDRESSMASK) >> D3DVSD_CONSTADDRESSSHIFT); + HRESULT hr; + + if (TRACE_ON(d3d8)) + { + DWORD i; + for (i = 0; i < count; ++i) + { + TRACE("c[%u] = (%8f, %8f, %8f, %8f)\n", + constant_idx, + *(const float *)(token + i * 4 + 1), + *(const float *)(token + i * 4 + 2), + *(const float *)(token + i * 4 + 3), + *(const float *)(token + i * 4 + 4)); + } + } + hr = wined3d_shader_set_local_constants_float(wined3d_vertex_shader, + constant_idx, (const float *)token + 1, count); + if (FAILED(hr)) ERR("Failed setting shader constants\n"); + } + + token += parse_token(token); + } +} + +/* NOTE: Make sure these are in the correct numerical order. (see /include/wined3d_types.h) */ +static const size_t wined3d_type_sizes[] = +{ + /*WINED3DDECLTYPE_FLOAT1*/ 1 * sizeof(float), + /*WINED3DDECLTYPE_FLOAT2*/ 2 * sizeof(float), + /*WINED3DDECLTYPE_FLOAT3*/ 3 * sizeof(float), + /*WINED3DDECLTYPE_FLOAT4*/ 4 * sizeof(float), + /*WINED3DDECLTYPE_D3DCOLOR*/ 4 * sizeof(BYTE), + /*WINED3DDECLTYPE_UBYTE4*/ 4 * sizeof(BYTE), + /*WINED3DDECLTYPE_SHORT2*/ 2 * sizeof(short int), + /*WINED3DDECLTYPE_SHORT4*/ 4 * sizeof(short int), + /*WINED3DDECLTYPE_UBYTE4N*/ 4 * sizeof(BYTE), + /*WINED3DDECLTYPE_SHORT2N*/ 2 * sizeof(short int), + /*WINED3DDECLTYPE_SHORT4N*/ 4 * sizeof(short int), + /*WINED3DDECLTYPE_USHORT2N*/ 2 * sizeof(short int), + /*WINED3DDECLTYPE_USHORT4N*/ 4 * sizeof(short int), + /*WINED3DDECLTYPE_UDEC3*/ 3 * sizeof(short int), + /*WINED3DDECLTYPE_DEC3N*/ 3 * sizeof(short int), + /*WINED3DDECLTYPE_FLOAT16_2*/ 2 * sizeof(short int), + /*WINED3DDECLTYPE_FLOAT16_4*/ 4 * sizeof(short int) +}; + +static const enum wined3d_format_id wined3d_format_lookup[] = +{ + /*WINED3DDECLTYPE_FLOAT1*/ WINED3DFMT_R32_FLOAT, + /*WINED3DDECLTYPE_FLOAT2*/ WINED3DFMT_R32G32_FLOAT, + /*WINED3DDECLTYPE_FLOAT3*/ WINED3DFMT_R32G32B32_FLOAT, + /*WINED3DDECLTYPE_FLOAT4*/ WINED3DFMT_R32G32B32A32_FLOAT, + /*WINED3DDECLTYPE_D3DCOLOR*/ WINED3DFMT_B8G8R8A8_UNORM, + /*WINED3DDECLTYPE_UBYTE4*/ WINED3DFMT_R8G8B8A8_UINT, + /*WINED3DDECLTYPE_SHORT2*/ WINED3DFMT_R16G16_SINT, + /*WINED3DDECLTYPE_SHORT4*/ WINED3DFMT_R16G16B16A16_SINT, + /*WINED3DDECLTYPE_UBYTE4N*/ WINED3DFMT_R8G8B8A8_UNORM, + /*WINED3DDECLTYPE_SHORT2N*/ WINED3DFMT_R16G16_SNORM, + /*WINED3DDECLTYPE_SHORT4N*/ WINED3DFMT_R16G16B16A16_SNORM, + /*WINED3DDECLTYPE_USHORT2N*/ WINED3DFMT_R16G16_UNORM, + /*WINED3DDECLTYPE_USHORT4N*/ WINED3DFMT_R16G16B16A16_UNORM, + /*WINED3DDECLTYPE_UDEC3*/ WINED3DFMT_R10G10B10A2_UINT, + /*WINED3DDECLTYPE_DEC3N*/ WINED3DFMT_R10G10B10A2_SNORM, + /*WINED3DDECLTYPE_FLOAT16_2*/ WINED3DFMT_R16G16_FLOAT, + /*WINED3DDECLTYPE_FLOAT16_4*/ WINED3DFMT_R16G16B16A16_FLOAT, +}; + +static const struct +{ + BYTE usage; + BYTE usage_idx; +} +wined3d_usage_lookup[] = +{ + /* D3DVSDE_POSITION */ {WINED3D_DECL_USAGE_POSITION, 0}, + /* D3DVSDE_BLENDWEIGHT */ {WINED3D_DECL_USAGE_BLEND_WEIGHT, 0}, + /* D3DVSDE_BLENDINDICES */ {WINED3D_DECL_USAGE_BLEND_INDICES, 0}, + /* D3DVSDE_NORMAL */ {WINED3D_DECL_USAGE_NORMAL, 0}, + /* D3DVSDE_PSIZE */ {WINED3D_DECL_USAGE_PSIZE, 0}, + /* D3DVSDE_DIFFUSE */ {WINED3D_DECL_USAGE_COLOR, 0}, + /* D3DVSDE_SPECULAR */ {WINED3D_DECL_USAGE_COLOR, 1}, + /* D3DVSDE_TEXCOORD0 */ {WINED3D_DECL_USAGE_TEXCOORD, 0}, + /* D3DVSDE_TEXCOORD1 */ {WINED3D_DECL_USAGE_TEXCOORD, 1}, + /* D3DVSDE_TEXCOORD2 */ {WINED3D_DECL_USAGE_TEXCOORD, 2}, + /* D3DVSDE_TEXCOORD3 */ {WINED3D_DECL_USAGE_TEXCOORD, 3}, + /* D3DVSDE_TEXCOORD4 */ {WINED3D_DECL_USAGE_TEXCOORD, 4}, + /* D3DVSDE_TEXCOORD5 */ {WINED3D_DECL_USAGE_TEXCOORD, 5}, + /* D3DVSDE_TEXCOORD6 */ {WINED3D_DECL_USAGE_TEXCOORD, 6}, + /* D3DVSDE_TEXCOORD7 */ {WINED3D_DECL_USAGE_TEXCOORD, 7}, + /* D3DVSDE_POSITION2 */ {WINED3D_DECL_USAGE_POSITION, 1}, + /* D3DVSDE_NORMAL2 */ {WINED3D_DECL_USAGE_NORMAL, 1}, +}; + +/* TODO: find out where rhw (or positionT) is for declaration8 */ +static UINT convert_to_wined3d_declaration(const DWORD *d3d8_elements, DWORD *d3d8_elements_size, + struct wined3d_vertex_element **wined3d_elements) +{ + struct wined3d_vertex_element *element; + const DWORD *token = d3d8_elements; + D3DVSD_TOKENTYPE token_type; + unsigned int element_count = 0; + WORD stream = 0; + int offset = 0; + + TRACE("d3d8_elements %p, wined3d_elements %p\n", d3d8_elements, wined3d_elements); + + /* 128 should be enough for anyone... */ + *wined3d_elements = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 128 * sizeof(**wined3d_elements)); + while (D3DVSD_END() != *token) + { + token_type = ((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT); + + if (token_type == D3DVSD_TOKEN_STREAM && !(*token & D3DVSD_STREAMTESSMASK)) + { + stream = ((*token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT); + offset = 0; + } else if (token_type == D3DVSD_TOKEN_STREAMDATA && !(token_type & 0x10000000)) { + DWORD type = ((*token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT); + DWORD reg = ((*token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT); + + TRACE("Adding element %d:\n", element_count); + + element = *wined3d_elements + element_count++; + element->format = wined3d_format_lookup[type]; + element->input_slot = stream; + element->offset = offset; + element->output_slot = reg; + element->method = WINED3D_DECL_METHOD_DEFAULT; + element->usage = wined3d_usage_lookup[reg].usage; + element->usage_idx = wined3d_usage_lookup[reg].usage_idx; + + offset += wined3d_type_sizes[type]; + } else if (token_type == D3DVSD_TOKEN_STREAMDATA && (token_type & 0x10000000)) { + TRACE(" 0x%08x SKIP(%u)\n", token_type, ((token_type & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT)); + offset += sizeof(DWORD) * ((token_type & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT); + } + + if (element_count >= 127) { + ERR("More than 127 elements?\n"); + break; + } + + token += parse_token(token); + } + + *d3d8_elements_size = (++token - d3d8_elements) * sizeof(DWORD); + + return element_count; +} + +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); +} + +void d3d8_vertex_declaration_destroy(struct d3d8_vertex_declaration *declaration) +{ + TRACE("declaration %p.\n", declaration); + + wined3d_mutex_lock(); + wined3d_vertex_declaration_decref(declaration->wined3d_vertex_declaration); + wined3d_mutex_unlock(); +} + +static const struct wined3d_parent_ops d3d8_vertexdeclaration_wined3d_parent_ops = +{ + d3d8_vertexdeclaration_wined3d_object_destroyed, +}; + +HRESULT d3d8_vertex_declaration_init(struct d3d8_vertex_declaration *declaration, + struct d3d8_device *device, const DWORD *elements, DWORD shader_handle) +{ + struct wined3d_vertex_element *wined3d_elements; + UINT wined3d_element_count; + HRESULT hr; + + 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) + { + ERR("Failed to allocate vertex declaration elements memory.\n"); + HeapFree(GetProcessHeap(), 0, wined3d_elements); + return E_OUTOFMEMORY; + } + + memcpy(declaration->elements, elements, declaration->elements_size); + + wined3d_mutex_lock(); + 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); + if (FAILED(hr)) + { + WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr); + HeapFree(GetProcessHeap(), 0, declaration->elements); + return hr; + } + + return D3D_OK; +} + +HRESULT d3d8_vertex_declaration_init_fvf(struct d3d8_vertex_declaration *declaration, + struct d3d8_device *device, DWORD fvf) +{ + HRESULT hr; + + declaration->elements = NULL; + declaration->elements_size = 0; + declaration->shader_handle = fvf; + + hr = wined3d_vertex_declaration_create_from_fvf(device->wined3d_device, fvf, declaration, + &d3d8_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_vertex_declaration); + if (FAILED(hr)) + { + WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr); + return hr; + } + + return D3D_OK; +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/volume.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/volume.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d8/volume.c (revision 46521) @@ -0,0 +1,303 @@ +/* + * IDirect3DVolume8 implementation + * + * Copyright 2005 Oliver Stieber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * 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); +} + +static HRESULT WINAPI d3d8_volume_QueryInterface(IDirect3DVolume8 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DVolume8) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DVolume8_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d8_volume_AddRef(IDirect3DVolume8 *iface) +{ + struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface); + + TRACE("iface %p.\n", iface); + + if (volume->forwardReference) + { + /* Forward to the containerParent */ + TRACE("Forwarding to %p,\n", volume->forwardReference); + return IUnknown_AddRef(volume->forwardReference); + } + else + { + /* No container, handle our own refcounting */ + ULONG ref = InterlockedIncrement(&volume->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, ref); + + if (ref == 1) + { + wined3d_mutex_lock(); + wined3d_volume_incref(volume->wined3d_volume); + wined3d_mutex_unlock(); + } + + return ref; + } +} + +static ULONG WINAPI d3d8_volume_Release(IDirect3DVolume8 *iface) +{ + struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface); + + TRACE("iface %p.\n", iface); + + if (volume->forwardReference) + { + /* Forward to the containerParent */ + TRACE("Forwarding to %p.\n", volume->forwardReference); + return IUnknown_Release(volume->forwardReference); + } + else + { + /* No container, handle our own refcounting */ + ULONG ref = InterlockedDecrement(&volume->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, ref); + + if (!ref) + { + wined3d_mutex_lock(); + wined3d_volume_decref(volume->wined3d_volume); + wined3d_mutex_unlock(); + } + + return ref; + } +} + +static HRESULT WINAPI d3d8_volume_GetDevice(IDirect3DVolume8 *iface, IDirect3DDevice8 **device) +{ + struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface); + IDirect3DResource8 *resource; + HRESULT hr; + + TRACE("iface %p, device %p.\n", iface, device); + + hr = IUnknown_QueryInterface(volume->forwardReference, &IID_IDirect3DResource8, (void **)&resource); + if (SUCCEEDED(hr)) + { + hr = IDirect3DResource8_GetDevice(resource, device); + IDirect3DResource8_Release(resource); + + TRACE("Returning device %p.\n", *device); + } + + return hr; +} + +static HRESULT WINAPI d3d8_volume_SetPrivateData(IDirect3DVolume8 *iface, REFGUID guid, + const void *data, DWORD data_size, DWORD flags) +{ + struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n", + iface, debugstr_guid(guid), data, data_size, flags); + + wined3d_mutex_lock(); + resource = wined3d_volume_get_resource(volume->wined3d_volume); + hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_volume_GetPrivateData(IDirect3DVolume8 *iface, REFGUID guid, + void *data, DWORD *data_size) +{ + struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %p.\n", + iface, debugstr_guid(guid), data, data_size); + + wined3d_mutex_lock(); + resource = wined3d_volume_get_resource(volume->wined3d_volume); + hr = wined3d_resource_get_private_data(resource, guid, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_volume_FreePrivateData(IDirect3DVolume8 *iface, REFGUID guid) +{ + struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid)); + + wined3d_mutex_lock(); + resource = wined3d_volume_get_resource(volume->wined3d_volume); + hr = wined3d_resource_free_private_data(resource, guid); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d8_volume_GetContainer(IDirect3DVolume8 *iface, REFIID riid, void **container) +{ + struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface); + HRESULT res; + + TRACE("iface %p, riid %s, container %p.\n", + iface, debugstr_guid(riid), container); + + if (!volume->container) + return E_NOINTERFACE; + + res = IUnknown_QueryInterface(volume->container, riid, container); + + TRACE("Returning %p.\n", *container); + + return res; +} + +static HRESULT WINAPI d3d8_volume_GetDesc(IDirect3DVolume8 *iface, D3DVOLUME_DESC *desc) +{ + struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface); + struct wined3d_resource_desc wined3d_desc; + struct wined3d_resource *wined3d_resource; + + TRACE("iface %p, desc %p.\n", iface, desc); + + wined3d_mutex_lock(); + wined3d_resource = wined3d_volume_get_resource(volume->wined3d_volume); + wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); + wined3d_mutex_unlock(); + + desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); + desc->Type = wined3d_desc.resource_type; + desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; + desc->Pool = wined3d_desc.pool; + desc->Size = wined3d_desc.size; + desc->Width = wined3d_desc.width; + desc->Height = wined3d_desc.height; + desc->Depth = wined3d_desc.depth; + + return D3D_OK; +} + +static HRESULT WINAPI d3d8_volume_LockBox(IDirect3DVolume8 *iface, + D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags) +{ + struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface); + struct wined3d_map_desc map_desc; + HRESULT hr; + + TRACE("iface %p, locked_box %p, box %p, flags %#x.\n", + iface, locked_box, box, flags); + + wined3d_mutex_lock(); + hr = wined3d_volume_map(volume->wined3d_volume, &map_desc, (const struct wined3d_box *)box, flags); + wined3d_mutex_unlock(); + + locked_box->RowPitch = map_desc.row_pitch; + locked_box->SlicePitch = map_desc.slice_pitch; + locked_box->pBits = map_desc.data; + + return hr; +} + +static HRESULT WINAPI d3d8_volume_UnlockBox(IDirect3DVolume8 *iface) +{ + struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface); + HRESULT hr; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + hr = wined3d_volume_unmap(volume->wined3d_volume); + wined3d_mutex_unlock(); + + return hr; +} + +static const IDirect3DVolume8Vtbl d3d8_volume_vtbl = +{ + /* IUnknown */ + d3d8_volume_QueryInterface, + d3d8_volume_AddRef, + d3d8_volume_Release, + /* IDirect3DVolume8 */ + d3d8_volume_GetDevice, + d3d8_volume_SetPrivateData, + d3d8_volume_GetPrivateData, + d3d8_volume_FreePrivateData, + d3d8_volume_GetContainer, + d3d8_volume_GetDesc, + d3d8_volume_LockBox, + d3d8_volume_UnlockBox, +}; + +static void STDMETHODCALLTYPE volume_wined3d_object_destroyed(void *parent) +{ + HeapFree(GetProcessHeap(), 0, parent); +} + +static const struct wined3d_parent_ops d3d8_volume_wined3d_parent_ops = +{ + volume_wined3d_object_destroyed, +}; + +HRESULT volume_init(struct d3d8_volume *volume, struct d3d8_device *device, UINT width, UINT height, + UINT depth, DWORD usage, enum wined3d_format_id format, enum wined3d_pool pool) +{ + HRESULT hr; + + volume->IDirect3DVolume8_iface.lpVtbl = &d3d8_volume_vtbl; + volume->refcount = 1; + + hr = wined3d_volume_create(device->wined3d_device, width, height, depth, usage, + format, pool, volume, &d3d8_volume_wined3d_parent_ops, &volume->wined3d_volume); + if (FAILED(hr)) + { + WARN("Failed to create wined3d volume, hr %#x.\n", hr); + return hr; + } + + return D3D_OK; +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/buffer.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/buffer.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/buffer.c (revision 46521) @@ -0,0 +1,610 @@ +/* + * Copyright 2002-2004 Jason Edmeades + * Copyright 2002-2004 Raphael Junqueira + * Copyright 2005 Oliver Stieber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * 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); +} + +static HRESULT WINAPI d3d9_vertexbuffer_QueryInterface(IDirect3DVertexBuffer9 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DVertexBuffer9) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DVertexBuffer9_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d9_vertexbuffer_AddRef(IDirect3DVertexBuffer9 *iface) +{ + struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface); + ULONG refcount = InterlockedIncrement(&buffer->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, refcount); + + if (refcount == 1) + { + IDirect3DDevice9Ex_AddRef(buffer->parent_device); + wined3d_mutex_lock(); + wined3d_buffer_incref(buffer->wined3d_buffer); + wined3d_mutex_unlock(); + } + + return refcount; +} + +static ULONG WINAPI d3d9_vertexbuffer_Release(IDirect3DVertexBuffer9 *iface) +{ + struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface); + ULONG refcount = InterlockedDecrement(&buffer->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, refcount); + + if (!refcount) + { + IDirect3DDevice9Ex *device = buffer->parent_device; + + wined3d_mutex_lock(); + wined3d_buffer_decref(buffer->wined3d_buffer); + wined3d_mutex_unlock(); + + /* Release the device last, as it may cause the device to be destroyed. */ + IDirect3DDevice9Ex_Release(device); + } + + return refcount; +} + +static HRESULT WINAPI d3d9_vertexbuffer_GetDevice(IDirect3DVertexBuffer9 *iface, IDirect3DDevice9 **device) +{ + struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = (IDirect3DDevice9 *)buffer->parent_device; + IDirect3DDevice9_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_vertexbuffer_SetPrivateData(IDirect3DVertexBuffer9 *iface, + REFGUID guid, const void *data, DWORD data_size, DWORD flags) +{ + struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n", + iface, debugstr_guid(guid), data, data_size, flags); + + wined3d_mutex_lock(); + resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); + hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_vertexbuffer_GetPrivateData(IDirect3DVertexBuffer9 *iface, + REFGUID guid, void *data, DWORD *data_size) +{ + struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %p.\n", + iface, debugstr_guid(guid), data, data_size); + + wined3d_mutex_lock(); + resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); + hr = wined3d_resource_get_private_data(resource, guid, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_vertexbuffer_FreePrivateData(IDirect3DVertexBuffer9 *iface, REFGUID guid) +{ + struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid)); + + wined3d_mutex_lock(); + resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); + hr = wined3d_resource_free_private_data(resource, guid); + wined3d_mutex_unlock(); + + return hr; +} + +static DWORD WINAPI d3d9_vertexbuffer_SetPriority(IDirect3DVertexBuffer9 *iface, DWORD priority) +{ + struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface); + DWORD previous; + + TRACE("iface %p, priority %u.\n", iface, priority); + + wined3d_mutex_lock(); + previous = wined3d_buffer_set_priority(buffer->wined3d_buffer, priority); + wined3d_mutex_unlock(); + + return previous; +} + +static DWORD WINAPI d3d9_vertexbuffer_GetPriority(IDirect3DVertexBuffer9 *iface) +{ + struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface); + DWORD priority; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + priority = wined3d_buffer_get_priority(buffer->wined3d_buffer); + wined3d_mutex_unlock(); + + return priority; +} + +static void WINAPI d3d9_vertexbuffer_PreLoad(IDirect3DVertexBuffer9 *iface) +{ + struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_buffer_preload(buffer->wined3d_buffer); + wined3d_mutex_unlock(); +} + +static D3DRESOURCETYPE WINAPI d3d9_vertexbuffer_GetType(IDirect3DVertexBuffer9 *iface) +{ + TRACE("iface %p.\n", iface); + + return D3DRTYPE_VERTEXBUFFER; +} + +static HRESULT WINAPI d3d9_vertexbuffer_Lock(IDirect3DVertexBuffer9 *iface, UINT offset, UINT size, + void **data, DWORD flags) +{ + struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface); + HRESULT hr; + + TRACE("iface %p, offset %u, size %u, data %p, flags %#x.\n", + iface, offset, size, data, flags); + + wined3d_mutex_lock(); + hr = wined3d_buffer_map(buffer->wined3d_buffer, offset, size, (BYTE **)data, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_vertexbuffer_Unlock(IDirect3DVertexBuffer9 *iface) +{ + struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_buffer_unmap(buffer->wined3d_buffer); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_vertexbuffer_GetDesc(IDirect3DVertexBuffer9 *iface, + D3DVERTEXBUFFER_DESC *desc) +{ + struct d3d9_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer9(iface); + struct wined3d_resource_desc wined3d_desc; + struct wined3d_resource *wined3d_resource; + + TRACE("iface %p, desc %p.\n", iface, desc); + + wined3d_mutex_lock(); + wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); + wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); + 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->FVF = buffer->fvf; + + return D3D_OK; +} + +static const IDirect3DVertexBuffer9Vtbl d3d9_vertexbuffer_vtbl = +{ + /* IUnknown */ + d3d9_vertexbuffer_QueryInterface, + d3d9_vertexbuffer_AddRef, + d3d9_vertexbuffer_Release, + /* IDirect3DResource9 */ + d3d9_vertexbuffer_GetDevice, + d3d9_vertexbuffer_SetPrivateData, + d3d9_vertexbuffer_GetPrivateData, + d3d9_vertexbuffer_FreePrivateData, + d3d9_vertexbuffer_SetPriority, + d3d9_vertexbuffer_GetPriority, + d3d9_vertexbuffer_PreLoad, + d3d9_vertexbuffer_GetType, + /* IDirect3DVertexBuffer9 */ + d3d9_vertexbuffer_Lock, + d3d9_vertexbuffer_Unlock, + d3d9_vertexbuffer_GetDesc, +}; + +static void STDMETHODCALLTYPE d3d9_vertexbuffer_wined3d_object_destroyed(void *parent) +{ + HeapFree(GetProcessHeap(), 0, parent); +} + +static const struct wined3d_parent_ops d3d9_vertexbuffer_wined3d_parent_ops = +{ + d3d9_vertexbuffer_wined3d_object_destroyed, +}; + +HRESULT vertexbuffer_init(struct d3d9_vertexbuffer *buffer, struct d3d9_device *device, + UINT size, UINT usage, DWORD fvf, D3DPOOL pool) +{ + HRESULT hr; + + buffer->IDirect3DVertexBuffer9_iface.lpVtbl = &d3d9_vertexbuffer_vtbl; + buffer->refcount = 1; + buffer->fvf = fvf; + + 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); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d buffer, hr %#x.\n", hr); + return hr; + } + + buffer->parent_device = &device->IDirect3DDevice9Ex_iface; + IDirect3DDevice9Ex_AddRef(buffer->parent_device); + + return D3D_OK; +} + +struct d3d9_vertexbuffer *unsafe_impl_from_IDirect3DVertexBuffer9(IDirect3DVertexBuffer9 *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == &d3d9_vertexbuffer_vtbl); + + return impl_from_IDirect3DVertexBuffer9(iface); +} + +static inline struct d3d9_indexbuffer *impl_from_IDirect3DIndexBuffer9(IDirect3DIndexBuffer9 *iface) +{ + return CONTAINING_RECORD(iface, struct d3d9_indexbuffer, IDirect3DIndexBuffer9_iface); +} + +static HRESULT WINAPI d3d9_indexbuffer_QueryInterface(IDirect3DIndexBuffer9 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DIndexBuffer9) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DIndexBuffer9_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d9_indexbuffer_AddRef(IDirect3DIndexBuffer9 *iface) +{ + struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(iface); + ULONG refcount = InterlockedIncrement(&buffer->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, refcount); + + if (refcount == 1) + { + IDirect3DDevice9Ex_AddRef(buffer->parent_device); + wined3d_mutex_lock(); + wined3d_buffer_incref(buffer->wined3d_buffer); + wined3d_mutex_unlock(); + } + + return refcount; +} + +static ULONG WINAPI d3d9_indexbuffer_Release(IDirect3DIndexBuffer9 *iface) +{ + struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(iface); + ULONG refcount = InterlockedDecrement(&buffer->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, refcount); + + if (!refcount) + { + IDirect3DDevice9Ex *device = buffer->parent_device; + + wined3d_mutex_lock(); + wined3d_buffer_decref(buffer->wined3d_buffer); + wined3d_mutex_unlock(); + + /* Release the device last, as it may cause the device to be destroyed. */ + IDirect3DDevice9Ex_Release(device); + } + + return refcount; +} + +static HRESULT WINAPI d3d9_indexbuffer_GetDevice(IDirect3DIndexBuffer9 *iface, IDirect3DDevice9 **device) +{ + struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = (IDirect3DDevice9 *)buffer->parent_device; + IDirect3DDevice9_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_indexbuffer_SetPrivateData(IDirect3DIndexBuffer9 *iface, + REFGUID guid, const void *data, DWORD data_size, DWORD flags) +{ + struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n", + iface, debugstr_guid(guid), data, data_size, flags); + + wined3d_mutex_lock(); + resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); + hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_indexbuffer_GetPrivateData(IDirect3DIndexBuffer9 *iface, + REFGUID guid, void *data, DWORD *data_size) +{ + struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %p.\n", + iface, debugstr_guid(guid), data, data_size); + + wined3d_mutex_lock(); + resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); + hr = wined3d_resource_get_private_data(resource, guid, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_indexbuffer_FreePrivateData(IDirect3DIndexBuffer9 *iface, REFGUID guid) +{ + struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid)); + + wined3d_mutex_lock(); + resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); + hr = wined3d_resource_free_private_data(resource, guid); + wined3d_mutex_unlock(); + + return hr; +} + +static DWORD WINAPI d3d9_indexbuffer_SetPriority(IDirect3DIndexBuffer9 *iface, DWORD priority) +{ + struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(iface); + DWORD previous; + + TRACE("iface %p, priority %u.\n", iface, priority); + + wined3d_mutex_lock(); + previous = wined3d_buffer_set_priority(buffer->wined3d_buffer, priority); + wined3d_mutex_unlock(); + + return previous; +} + +static DWORD WINAPI d3d9_indexbuffer_GetPriority(IDirect3DIndexBuffer9 *iface) +{ + struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(iface); + DWORD priority; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + priority = wined3d_buffer_get_priority(buffer->wined3d_buffer); + wined3d_mutex_unlock(); + + return priority; +} + +static void WINAPI d3d9_indexbuffer_PreLoad(IDirect3DIndexBuffer9 *iface) +{ + struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_buffer_preload(buffer->wined3d_buffer); + wined3d_mutex_unlock(); +} + +static D3DRESOURCETYPE WINAPI d3d9_indexbuffer_GetType(IDirect3DIndexBuffer9 *iface) +{ + TRACE("iface %p.\n", iface); + + return D3DRTYPE_INDEXBUFFER; +} + +static HRESULT WINAPI d3d9_indexbuffer_Lock(IDirect3DIndexBuffer9 *iface, + UINT offset, UINT size, void **data, DWORD flags) +{ + struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(iface); + HRESULT hr; + + TRACE("iface %p, offset %u, size %u, data %p, flags %#x.\n", + iface, offset, size, data, flags); + + wined3d_mutex_lock(); + hr = wined3d_buffer_map(buffer->wined3d_buffer, offset, size, (BYTE **)data, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_indexbuffer_Unlock(IDirect3DIndexBuffer9 *iface) +{ + struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_buffer_unmap(buffer->wined3d_buffer); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_indexbuffer_GetDesc(IDirect3DIndexBuffer9 *iface, D3DINDEXBUFFER_DESC *desc) +{ + struct d3d9_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer9(iface); + struct wined3d_resource_desc wined3d_desc; + struct wined3d_resource *wined3d_resource; + + TRACE("iface %p, desc %p.\n", iface, desc); + + wined3d_mutex_lock(); + wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); + wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); + 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; + + return D3D_OK; +} + +static const IDirect3DIndexBuffer9Vtbl d3d9_indexbuffer_vtbl = +{ + /* IUnknown */ + d3d9_indexbuffer_QueryInterface, + d3d9_indexbuffer_AddRef, + d3d9_indexbuffer_Release, + /* IDirect3DResource9 */ + d3d9_indexbuffer_GetDevice, + d3d9_indexbuffer_SetPrivateData, + d3d9_indexbuffer_GetPrivateData, + d3d9_indexbuffer_FreePrivateData, + d3d9_indexbuffer_SetPriority, + d3d9_indexbuffer_GetPriority, + d3d9_indexbuffer_PreLoad, + d3d9_indexbuffer_GetType, + /* IDirect3DIndexBuffer9 */ + d3d9_indexbuffer_Lock, + d3d9_indexbuffer_Unlock, + d3d9_indexbuffer_GetDesc, +}; + +static void STDMETHODCALLTYPE d3d9_indexbuffer_wined3d_object_destroyed(void *parent) +{ + HeapFree(GetProcessHeap(), 0, parent); +} + +static const struct wined3d_parent_ops d3d9_indexbuffer_wined3d_parent_ops = +{ + d3d9_indexbuffer_wined3d_object_destroyed, +}; + +HRESULT indexbuffer_init(struct d3d9_indexbuffer *buffer, struct d3d9_device *device, + UINT size, DWORD usage, D3DFORMAT format, D3DPOOL pool) +{ + HRESULT hr; + + buffer->IDirect3DIndexBuffer9_iface.lpVtbl = &d3d9_indexbuffer_vtbl; + buffer->refcount = 1; + 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, &d3d9_indexbuffer_wined3d_parent_ops, &buffer->wined3d_buffer); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d buffer, hr %#x.\n", hr); + return hr; + } + + buffer->parent_device = &device->IDirect3DDevice9Ex_iface; + IDirect3DDevice9Ex_AddRef(buffer->parent_device); + + return D3D_OK; +} + +struct d3d9_indexbuffer *unsafe_impl_from_IDirect3DIndexBuffer9(IDirect3DIndexBuffer9 *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == &d3d9_indexbuffer_vtbl); + + return impl_from_IDirect3DIndexBuffer9(iface); +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/d3d9_main.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/d3d9_main.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/d3d9_main.c (revision 46521) @@ -0,0 +1,170 @@ +/* + * Direct3D 9 + * + * Copyright 2002-2003 Jason Edmeades + * Copyright 2002-2003 Raphael Junqueira + * Copyright 2005 Oliver Stieber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + * + */ + +#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) { + /* nothing to do */ +} + +IDirect3D9 * WINAPI DECLSPEC_HOTPATCH Direct3DCreate9(UINT sdk_version) +{ + struct d3d9 *object; + + TRACE("sdk_version %#x.\n", sdk_version); + + if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)))) + return NULL; + + if (!d3d9_init(object, FALSE)) + { + WARN("Failed to initialize d3d9.\n"); + HeapFree(GetProcessHeap(), 0, object); + return NULL; + } + + TRACE("Created d3d9 object %p.\n", object); + + return (IDirect3D9 *)&object->IDirect3D9Ex_iface; +} + +HRESULT WINAPI DECLSPEC_HOTPATCH Direct3DCreate9Ex(UINT sdk_version, IDirect3D9Ex **d3d9ex) +{ +#if defined(VBOX_WITH_WINE_FIX_NO9EX) && !defined(VBOX_WITH_WDDM) + /* real D3D lib does not allow 9Ex creation if no WDDM driver is installed, + * the Direct3DCreate9Ex should return D3DERR_NOTAVAILABLE in that case. + * do it that way for our XPDM case */ + return D3DERR_NOTAVAILABLE; +#else + struct d3d9 *object; + + TRACE("sdk_version %#x, d3d9ex %p.\n", sdk_version, d3d9ex); + + if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)))) + return E_OUTOFMEMORY; + + if (!d3d9_init(object, TRUE)) + { + WARN("Failed to initialize d3d9.\n"); + HeapFree(GetProcessHeap(), 0, object); + return D3DERR_NOTAVAILABLE; + } + + TRACE("Created d3d9 object %p.\n", object); + *d3d9ex = &object->IDirect3D9Ex_iface; + + return D3D_OK; +#endif +} + +/******************************************************************* + * Direct3DShaderValidatorCreate9 (D3D9.@) + * + * No documentation available for this function. + * SDK only says it is internal and shouldn't be used. + */ +void* WINAPI Direct3DShaderValidatorCreate9(void) +{ + static int once; + + if (!once++) FIXME("stub\n"); + return NULL; +} + +/******************************************************************* + * DllMain + */ +BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv) +{ + /* At process attach */ + TRACE("fdwReason=%d\n", fdwReason); + if (fdwReason == DLL_PROCESS_ATTACH) + DisableThreadLibraryCalls(hInstDLL); + + return TRUE; +} + +/*********************************************************************** + * D3DPERF_BeginEvent (D3D9.@) + */ +int WINAPI D3DPERF_BeginEvent(D3DCOLOR color, LPCWSTR name) { + TRACE("(color %#x, name %s) : stub\n", color, debugstr_w(name)); + + return D3DPERF_event_level++; +} + +/*********************************************************************** + * D3DPERF_EndEvent (D3D9.@) + */ +int WINAPI D3DPERF_EndEvent(void) { + TRACE("(void) : stub\n"); + + return --D3DPERF_event_level; +} + +/*********************************************************************** + * D3DPERF_GetStatus (D3D9.@) + */ +DWORD WINAPI D3DPERF_GetStatus(void) { + FIXME("(void) : stub\n"); + + return 0; +} + +/*********************************************************************** + * D3DPERF_SetOptions (D3D9.@) + * + */ +void WINAPI D3DPERF_SetOptions(DWORD options) +{ + FIXME("(%#x) : stub\n", options); +} + +/*********************************************************************** + * D3DPERF_QueryRepeatFrame (D3D9.@) + */ +BOOL WINAPI D3DPERF_QueryRepeatFrame(void) { + FIXME("(void) : stub\n"); + + return FALSE; +} + +/*********************************************************************** + * D3DPERF_SetMarker (D3D9.@) + */ +void WINAPI D3DPERF_SetMarker(D3DCOLOR color, LPCWSTR name) { + FIXME("(color %#x, name %s) : stub\n", color, debugstr_w(name)); +} + +/*********************************************************************** + * D3DPERF_SetRegion (D3D9.@) + */ +void WINAPI D3DPERF_SetRegion(D3DCOLOR color, LPCWSTR name) { + FIXME("(color %#x, name %s) : stub\n", color, debugstr_w(name)); +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/d3d9_private.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/d3d9_private.h (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/d3d9_private.h (revision 46521) @@ -0,0 +1,352 @@ +/* + * Direct3D 9 private include file + * + * Copyright 2002-2003 Jason Edmeades + * Copyright 2002-2003 Raphael Junqueira + * Copyright 2005 Oliver Stieber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D3D9_PRIVATE_H +#define __WINE_D3D9_PRIVATE_H + +#include +#include + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#define COBJMACROS +#ifndef VBOX_WINE_WITHOUT_LIBWINE +#include "windef.h" +#include "winbase.h" +#include "wingdi.h" +#include "winuser.h" +#else +#include +#endif +#include "wine/debug.h" +#include "wine/unicode.h" + +#include "d3d9.h" +#include "wine/wined3d.h" + +extern HRESULT vdecl_convert_fvf(DWORD FVF, D3DVERTEXELEMENT9 **ppVertexElements) DECLSPEC_HIDDEN; +D3DFORMAT d3dformat_from_wined3dformat(enum wined3d_format_id format) DECLSPEC_HIDDEN; +enum wined3d_format_id wined3dformat_from_d3dformat(D3DFORMAT format) DECLSPEC_HIDDEN; +void present_parameters_from_wined3d_swapchain_desc(D3DPRESENT_PARAMETERS *present_parameters, + const struct wined3d_swapchain_desc *swapchain_desc) DECLSPEC_HIDDEN; + +#define WINECAPSTOD3D9CAPS(_pD3D9Caps, _pWineCaps) \ + _pD3D9Caps->DeviceType = (D3DDEVTYPE) _pWineCaps->DeviceType; \ + _pD3D9Caps->AdapterOrdinal = _pWineCaps->AdapterOrdinal; \ + _pD3D9Caps->Caps = _pWineCaps->Caps; \ + _pD3D9Caps->Caps2 = _pWineCaps->Caps2; \ + _pD3D9Caps->Caps3 = _pWineCaps->Caps3; \ + _pD3D9Caps->PresentationIntervals = _pWineCaps->PresentationIntervals; \ + _pD3D9Caps->CursorCaps = _pWineCaps->CursorCaps; \ + _pD3D9Caps->DevCaps = _pWineCaps->DevCaps; \ + _pD3D9Caps->PrimitiveMiscCaps = _pWineCaps->PrimitiveMiscCaps; \ + _pD3D9Caps->RasterCaps = _pWineCaps->RasterCaps; \ + _pD3D9Caps->ZCmpCaps = _pWineCaps->ZCmpCaps; \ + _pD3D9Caps->SrcBlendCaps = _pWineCaps->SrcBlendCaps; \ + _pD3D9Caps->DestBlendCaps = _pWineCaps->DestBlendCaps; \ + _pD3D9Caps->AlphaCmpCaps = _pWineCaps->AlphaCmpCaps; \ + _pD3D9Caps->ShadeCaps = _pWineCaps->ShadeCaps; \ + _pD3D9Caps->TextureCaps = _pWineCaps->TextureCaps; \ + _pD3D9Caps->TextureFilterCaps = _pWineCaps->TextureFilterCaps; \ + _pD3D9Caps->CubeTextureFilterCaps = _pWineCaps->CubeTextureFilterCaps; \ + _pD3D9Caps->VolumeTextureFilterCaps = _pWineCaps->VolumeTextureFilterCaps; \ + _pD3D9Caps->TextureAddressCaps = _pWineCaps->TextureAddressCaps; \ + _pD3D9Caps->VolumeTextureAddressCaps = _pWineCaps->VolumeTextureAddressCaps; \ + _pD3D9Caps->LineCaps = _pWineCaps->LineCaps; \ + _pD3D9Caps->MaxTextureWidth = _pWineCaps->MaxTextureWidth; \ + _pD3D9Caps->MaxTextureHeight = _pWineCaps->MaxTextureHeight; \ + _pD3D9Caps->MaxVolumeExtent = _pWineCaps->MaxVolumeExtent; \ + _pD3D9Caps->MaxTextureRepeat = _pWineCaps->MaxTextureRepeat; \ + _pD3D9Caps->MaxTextureAspectRatio = _pWineCaps->MaxTextureAspectRatio; \ + _pD3D9Caps->MaxAnisotropy = _pWineCaps->MaxAnisotropy; \ + _pD3D9Caps->MaxVertexW = _pWineCaps->MaxVertexW; \ + _pD3D9Caps->GuardBandLeft = _pWineCaps->GuardBandLeft; \ + _pD3D9Caps->GuardBandTop = _pWineCaps->GuardBandTop; \ + _pD3D9Caps->GuardBandRight = _pWineCaps->GuardBandRight; \ + _pD3D9Caps->GuardBandBottom = _pWineCaps->GuardBandBottom; \ + _pD3D9Caps->ExtentsAdjust = _pWineCaps->ExtentsAdjust; \ + _pD3D9Caps->StencilCaps = _pWineCaps->StencilCaps; \ + _pD3D9Caps->FVFCaps = _pWineCaps->FVFCaps; \ + _pD3D9Caps->TextureOpCaps = _pWineCaps->TextureOpCaps; \ + _pD3D9Caps->MaxTextureBlendStages = _pWineCaps->MaxTextureBlendStages; \ + _pD3D9Caps->MaxSimultaneousTextures = _pWineCaps->MaxSimultaneousTextures; \ + _pD3D9Caps->VertexProcessingCaps = _pWineCaps->VertexProcessingCaps; \ + _pD3D9Caps->MaxActiveLights = _pWineCaps->MaxActiveLights; \ + _pD3D9Caps->MaxUserClipPlanes = _pWineCaps->MaxUserClipPlanes; \ + _pD3D9Caps->MaxVertexBlendMatrices = _pWineCaps->MaxVertexBlendMatrices; \ + _pD3D9Caps->MaxVertexBlendMatrixIndex = _pWineCaps->MaxVertexBlendMatrixIndex; \ + _pD3D9Caps->MaxPointSize = _pWineCaps->MaxPointSize; \ + _pD3D9Caps->MaxPrimitiveCount = _pWineCaps->MaxPrimitiveCount; \ + _pD3D9Caps->MaxVertexIndex = _pWineCaps->MaxVertexIndex; \ + _pD3D9Caps->MaxStreams = _pWineCaps->MaxStreams; \ + _pD3D9Caps->MaxStreamStride = _pWineCaps->MaxStreamStride; \ + _pD3D9Caps->VertexShaderVersion = _pWineCaps->VertexShaderVersion; \ + _pD3D9Caps->MaxVertexShaderConst = _pWineCaps->MaxVertexShaderConst; \ + _pD3D9Caps->PixelShaderVersion = _pWineCaps->PixelShaderVersion; \ + _pD3D9Caps->PixelShader1xMaxValue = _pWineCaps->PixelShader1xMaxValue; \ + _pD3D9Caps->DevCaps2 = _pWineCaps->DevCaps2; \ + _pD3D9Caps->MaxNpatchTessellationLevel = _pWineCaps->MaxNpatchTessellationLevel; \ + _pD3D9Caps->MasterAdapterOrdinal = _pWineCaps->MasterAdapterOrdinal; \ + _pD3D9Caps->AdapterOrdinalInGroup = _pWineCaps->AdapterOrdinalInGroup; \ + _pD3D9Caps->NumberOfAdaptersInGroup = _pWineCaps->NumberOfAdaptersInGroup; \ + _pD3D9Caps->DeclTypes = _pWineCaps->DeclTypes; \ + _pD3D9Caps->NumSimultaneousRTs = _pWineCaps->NumSimultaneousRTs; \ + _pD3D9Caps->StretchRectFilterCaps = _pWineCaps->StretchRectFilterCaps; \ + _pD3D9Caps->VS20Caps.Caps = _pWineCaps->VS20Caps.caps; \ + _pD3D9Caps->VS20Caps.DynamicFlowControlDepth = _pWineCaps->VS20Caps.dynamic_flow_control_depth; \ + _pD3D9Caps->VS20Caps.NumTemps = _pWineCaps->VS20Caps.temp_count; \ + _pD3D9Caps->VS20Caps.StaticFlowControlDepth = _pWineCaps->VS20Caps.static_flow_control_depth; \ + _pD3D9Caps->PS20Caps.Caps = _pWineCaps->PS20Caps.caps; \ + _pD3D9Caps->PS20Caps.DynamicFlowControlDepth = _pWineCaps->PS20Caps.dynamic_flow_control_depth; \ + _pD3D9Caps->PS20Caps.NumTemps = _pWineCaps->PS20Caps.temp_count; \ + _pD3D9Caps->PS20Caps.StaticFlowControlDepth = _pWineCaps->PS20Caps.static_flow_control_depth; \ + _pD3D9Caps->PS20Caps.NumInstructionSlots = _pWineCaps->PS20Caps.instruction_slot_count; \ + _pD3D9Caps->VertexTextureFilterCaps = _pWineCaps->VertexTextureFilterCaps; \ + _pD3D9Caps->MaxVShaderInstructionsExecuted = _pWineCaps->MaxVShaderInstructionsExecuted; \ + _pD3D9Caps->MaxPShaderInstructionsExecuted = _pWineCaps->MaxPShaderInstructionsExecuted; \ + _pD3D9Caps->MaxVertexShader30InstructionSlots = _pWineCaps->MaxVertexShader30InstructionSlots; \ + _pD3D9Caps->MaxPixelShader30InstructionSlots = _pWineCaps->MaxPixelShader30InstructionSlots; + +struct d3d9 +{ + IDirect3D9Ex IDirect3D9Ex_iface; + LONG refcount; + struct wined3d *wined3d; + BOOL extended; +}; + +BOOL d3d9_init(struct d3d9 *d3d9, BOOL extended) DECLSPEC_HIDDEN; +void filter_caps(D3DCAPS9* pCaps) DECLSPEC_HIDDEN; + +struct fvf_declaration +{ + struct wined3d_vertex_declaration *decl; + DWORD fvf; +}; + +struct d3d9_device +{ + IDirect3DDevice9Ex IDirect3DDevice9Ex_iface; + struct wined3d_device_parent device_parent; + LONG refcount; + struct wined3d_device *wined3d_device; + struct d3d9 *d3d_parent; + + struct fvf_declaration *fvf_decls; + UINT fvf_decl_count, fvf_decl_size; + + struct wined3d_buffer *vertex_buffer; + UINT vertex_buffer_size; + UINT vertex_buffer_pos; + struct wined3d_buffer *index_buffer; + UINT index_buffer_size; + UINT index_buffer_pos; + + BOOL in_destruction; + BOOL not_reset; + BOOL in_scene; +}; + +HRESULT device_init(struct d3d9_device *device, struct d3d9 *parent, struct wined3d *wined3d, + UINT adapter, D3DDEVTYPE device_type, HWND focus_window, DWORD flags +#ifdef VBOX_WITH_WDDM + , VBOXWINEEX_D3DPRESENT_PARAMETERS *parameters +#else + , D3DPRESENT_PARAMETERS *parameters +#endif + , D3DDISPLAYMODEEX *mode) DECLSPEC_HIDDEN; + +struct d3d9_volume +{ + IDirect3DVolume9 IDirect3DVolume9_iface; + LONG refcount; + struct wined3d_volume *wined3d_volume; + IUnknown *container; + IUnknown *forwardReference; +}; + +HRESULT volume_init(struct d3d9_volume *volume, struct d3d9_device *device, UINT width, UINT height, + UINT depth, DWORD usage, enum wined3d_format_id format, enum wined3d_pool pool +#ifdef VBOX_WITH_WDDM + , HANDLE *shared_handle + , void *pvClientMem +#endif + ) DECLSPEC_HIDDEN; + +struct d3d9_swapchain +{ + IDirect3DSwapChain9 IDirect3DSwapChain9_iface; + LONG refcount; + struct wined3d_swapchain *wined3d_swapchain; + IDirect3DDevice9Ex *parent_device; +}; + +HRESULT d3d9_swapchain_create(struct d3d9_device *device, struct wined3d_swapchain_desc *desc, + struct d3d9_swapchain **swapchain) DECLSPEC_HIDDEN; + +struct d3d9_surface +{ + IDirect3DSurface9 IDirect3DSurface9_iface; + LONG refcount; + struct wined3d_surface *wined3d_surface; + IDirect3DDevice9Ex *parent_device; + IUnknown *container; + IUnknown *forwardReference; + BOOL getdc_supported; +}; + +HRESULT surface_init(struct d3d9_surface *surface, struct d3d9_device *device, UINT width, UINT height, + D3DFORMAT format, DWORD flags, DWORD usage, D3DPOOL pool, D3DMULTISAMPLE_TYPE multisample_type, + DWORD multisample_quality +#ifdef VBOX_WITH_WDDM + , HANDLE *shared_handle + , void *pvClientMem +#endif + ) DECLSPEC_HIDDEN; +struct d3d9_surface *unsafe_impl_from_IDirect3DSurface9(IDirect3DSurface9 *iface) DECLSPEC_HIDDEN; + +struct d3d9_vertexbuffer +{ + IDirect3DVertexBuffer9 IDirect3DVertexBuffer9_iface; + LONG refcount; + struct wined3d_buffer *wined3d_buffer; + IDirect3DDevice9Ex *parent_device; + DWORD fvf; +}; + +HRESULT vertexbuffer_init(struct d3d9_vertexbuffer *buffer, struct d3d9_device *device, + UINT size, UINT usage, DWORD fvf, D3DPOOL pool) DECLSPEC_HIDDEN; +struct d3d9_vertexbuffer *unsafe_impl_from_IDirect3DVertexBuffer9(IDirect3DVertexBuffer9 *iface) DECLSPEC_HIDDEN; + +struct d3d9_indexbuffer +{ + IDirect3DIndexBuffer9 IDirect3DIndexBuffer9_iface; + LONG refcount; + struct wined3d_buffer *wined3d_buffer; + IDirect3DDevice9Ex *parent_device; + enum wined3d_format_id format; +}; + +HRESULT indexbuffer_init(struct d3d9_indexbuffer *buffer, struct d3d9_device *device, + UINT size, DWORD usage, D3DFORMAT format, D3DPOOL pool) DECLSPEC_HIDDEN; +struct d3d9_indexbuffer *unsafe_impl_from_IDirect3DIndexBuffer9(IDirect3DIndexBuffer9 *iface) DECLSPEC_HIDDEN; + +struct d3d9_texture +{ + IDirect3DBaseTexture9 IDirect3DBaseTexture9_iface; + LONG refcount; + struct wined3d_texture *wined3d_texture; + IDirect3DDevice9Ex *parent_device; +}; + +HRESULT cubetexture_init(struct d3d9_texture *texture, struct d3d9_device *device, + UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool +#ifdef VBOX_WITH_WDDM + , HANDLE *shared_handle + , void **pavClientMem +#endif + ) DECLSPEC_HIDDEN; +HRESULT texture_init(struct d3d9_texture *texture, struct d3d9_device *device, + UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool +#ifdef VBOX_WITH_WDDM + , HANDLE *shared_handle + , void **pavClientMem +#endif + ) DECLSPEC_HIDDEN; +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 +#ifdef VBOX_WITH_WDDM + , HANDLE *shared_handle + , void **pavClientMem +#endif + ) DECLSPEC_HIDDEN; +struct d3d9_texture *unsafe_impl_from_IDirect3DBaseTexture9(IDirect3DBaseTexture9 *iface) DECLSPEC_HIDDEN; + +struct d3d9_stateblock +{ + IDirect3DStateBlock9 IDirect3DStateBlock9_iface; + LONG refcount; + struct wined3d_stateblock *wined3d_stateblock; + IDirect3DDevice9Ex *parent_device; +}; + +HRESULT stateblock_init(struct d3d9_stateblock *stateblock, struct d3d9_device *device, + D3DSTATEBLOCKTYPE type, struct wined3d_stateblock *wined3d_stateblock) DECLSPEC_HIDDEN; + +struct d3d9_vertex_declaration +{ + IDirect3DVertexDeclaration9 IDirect3DVertexDeclaration9_iface; + LONG refcount; + D3DVERTEXELEMENT9 *elements; + UINT element_count; + struct wined3d_vertex_declaration *wined3d_declaration; + DWORD fvf; + IDirect3DDevice9Ex *parent_device; +}; + +HRESULT d3d9_vertex_declaration_create(struct d3d9_device *device, + const D3DVERTEXELEMENT9 *elements, struct d3d9_vertex_declaration **declaration) DECLSPEC_HIDDEN; +struct d3d9_vertex_declaration *unsafe_impl_from_IDirect3DVertexDeclaration9( + IDirect3DVertexDeclaration9 *iface) DECLSPEC_HIDDEN; + +struct d3d9_vertexshader +{ + IDirect3DVertexShader9 IDirect3DVertexShader9_iface; + LONG refcount; + struct wined3d_shader *wined3d_shader; + IDirect3DDevice9Ex *parent_device; +}; + +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; + LONG refcount; + struct wined3d_shader *wined3d_shader; + IDirect3DDevice9Ex *parent_device; +}; + +HRESULT pixelshader_init(struct d3d9_pixelshader *shader, + struct d3d9_device *device, const DWORD *byte_code) DECLSPEC_HIDDEN; +struct d3d9_pixelshader *unsafe_impl_from_IDirect3DPixelShader9(IDirect3DPixelShader9 *iface) DECLSPEC_HIDDEN; + +struct d3d9_query +{ + IDirect3DQuery9 IDirect3DQuery9_iface; + LONG refcount; + struct wined3d_query *wined3d_query; + IDirect3DDevice9Ex *parent_device; +}; + +HRESULT query_init(struct d3d9_query *query, struct d3d9_device *device, D3DQUERYTYPE type) DECLSPEC_HIDDEN; + +#ifdef VBOX_WITH_WDDM +struct d3d9_volume *unsafe_impl_from_IDirect3DVolume9(IDirect3DVolume9 *iface) DECLSPEC_HIDDEN; +#endif + +#endif /* __WINE_D3D9_PRIVATE_H */ Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/d3d9wddm.def =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/d3d9wddm.def (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/d3d9wddm.def (revision 46521) @@ -0,0 +1,23 @@ + +EXPORTS + Direct3DShaderValidatorCreate9 + D3DPERF_BeginEvent + D3DPERF_EndEvent + D3DPERF_GetStatus + D3DPERF_QueryRepeatFrame + D3DPERF_SetMarker + D3DPERF_SetOptions + D3DPERF_SetRegion + DebugSetMute + Direct3DCreate9 + Direct3DCreate9Ex + VBoxWineExD3DDev9Flush + VBoxWineExD3DDev9FlushToHost + VBoxWineExD3DDev9Finish + VBoxWineExD3DDev9CreateTexture + VBoxWineExD3DDev9CreateCubeTexture + VBoxWineExD3DDev9CreateVolumeTexture + VBoxWineExD3DDev9Term + VBoxWineExD3DSwapchain9Present + VBoxWineExD3DDev9VolBlt + VBoxWineExD3DDev9VolTexBlt Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/d3d9xpdm.def =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/d3d9xpdm.def (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/d3d9xpdm.def (revision 46521) @@ -0,0 +1,14 @@ +LIBRARY VBoxD3D9.dll + +EXPORTS + Direct3DShaderValidatorCreate9 + D3DPERF_BeginEvent + D3DPERF_EndEvent + D3DPERF_GetStatus + D3DPERF_QueryRepeatFrame + D3DPERF_SetMarker + D3DPERF_SetOptions + D3DPERF_SetRegion + DebugSetMute + Direct3DCreate9 + Direct3DCreate9Ex Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/device.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/device.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/device.c (revision 46521) @@ -0,0 +1,3927 @@ +/* + * IDirect3DDevice9 implementation + * + * Copyright 2002-2005 Jason Edmeades + * Copyright 2002-2005 Raphael Junqueira + * Copyright 2005 Oliver Stieber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "config.h" +#include "d3d9_private.h" + +#ifdef VBOX_WITH_WDDM +# include +# include "../../common/VBoxVideoTools.h" +#endif + +WINE_DEFAULT_DEBUG_CHANNEL(d3d9); + +D3DFORMAT d3dformat_from_wined3dformat(enum wined3d_format_id format) +{ + BYTE *c = (BYTE *)&format; + + /* Don't translate FOURCC formats */ + if (isprint(c[0]) && isprint(c[1]) && isprint(c[2]) && isprint(c[3])) return format; + + switch(format) + { + case WINED3DFMT_UNKNOWN: return D3DFMT_UNKNOWN; + case WINED3DFMT_B8G8R8_UNORM: return D3DFMT_R8G8B8; + case WINED3DFMT_B8G8R8A8_UNORM: return D3DFMT_A8R8G8B8; + case WINED3DFMT_B8G8R8X8_UNORM: return D3DFMT_X8R8G8B8; + case WINED3DFMT_B5G6R5_UNORM: return D3DFMT_R5G6B5; + case WINED3DFMT_B5G5R5X1_UNORM: return D3DFMT_X1R5G5B5; + case WINED3DFMT_B5G5R5A1_UNORM: return D3DFMT_A1R5G5B5; + case WINED3DFMT_B4G4R4A4_UNORM: return D3DFMT_A4R4G4B4; + case WINED3DFMT_B2G3R3_UNORM: return D3DFMT_R3G3B2; + case WINED3DFMT_A8_UNORM: return D3DFMT_A8; + case WINED3DFMT_B2G3R3A8_UNORM: return D3DFMT_A8R3G3B2; + case WINED3DFMT_B4G4R4X4_UNORM: return D3DFMT_X4R4G4B4; + case WINED3DFMT_R10G10B10A2_UNORM: return D3DFMT_A2B10G10R10; + case WINED3DFMT_R8G8B8A8_UNORM: return D3DFMT_A8B8G8R8; + case WINED3DFMT_R8G8B8X8_UNORM: return D3DFMT_X8B8G8R8; + case WINED3DFMT_R16G16_UNORM: return D3DFMT_G16R16; + case WINED3DFMT_B10G10R10A2_UNORM: return D3DFMT_A2R10G10B10; + case WINED3DFMT_R16G16B16A16_UNORM: return D3DFMT_A16B16G16R16; + case WINED3DFMT_P8_UINT_A8_UNORM: return D3DFMT_A8P8; + case WINED3DFMT_P8_UINT: return D3DFMT_P8; + case WINED3DFMT_L8_UNORM: return D3DFMT_L8; + case WINED3DFMT_L8A8_UNORM: return D3DFMT_A8L8; + case WINED3DFMT_L4A4_UNORM: return D3DFMT_A4L4; + case WINED3DFMT_R8G8_SNORM: return D3DFMT_V8U8; + case WINED3DFMT_R5G5_SNORM_L6_UNORM: return D3DFMT_L6V5U5; + case WINED3DFMT_R8G8_SNORM_L8X8_UNORM: return D3DFMT_X8L8V8U8; + case WINED3DFMT_R8G8B8A8_SNORM: return D3DFMT_Q8W8V8U8; + case WINED3DFMT_R16G16_SNORM: return D3DFMT_V16U16; + case WINED3DFMT_R10G10B10_SNORM_A2_UNORM: return D3DFMT_A2W10V10U10; + case WINED3DFMT_D16_LOCKABLE: return D3DFMT_D16_LOCKABLE; + case WINED3DFMT_D32_UNORM: return D3DFMT_D32; + case WINED3DFMT_S1_UINT_D15_UNORM: return D3DFMT_D15S1; + case WINED3DFMT_D24_UNORM_S8_UINT: return D3DFMT_D24S8; + case WINED3DFMT_X8D24_UNORM: return D3DFMT_D24X8; + case WINED3DFMT_S4X4_UINT_D24_UNORM: return D3DFMT_D24X4S4; + case WINED3DFMT_D16_UNORM: return D3DFMT_D16; + case WINED3DFMT_L16_UNORM: return D3DFMT_L16; + case WINED3DFMT_D32_FLOAT: return D3DFMT_D32F_LOCKABLE; + case WINED3DFMT_S8_UINT_D24_FLOAT: return D3DFMT_D24FS8; + case WINED3DFMT_VERTEXDATA: return D3DFMT_VERTEXDATA; + case WINED3DFMT_R16_UINT: return D3DFMT_INDEX16; + case WINED3DFMT_R32_UINT: return D3DFMT_INDEX32; + case WINED3DFMT_R16G16B16A16_SNORM: return D3DFMT_Q16W16V16U16; + case WINED3DFMT_R16_FLOAT: return D3DFMT_R16F; + case WINED3DFMT_R16G16_FLOAT: return D3DFMT_G16R16F; + case WINED3DFMT_R16G16B16A16_FLOAT: return D3DFMT_A16B16G16R16F; + case WINED3DFMT_R32_FLOAT: return D3DFMT_R32F; + case WINED3DFMT_R32G32_FLOAT: return D3DFMT_G32R32F; + case WINED3DFMT_R32G32B32A32_FLOAT: return D3DFMT_A32B32G32R32F; + case WINED3DFMT_R8G8_SNORM_Cx: return D3DFMT_CxV8U8; + default: + FIXME("Unhandled wined3d format %#x.\n", format); + return D3DFMT_UNKNOWN; + } +} + +enum wined3d_format_id wined3dformat_from_d3dformat(D3DFORMAT format) +{ + BYTE *c = (BYTE *)&format; + + /* Don't translate FOURCC formats */ + if (isprint(c[0]) && isprint(c[1]) && isprint(c[2]) && isprint(c[3])) return format; + + switch(format) + { + case D3DFMT_UNKNOWN: return WINED3DFMT_UNKNOWN; + case D3DFMT_R8G8B8: return WINED3DFMT_B8G8R8_UNORM; + case D3DFMT_A8R8G8B8: return WINED3DFMT_B8G8R8A8_UNORM; + case D3DFMT_X8R8G8B8: return WINED3DFMT_B8G8R8X8_UNORM; + case D3DFMT_R5G6B5: return WINED3DFMT_B5G6R5_UNORM; + case D3DFMT_X1R5G5B5: return WINED3DFMT_B5G5R5X1_UNORM; + case D3DFMT_A1R5G5B5: return WINED3DFMT_B5G5R5A1_UNORM; + case D3DFMT_A4R4G4B4: return WINED3DFMT_B4G4R4A4_UNORM; + case D3DFMT_R3G3B2: return WINED3DFMT_B2G3R3_UNORM; + case D3DFMT_A8: return WINED3DFMT_A8_UNORM; + case D3DFMT_A8R3G3B2: return WINED3DFMT_B2G3R3A8_UNORM; + case D3DFMT_X4R4G4B4: return WINED3DFMT_B4G4R4X4_UNORM; + case D3DFMT_A2B10G10R10: return WINED3DFMT_R10G10B10A2_UNORM; + case D3DFMT_A8B8G8R8: return WINED3DFMT_R8G8B8A8_UNORM; + case D3DFMT_X8B8G8R8: return WINED3DFMT_R8G8B8X8_UNORM; + case D3DFMT_G16R16: return WINED3DFMT_R16G16_UNORM; + case D3DFMT_A2R10G10B10: return WINED3DFMT_B10G10R10A2_UNORM; + case D3DFMT_A16B16G16R16: return WINED3DFMT_R16G16B16A16_UNORM; + case D3DFMT_A8P8: return WINED3DFMT_P8_UINT_A8_UNORM; + case D3DFMT_P8: return WINED3DFMT_P8_UINT; + case D3DFMT_L8: return WINED3DFMT_L8_UNORM; + case D3DFMT_A8L8: return WINED3DFMT_L8A8_UNORM; + case D3DFMT_A4L4: return WINED3DFMT_L4A4_UNORM; + case D3DFMT_V8U8: return WINED3DFMT_R8G8_SNORM; + case D3DFMT_L6V5U5: return WINED3DFMT_R5G5_SNORM_L6_UNORM; + case D3DFMT_X8L8V8U8: return WINED3DFMT_R8G8_SNORM_L8X8_UNORM; + case D3DFMT_Q8W8V8U8: return WINED3DFMT_R8G8B8A8_SNORM; + case D3DFMT_V16U16: return WINED3DFMT_R16G16_SNORM; + case D3DFMT_A2W10V10U10: return WINED3DFMT_R10G10B10_SNORM_A2_UNORM; + case D3DFMT_D16_LOCKABLE: return WINED3DFMT_D16_LOCKABLE; + case D3DFMT_D32: return WINED3DFMT_D32_UNORM; + case D3DFMT_D15S1: return WINED3DFMT_S1_UINT_D15_UNORM; + case D3DFMT_D24S8: return WINED3DFMT_D24_UNORM_S8_UINT; + case D3DFMT_D24X8: return WINED3DFMT_X8D24_UNORM; + case D3DFMT_D24X4S4: return WINED3DFMT_S4X4_UINT_D24_UNORM; + case D3DFMT_D16: return WINED3DFMT_D16_UNORM; + case D3DFMT_L16: return WINED3DFMT_L16_UNORM; + case D3DFMT_D32F_LOCKABLE: return WINED3DFMT_D32_FLOAT; + case D3DFMT_D24FS8: return WINED3DFMT_S8_UINT_D24_FLOAT; + case D3DFMT_VERTEXDATA: return WINED3DFMT_VERTEXDATA; + case D3DFMT_INDEX16: return WINED3DFMT_R16_UINT; + case D3DFMT_INDEX32: return WINED3DFMT_R32_UINT; + case D3DFMT_Q16W16V16U16: return WINED3DFMT_R16G16B16A16_SNORM; + case D3DFMT_R16F: return WINED3DFMT_R16_FLOAT; + case D3DFMT_G16R16F: return WINED3DFMT_R16G16_FLOAT; + case D3DFMT_A16B16G16R16F: return WINED3DFMT_R16G16B16A16_FLOAT; + case D3DFMT_R32F: return WINED3DFMT_R32_FLOAT; + case D3DFMT_G32R32F: return WINED3DFMT_R32G32_FLOAT; + case D3DFMT_A32B32G32R32F: return WINED3DFMT_R32G32B32A32_FLOAT; + case D3DFMT_CxV8U8: return WINED3DFMT_R8G8_SNORM_Cx; + default: + FIXME("Unhandled D3DFORMAT %#x\n", format); + return WINED3DFMT_UNKNOWN; + } +} + +static UINT vertex_count_from_primitive_count(D3DPRIMITIVETYPE primitive_type, UINT primitive_count) +{ + switch(primitive_type) + { + case D3DPT_POINTLIST: + return primitive_count; + + case D3DPT_LINELIST: + return primitive_count * 2; + + case D3DPT_LINESTRIP: + return primitive_count + 1; + + case D3DPT_TRIANGLELIST: + return primitive_count * 3; + + case D3DPT_TRIANGLESTRIP: + case D3DPT_TRIANGLEFAN: + return primitive_count + 2; + + default: + FIXME("Unhandled primitive type %#x\n", primitive_type); + return 0; + } +} + +void present_parameters_from_wined3d_swapchain_desc(D3DPRESENT_PARAMETERS *present_parameters, + const struct wined3d_swapchain_desc *swapchain_desc) +{ + present_parameters->BackBufferWidth = swapchain_desc->backbuffer_width; + present_parameters->BackBufferHeight = swapchain_desc->backbuffer_height; + 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->MultiSampleQuality = swapchain_desc->multisample_quality; + present_parameters->SwapEffect = 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; + present_parameters->AutoDepthStencilFormat + = d3dformat_from_wined3dformat(swapchain_desc->auto_depth_stencil_format); + present_parameters->Flags = swapchain_desc->flags; + present_parameters->FullScreen_RefreshRateInHz = swapchain_desc->refresh_rate; + present_parameters->PresentationInterval = swapchain_desc->swap_interval; +} + +static void wined3d_swapchain_desc_from_present_parameters(struct wined3d_swapchain_desc *swapchain_desc, + const D3DPRESENT_PARAMETERS *present_parameters) +{ + swapchain_desc->backbuffer_width = present_parameters->BackBufferWidth; + 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->multisample_type = present_parameters->MultiSampleType; + swapchain_desc->multisample_quality = present_parameters->MultiSampleQuality; + swapchain_desc->swap_effect = 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; + swapchain_desc->auto_depth_stencil_format + = wined3dformat_from_d3dformat(present_parameters->AutoDepthStencilFormat); + swapchain_desc->flags = present_parameters->Flags; + swapchain_desc->refresh_rate = present_parameters->FullScreen_RefreshRateInHz; + swapchain_desc->swap_interval = present_parameters->PresentationInterval; + swapchain_desc->auto_restore_display_mode = TRUE; +#ifdef VBOX_WITH_WDDM + swapchain_desc->pHgsmi = NULL; +#endif + +} + +static inline struct d3d9_device *impl_from_IDirect3DDevice9Ex(IDirect3DDevice9Ex *iface) +{ + return CONTAINING_RECORD(iface, struct d3d9_device, IDirect3DDevice9Ex_iface); +} + +static HRESULT WINAPI d3d9_device_QueryInterface(IDirect3DDevice9Ex *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DDevice9) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DDevice9Ex_AddRef(iface); + *out = iface; + return S_OK; + } + + if (IsEqualGUID(riid, &IID_IDirect3DDevice9Ex)) + { + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + /* Find out if the creating d3d9 interface was created with Direct3DCreate9Ex. + * It doesn't matter with which function the device was created. */ + if (!device->d3d_parent->extended) + { + WARN("IDirect3D9 instance wasn't created with CreateDirect3D9Ex, returning E_NOINTERFACE.\n"); + *out = NULL; + return E_NOINTERFACE; + } + + IDirect3DDevice9Ex_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d9_device_AddRef(IDirect3DDevice9Ex *iface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + ULONG refcount = InterlockedIncrement(&device->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, refcount); + + return refcount; +} + +#ifdef VBOX +static LONG d3d9_device_Term(struct d3d9_device *device) +{ + unsigned i; + LONG refs = device->refcount; + device->in_destruction = TRUE; + + if (refs != 1) + { + ERR("unexpected ref count %d, destroying in anyway", refs); + } + + wined3d_mutex_lock(); + for (i = 0; i < device->fvf_decl_count; ++i) + { + wined3d_vertex_declaration_decref(device->fvf_decls[i].decl); + } + HeapFree(GetProcessHeap(), 0, device->fvf_decls); + + if (device->vertex_buffer) + wined3d_buffer_decref(device->vertex_buffer); + if (device->index_buffer) + wined3d_buffer_decref(device->index_buffer); + + wined3d_device_uninit_3d(device->wined3d_device); +# ifndef VBOX_WITH_WDDM + wined3d_device_release_focus_window(device->wined3d_device); +# endif + wined3d_device_decref(device->wined3d_device); + wined3d_mutex_unlock(); + + IDirect3D9Ex_Release(&device->d3d_parent->IDirect3D9Ex_iface); + + HeapFree(GetProcessHeap(), 0, device); + + return refs - 1; +} +#endif + +static ULONG WINAPI DECLSPEC_HOTPATCH d3d9_device_Release(IDirect3DDevice9Ex *iface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + ULONG refcount; + + if (device->in_destruction) + return 0; + + refcount = InterlockedDecrement(&device->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, refcount); + + if (!refcount) + { +#ifdef VBOX + d3d9_device_Term(device); +#else + unsigned i; + device->in_destruction = TRUE; + + wined3d_mutex_lock(); + for (i = 0; i < device->fvf_decl_count; ++i) + { + wined3d_vertex_declaration_decref(device->fvf_decls[i].decl); + } + HeapFree(GetProcessHeap(), 0, device->fvf_decls); + + if (device->vertex_buffer) + wined3d_buffer_decref(device->vertex_buffer); + if (device->index_buffer) + wined3d_buffer_decref(device->index_buffer); + + wined3d_device_uninit_3d(device->wined3d_device); + wined3d_device_release_focus_window(device->wined3d_device); + wined3d_device_decref(device->wined3d_device); + wined3d_mutex_unlock(); + + IDirect3D9Ex_Release(&device->d3d_parent->IDirect3D9Ex_iface); + + HeapFree(GetProcessHeap(), 0, device); +#endif + } + + return refcount; +} + +static HRESULT WINAPI d3d9_device_TestCooperativeLevel(IDirect3DDevice9Ex *iface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p.\n", iface); + + if (device->not_reset) + { + TRACE("D3D9 device is marked not reset.\n"); + return D3DERR_DEVICENOTRESET; + } + + return D3D_OK; +} + +static UINT WINAPI d3d9_device_GetAvailableTextureMem(IDirect3DDevice9Ex *iface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + hr = wined3d_device_get_available_texture_mem(device->wined3d_device); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_EvictManagedResources(IDirect3DDevice9Ex *iface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_device_evict_managed_resources(device->wined3d_device); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_GetDirect3D(IDirect3DDevice9Ex *iface, IDirect3D9 **d3d9) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, d3d9 %p.\n", iface, d3d9); + + if (!d3d9) + return D3DERR_INVALIDCALL; + + return IDirect3D9Ex_QueryInterface(&device->d3d_parent->IDirect3D9Ex_iface, &IID_IDirect3D9, (void **)d3d9); +} + +static HRESULT WINAPI d3d9_device_GetDeviceCaps(IDirect3DDevice9Ex *iface, D3DCAPS9 *caps) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + WINED3DCAPS *wined3d_caps; + HRESULT hr; + + TRACE("iface %p, caps %p.\n", iface, caps); + + if (!caps) + return D3DERR_INVALIDCALL; + + if (!(wined3d_caps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wined3d_caps)))) + return D3DERR_INVALIDCALL; /* well this is what MSDN says to return */ + + memset(caps, 0, sizeof(*caps)); + + wined3d_mutex_lock(); + hr = wined3d_device_get_device_caps(device->wined3d_device, wined3d_caps); + wined3d_mutex_unlock(); + + WINECAPSTOD3D9CAPS(caps, wined3d_caps) + HeapFree(GetProcessHeap(), 0, wined3d_caps); + + /* Some functionality is implemented in d3d9.dll, not wined3d.dll. Add the needed caps */ + caps->DevCaps2 |= D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES; + + filter_caps(caps); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetDisplayMode(IDirect3DDevice9Ex *iface, UINT swapchain, D3DDISPLAYMODE *mode) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct wined3d_display_mode wined3d_mode; + HRESULT hr; + + TRACE("iface %p, swapchain %u, mode %p.\n", iface, swapchain, mode); + + wined3d_mutex_lock(); + hr = wined3d_device_get_display_mode(device->wined3d_device, swapchain, &wined3d_mode, NULL); + wined3d_mutex_unlock(); + + if (SUCCEEDED(hr)) + { + mode->Width = wined3d_mode.width; + mode->Height = wined3d_mode.height; + mode->RefreshRate = wined3d_mode.refresh_rate; + mode->Format = d3dformat_from_wined3dformat(wined3d_mode.format_id); + } + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetCreationParameters(IDirect3DDevice9Ex *iface, + D3DDEVICE_CREATION_PARAMETERS *parameters) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, parameters %p.\n", iface, parameters); + + wined3d_mutex_lock(); + wined3d_device_get_creation_parameters(device->wined3d_device, + (struct wined3d_device_creation_parameters *)parameters); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_SetCursorProperties(IDirect3DDevice9Ex *iface, + UINT hotspot_x, UINT hotspot_y, IDirect3DSurface9 *bitmap) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_surface *bitmap_impl = unsafe_impl_from_IDirect3DSurface9(bitmap); + HRESULT hr; + + TRACE("iface %p, hotspot_x %u, hotspot_y %u, bitmap %p.\n", + iface, hotspot_x, hotspot_y, bitmap); + + if (!bitmap) + { + WARN("No cursor bitmap, returning D3DERR_INVALIDCALL.\n"); + return D3DERR_INVALIDCALL; + } + + wined3d_mutex_lock(); + hr = wined3d_device_set_cursor_properties(device->wined3d_device, + hotspot_x, hotspot_y, bitmap_impl->wined3d_surface); + wined3d_mutex_unlock(); + + return hr; +} + +static void WINAPI d3d9_device_SetCursorPosition(IDirect3DDevice9Ex *iface, int x, int y, DWORD flags) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, x %u, y %u, flags %#x.\n", iface, x, y, flags); + + wined3d_mutex_lock(); + wined3d_device_set_cursor_position(device->wined3d_device, x, y, flags); + wined3d_mutex_unlock(); +} + +static BOOL WINAPI d3d9_device_ShowCursor(IDirect3DDevice9Ex *iface, BOOL show) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + BOOL ret; + + TRACE("iface %p, show %#x.\n", iface, show); + + wined3d_mutex_lock(); + ret = wined3d_device_show_cursor(device->wined3d_device, show); + wined3d_mutex_unlock(); + + return ret; +} + +static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_device_CreateAdditionalSwapChain(IDirect3DDevice9Ex *iface, + D3DPRESENT_PARAMETERS *present_parameters, IDirect3DSwapChain9 **swapchain) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct wined3d_swapchain_desc desc; + struct d3d9_swapchain *object; + HRESULT hr; + + TRACE("iface %p, present_parameters %p, swapchain %p.\n", + iface, present_parameters, swapchain); + + wined3d_swapchain_desc_from_present_parameters(&desc, present_parameters); + if (SUCCEEDED(hr = d3d9_swapchain_create(device, &desc, &object))) + *swapchain = &object->IDirect3DSwapChain9_iface; + present_parameters_from_wined3d_swapchain_desc(present_parameters, &desc); + + return hr; +} + +static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_device_GetSwapChain(IDirect3DDevice9Ex *iface, + UINT swapchain_idx, IDirect3DSwapChain9 **swapchain) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct wined3d_swapchain *wined3d_swapchain; + struct d3d9_swapchain *swapchain_impl; + HRESULT hr; + + TRACE("iface %p, swapchain_idx %u, swapchain %p.\n", iface, swapchain_idx, swapchain); + + wined3d_mutex_lock(); + if ((wined3d_swapchain = wined3d_device_get_swapchain(device->wined3d_device, swapchain_idx))) + { + swapchain_impl = wined3d_swapchain_get_parent(wined3d_swapchain); + *swapchain = &swapchain_impl->IDirect3DSwapChain9_iface; + IDirect3DSwapChain9_AddRef(*swapchain); + hr = D3D_OK; + } + else + { + *swapchain = NULL; + hr = D3DERR_INVALIDCALL; + } + wined3d_mutex_unlock(); + + return hr; +} + +static UINT WINAPI d3d9_device_GetNumberOfSwapChains(IDirect3DDevice9Ex *iface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + UINT count; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + count = wined3d_device_get_swapchain_count(device->wined3d_device); + wined3d_mutex_unlock(); + + return count; +} + +static HRESULT CDECL reset_enum_callback(struct wined3d_resource *resource) +{ + struct wined3d_resource_desc desc; + + wined3d_resource_get_desc(resource, &desc); + if (desc.pool == WINED3D_POOL_DEFAULT) + { + struct d3d9_surface *surface; + + if (desc.resource_type == WINED3D_RTYPE_TEXTURE) + { + IUnknown *parent = wined3d_resource_get_parent(resource); + IDirect3DBaseTexture9 *texture; + + if (SUCCEEDED(IUnknown_QueryInterface(parent, &IID_IDirect3DBaseTexture9, (void **)&texture))) + { + IDirect3DBaseTexture9_Release(texture); + WARN("Texture %p (resource %p) in pool D3DPOOL_DEFAULT blocks the Reset call.\n", texture, resource); + return D3DERR_INVALIDCALL; + } + + return D3D_OK; + } + + if (desc.resource_type != WINED3D_RTYPE_SURFACE) + { + WARN("Resource %p in pool D3DPOOL_DEFAULT blocks the Reset call.\n", resource); + return D3DERR_INVALIDCALL; + } + + surface = wined3d_resource_get_parent(resource); + if (surface->refcount) + { + WARN("Surface %p (resource %p) in pool D3DPOOL_DEFAULT blocks the Reset call.\n", surface, resource); + return D3DERR_INVALIDCALL; + } + + WARN("Surface %p (resource %p) is an implicit resource with ref 0.\n", surface, resource); + } + + return D3D_OK; +} + +static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_device_Reset(IDirect3DDevice9Ex *iface, + D3DPRESENT_PARAMETERS *present_parameters) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct wined3d_swapchain_desc swapchain_desc; + HRESULT hr; + + TRACE("iface %p, present_parameters %p.\n", iface, present_parameters); + + wined3d_mutex_lock(); + + if (device->vertex_buffer) + { + wined3d_buffer_decref(device->vertex_buffer); + device->vertex_buffer = NULL; + device->vertex_buffer_size = 0; + } + if (device->index_buffer) + { + wined3d_buffer_decref(device->index_buffer); + device->index_buffer = NULL; + device->index_buffer_size = 0; + } + + wined3d_swapchain_desc_from_present_parameters(&swapchain_desc, present_parameters); + hr = wined3d_device_reset(device->wined3d_device, &swapchain_desc, + NULL, reset_enum_callback, !device->d3d_parent->extended); + if (FAILED(hr) && !device->d3d_parent->extended) + device->not_reset = TRUE; + else + device->not_reset = FALSE; + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_device_Present(IDirect3DDevice9Ex *iface, + const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override, const RGNDATA *dirty_region) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, src_rect %p, dst_rect %p, dst_window_override %p, dirty_region %p.\n", + iface, src_rect, dst_rect, dst_window_override, dirty_region); + + wined3d_mutex_lock(); + hr = wined3d_device_present(device->wined3d_device, src_rect, dst_rect, + dst_window_override, dirty_region, 0); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetBackBuffer(IDirect3DDevice9Ex *iface, UINT swapchain, + UINT backbuffer_idx, D3DBACKBUFFER_TYPE backbuffer_type, IDirect3DSurface9 **backbuffer) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct wined3d_surface *wined3d_surface = NULL; + struct d3d9_surface *surface_impl; + HRESULT hr; + + TRACE("iface %p, swapchain %u, backbuffer_idx %u, backbuffer_type %#x, backbuffer %p.\n", + iface, swapchain, backbuffer_idx, backbuffer_type, backbuffer); + + wined3d_mutex_lock(); + hr = wined3d_device_get_back_buffer(device->wined3d_device, swapchain, + backbuffer_idx, (enum wined3d_backbuffer_type)backbuffer_type, &wined3d_surface); + if (SUCCEEDED(hr) && wined3d_surface && backbuffer) + { + surface_impl = wined3d_surface_get_parent(wined3d_surface); + *backbuffer = &surface_impl->IDirect3DSurface9_iface; + IDirect3DSurface9_AddRef(*backbuffer); + } + wined3d_mutex_unlock(); + + return hr; +} +static HRESULT WINAPI d3d9_device_GetRasterStatus(IDirect3DDevice9Ex *iface, + UINT swapchain, D3DRASTER_STATUS *raster_status) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, swapchain %u, raster_status %p.\n", iface, swapchain, raster_status); + + wined3d_mutex_lock(); + hr = wined3d_device_get_raster_status(device->wined3d_device, + swapchain, (struct wined3d_raster_status *)raster_status); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_SetDialogBoxMode(IDirect3DDevice9Ex *iface, BOOL enable) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, enable %#x.\n", iface, enable); + + wined3d_mutex_lock(); + hr = wined3d_device_set_dialog_box_mode(device->wined3d_device, enable); + wined3d_mutex_unlock(); + + return hr; +} + +static void WINAPI d3d9_device_SetGammaRamp(IDirect3DDevice9Ex *iface, + UINT swapchain, DWORD flags, const D3DGAMMARAMP *ramp) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, swapchain %u, flags %#x, ramp %p.\n", iface, swapchain, flags, ramp); + + /* Note: D3DGAMMARAMP is compatible with struct wined3d_gamma_ramp. */ + wined3d_mutex_lock(); + wined3d_device_set_gamma_ramp(device->wined3d_device, swapchain, flags, (const struct wined3d_gamma_ramp *)ramp); + wined3d_mutex_unlock(); +} + +static void WINAPI d3d9_device_GetGammaRamp(IDirect3DDevice9Ex *iface, UINT swapchain, D3DGAMMARAMP *ramp) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, swapchain %u, ramp %p.\n", iface, swapchain, ramp); + + /* Note: D3DGAMMARAMP is compatible with struct wined3d_gamma_ramp. */ + wined3d_mutex_lock(); + wined3d_device_get_gamma_ramp(device->wined3d_device, swapchain, (struct wined3d_gamma_ramp *)ramp); + wined3d_mutex_unlock(); +} + +#ifdef VBOX_WITH_WDDM +//#pragma comment(linker, "/export:VBoxWineExD3DDev9Flush=_VBoxWineExD3DDev9Flush@4") + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9Flush(IDirect3DDevice9Ex *iface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, Flush\n", iface); + + wined3d_mutex_lock(); + hr = wined3d_device_flush(device->wined3d_device); + wined3d_mutex_unlock(); + + return hr; +} + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9FlushToHost(IDirect3DDevice9Ex *iface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, FlushToHost\n", iface); + + wined3d_mutex_lock(); + hr = wined3d_device_flush_to_host(device->wined3d_device); + wined3d_mutex_unlock(); + + return hr; +} + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9Finish(IDirect3DDevice9Ex *iface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, FlushToHost\n", iface); + + wined3d_mutex_lock(); + hr = wined3d_device_finish(device->wined3d_device); + wined3d_mutex_unlock(); + + return hr; +} + +//#pragma comment(linker, "/export:VBoxWineExD3DDev9CreateTexture=_VBoxWineExD3DDev9CreateTexture@40") + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9CreateTexture(IDirect3DDevice9Ex *iface, + UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, IDirect3DTexture9 **texture, HANDLE *shared_handle, + void **pavClientMem) /* <- extension arg to pass in the client memory buffer, + * applicable ONLY for SYSMEM textures */ +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_texture *object; + HRESULT hr; + + TRACE("iface %p, width %u, height %u, levels %u, usage %#x, format %#x, pool %#x, texture %p, shared_handle %p.\n", + iface, width, height, levels, usage, format, pool, texture, shared_handle); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!object) + return D3DERR_OUTOFVIDEOMEMORY; + + hr = texture_init(object, device, width, height, levels, usage, format, pool, shared_handle, pavClientMem); + if (FAILED(hr)) + { + WARN("Failed to initialize texture, hr %#x.\n", hr); + HeapFree(GetProcessHeap(), 0, object); + return hr; + } + + TRACE("Created texture %p.\n", object); + *texture = (IDirect3DTexture9 *)&object->IDirect3DBaseTexture9_iface; + + return D3D_OK; +} + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9CreateVolumeTexture(IDirect3DDevice9Ex *iface, + UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, IDirect3DVolumeTexture9 **texture, HANDLE *shared_handle, + void **pavClientMem) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_texture *object; + HRESULT hr; + + TRACE("iface %p, width %u, height %u, depth %u, levels %u\n", + iface, width, height, depth, levels); + TRACE("usage %#x, format %#x, pool %#x, texture %p, shared_handle %p.\n", + usage, format, pool, texture, shared_handle); + + if (shared_handle) + FIXME("Resource sharing not implemented, *shared_handle %p.\n", *shared_handle); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!object) + return D3DERR_OUTOFVIDEOMEMORY; + + hr = volumetexture_init(object, device, width, height, depth, levels, usage, format, pool, shared_handle, pavClientMem); + if (FAILED(hr)) + { + WARN("Failed to initialize volume texture, hr %#x.\n", hr); + HeapFree(GetProcessHeap(), 0, object); + return hr; + } + + TRACE("Created volume texture %p.\n", object); + *texture = (IDirect3DVolumeTexture9 *)&object->IDirect3DBaseTexture9_iface; + + return D3D_OK; +} + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9CreateCubeTexture(IDirect3DDevice9Ex *iface, + UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, IDirect3DCubeTexture9 **texture, HANDLE *shared_handle, + void **pavClientMem) /* <- extension arg to pass in the client memory buffer, + * applicable ONLY for SYSMEM textures */ +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_texture *object; + HRESULT hr; + + TRACE("iface %p, edge_length %u, levels %u, usage %#x, format %#x, pool %#x, texture %p, shared_handle %p.\n", + iface, edge_length, levels, usage, format, pool, texture, shared_handle); + + if (shared_handle) + FIXME("Resource sharing not implemented, *shared_handle %p.\n", *shared_handle); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!object) + return D3DERR_OUTOFVIDEOMEMORY; + + hr = cubetexture_init(object, device, edge_length, levels, usage, format, pool, shared_handle, pavClientMem); + if (FAILED(hr)) + { + WARN("Failed to initialize cube texture, hr %#x.\n", hr); + HeapFree(GetProcessHeap(), 0, object); + return hr; + } + + TRACE("Created cube texture %p.\n", object); + *texture = (IDirect3DCubeTexture9 *)&object->IDirect3DBaseTexture9_iface; + + return D3D_OK; +} + +#endif + +static HRESULT WINAPI d3d9_device_CreateTexture(IDirect3DDevice9Ex *iface, + UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, IDirect3DTexture9 **texture, HANDLE *shared_handle) +{ +#ifdef VBOX_WITH_WDDM + return VBoxWineExD3DDev9CreateTexture(iface, width, height, levels, usage, format, + pool, texture, shared_handle, + NULL); +#else + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_texture *object; + BOOL set_mem = FALSE; + HRESULT hr; + + TRACE("iface %p, width %u, height %u, levels %u, usage %#x, format %#x, pool %#x, texture %p, shared_handle %p.\n", + iface, width, height, levels, usage, format, pool, texture, shared_handle); + + if (shared_handle) + { + if (pool == D3DPOOL_SYSTEMMEM) + { + if (levels != 1) + return D3DERR_INVALIDCALL; + set_mem = TRUE; + } + else + FIXME("Resource sharing not implemented, *shared_handle %p.\n", *shared_handle); + } + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!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); + return hr; + } + + if (set_mem) + { + struct wined3d_resource *resource; + struct d3d9_surface *surface; + + resource = wined3d_texture_get_sub_resource(object->wined3d_texture, 0); + surface = wined3d_resource_get_parent(resource); + wined3d_surface_set_mem(surface->wined3d_surface, *shared_handle); + } + + TRACE("Created texture %p.\n", object); + *texture = (IDirect3DTexture9 *)&object->IDirect3DBaseTexture9_iface; + + return D3D_OK; +#endif +} + +static HRESULT WINAPI d3d9_device_CreateVolumeTexture(IDirect3DDevice9Ex *iface, + UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, IDirect3DVolumeTexture9 **texture, HANDLE *shared_handle) +{ +#ifdef VBOX_WITH_WDDM + return VBoxWineExD3DDev9CreateVolumeTexture(iface, width, height, depth, levels, usage, format, + pool, texture, shared_handle, NULL); +#else + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_texture *object; + HRESULT hr; + + TRACE("iface %p, width %u, height %u, depth %u, levels %u\n", + iface, width, height, depth, levels); + TRACE("usage %#x, format %#x, pool %#x, texture %p, shared_handle %p.\n", + usage, format, pool, texture, shared_handle); + + if (shared_handle) + FIXME("Resource sharing not implemented, *shared_handle %p.\n", *shared_handle); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!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); + return hr; + } + + TRACE("Created volume texture %p.\n", object); + *texture = (IDirect3DVolumeTexture9 *)&object->IDirect3DBaseTexture9_iface; + + return D3D_OK; +#endif +} + +static HRESULT WINAPI d3d9_device_CreateCubeTexture(IDirect3DDevice9Ex *iface, + UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool, + IDirect3DCubeTexture9 **texture, HANDLE *shared_handle) +{ +#ifdef VBOX_WITH_WDDM + return VBoxWineExD3DDev9CreateCubeTexture(iface, edge_length, levels, usage, format, + pool, texture, shared_handle, NULL); +#else + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_texture *object; + HRESULT hr; + + TRACE("iface %p, edge_length %u, levels %u, usage %#x, format %#x, pool %#x, texture %p, shared_handle %p.\n", + iface, edge_length, levels, usage, format, pool, texture, shared_handle); + + if (shared_handle) + FIXME("Resource sharing not implemented, *shared_handle %p.\n", *shared_handle); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!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); + return hr; + } + + TRACE("Created cube texture %p.\n", object); + *texture = (IDirect3DCubeTexture9 *)&object->IDirect3DBaseTexture9_iface; + + return D3D_OK; +#endif +} + +static HRESULT WINAPI d3d9_device_CreateVertexBuffer(IDirect3DDevice9Ex *iface, UINT size, + DWORD usage, DWORD fvf, D3DPOOL pool, IDirect3DVertexBuffer9 **buffer, + HANDLE *shared_handle) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_vertexbuffer *object; + HRESULT hr; + + TRACE("iface %p, size %u, usage %#x, fvf %#x, pool %#x, buffer %p, shared_handle %p.\n", + iface, size, usage, fvf, pool, buffer, shared_handle); + + if (shared_handle) + FIXME("Resource sharing not implemented, *shared_handle %p.\n", *shared_handle); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!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); + return hr; + } + + TRACE("Created vertex buffer %p.\n", object); + *buffer = &object->IDirect3DVertexBuffer9_iface; + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_CreateIndexBuffer(IDirect3DDevice9Ex *iface, UINT size, + DWORD usage, D3DFORMAT format, D3DPOOL pool, IDirect3DIndexBuffer9 **buffer, + HANDLE *shared_handle) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_indexbuffer *object; + HRESULT hr; + + TRACE("iface %p, size %u, usage %#x, format %#x, pool %#x, buffer %p, shared_handle %p.\n", + iface, size, usage, format, pool, buffer, shared_handle); + + if (shared_handle) + FIXME("Resource sharing not implemented, *shared_handle %p.\n", *shared_handle); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!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); + return hr; + } + + TRACE("Created index buffer %p.\n", object); + *buffer = &object->IDirect3DIndexBuffer9_iface; + + return D3D_OK; +} + +static HRESULT d3d9_device_create_surface(struct d3d9_device *device, UINT width, UINT height, + D3DFORMAT format, DWORD flags, IDirect3DSurface9 **surface, UINT usage, D3DPOOL pool, + D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality +#ifdef VBOX_WITH_WDDM + , HANDLE *shared_handle + , void *pvClientMem +#endif + ) +{ + struct d3d9_surface *object; + HRESULT hr; + + TRACE("device %p, width %u, height %u, format %#x, flags %#x, surface %p.\n" + "usage %#x, pool %#x, multisample_type %#x, multisample_quality %u.\n", + device, width, height, format, flags, surface, usage, pool, + multisample_type, multisample_quality); + + if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)))) + { + FIXME("Failed to allocate surface memory.\n"); + return D3DERR_OUTOFVIDEOMEMORY; + } + +#ifdef VBOX_WITH_WDDM + if (FAILED(hr = surface_init(object, device, width, height, format, + flags, usage, pool, multisample_type, multisample_quality + , shared_handle + , pvClientMem + ))) +#else + if (FAILED(hr = surface_init(object, device, width, height, format, + flags, usage, pool, multisample_type, multisample_quality))) +#endif + { + WARN("Failed to initialize surface, hr %#x.\n", hr); + HeapFree(GetProcessHeap(), 0, object); + return hr; + } + + TRACE("Created surface %p.\n", object); + *surface = &object->IDirect3DSurface9_iface; + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_CreateRenderTarget(IDirect3DDevice9Ex *iface, UINT width, UINT height, + D3DFORMAT format, D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality, + BOOL lockable, IDirect3DSurface9 **surface, HANDLE *shared_handle) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + DWORD flags = 0; + + TRACE("iface %p, width %u, height %u, format %#x, multisample_type %#x, multisample_quality %u.\n" + "lockable %#x, surface %p, shared_handle %p.\n", + iface, width, height, format, multisample_type, multisample_quality, + lockable, surface, shared_handle); + + if (shared_handle) + FIXME("Resource sharing not implemented, *shared_handle %p.\n", *shared_handle); + + if (lockable) + flags |= WINED3D_SURFACE_MAPPABLE; + + return d3d9_device_create_surface(device, width, height, format, flags, surface, + D3DUSAGE_RENDERTARGET, D3DPOOL_DEFAULT, multisample_type, multisample_quality +#ifdef VBOX_WITH_WDDM + , shared_handle + , NULL +#endif + ); +} + +static HRESULT WINAPI d3d9_device_CreateDepthStencilSurface(IDirect3DDevice9Ex *iface, UINT width, UINT height, + D3DFORMAT format, D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality, + BOOL discard, IDirect3DSurface9 **surface, HANDLE *shared_handle) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + DWORD flags = WINED3D_SURFACE_MAPPABLE; + + TRACE("iface %p, width %u, height %u, format %#x, multisample_type %#x, multisample_quality %u.\n" + "discard %#x, surface %p, shared_handle %p.\n", + iface, width, height, format, multisample_type, multisample_quality, + discard, surface, shared_handle); + + if (shared_handle) + FIXME("Resource sharing not implemented, *shared_handle %p.\n", *shared_handle); + + if (discard) + flags |= WINED3D_SURFACE_DISCARD; + + return d3d9_device_create_surface(device, width, height, format, flags, surface, + D3DUSAGE_DEPTHSTENCIL, D3DPOOL_DEFAULT, multisample_type, multisample_quality +#ifdef VBOX_WITH_WDDM + , shared_handle + , NULL +#endif + ); +} + + +static HRESULT WINAPI d3d9_device_UpdateSurface(IDirect3DDevice9Ex *iface, + IDirect3DSurface9 *src_surface, const RECT *src_rect, + IDirect3DSurface9 *dst_surface, const POINT *dst_point) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_surface *src = unsafe_impl_from_IDirect3DSurface9(src_surface); + struct d3d9_surface *dst = unsafe_impl_from_IDirect3DSurface9(dst_surface); + HRESULT hr; + + TRACE("iface %p, src_surface %p, src_rect %p, dst_surface %p, dst_point %p.\n", + iface, src_surface, src_rect, dst_surface, dst_point); + + wined3d_mutex_lock(); + hr = wined3d_device_update_surface(device->wined3d_device, src->wined3d_surface, src_rect, + dst->wined3d_surface, dst_point); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_UpdateTexture(IDirect3DDevice9Ex *iface, + IDirect3DBaseTexture9 *src_texture, IDirect3DBaseTexture9 *dst_texture) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_texture *src_impl, *dst_impl; + HRESULT hr; + + TRACE("iface %p, src_texture %p, dst_texture %p.\n", iface, src_texture, dst_texture); + + src_impl = unsafe_impl_from_IDirect3DBaseTexture9(src_texture); + dst_impl = unsafe_impl_from_IDirect3DBaseTexture9(dst_texture); + + wined3d_mutex_lock(); + hr = wined3d_device_update_texture(device->wined3d_device, + src_impl->wined3d_texture, dst_impl->wined3d_texture); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetRenderTargetData(IDirect3DDevice9Ex *iface, + IDirect3DSurface9 *render_target, IDirect3DSurface9 *dst_surface) +{ + struct d3d9_surface *rt_impl = unsafe_impl_from_IDirect3DSurface9(render_target); + struct d3d9_surface *dst_impl = unsafe_impl_from_IDirect3DSurface9(dst_surface); + HRESULT hr; + + TRACE("iface %p, render_target %p, dst_surface %p.\n", iface, render_target, dst_surface); + + wined3d_mutex_lock(); + hr = wined3d_surface_get_render_target_data(dst_impl->wined3d_surface, rt_impl->wined3d_surface); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetFrontBufferData(IDirect3DDevice9Ex *iface, + UINT swapchain, IDirect3DSurface9 *dst_surface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_surface *dst_impl = unsafe_impl_from_IDirect3DSurface9(dst_surface); + HRESULT hr; + + TRACE("iface %p, swapchain %u, dst_surface %p.\n", iface, swapchain, dst_surface); + + wined3d_mutex_lock(); + hr = wined3d_device_get_front_buffer_data(device->wined3d_device, swapchain, dst_impl->wined3d_surface); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_StretchRect(IDirect3DDevice9Ex *iface, IDirect3DSurface9 *src_surface, + const RECT *src_rect, IDirect3DSurface9 *dst_surface, const RECT *dst_rect, D3DTEXTUREFILTERTYPE filter) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_surface *src = unsafe_impl_from_IDirect3DSurface9(src_surface); + struct d3d9_surface *dst = unsafe_impl_from_IDirect3DSurface9(dst_surface); + HRESULT hr = D3DERR_INVALIDCALL; + struct wined3d_resource_desc src_desc, dst_desc; + struct wined3d_resource *wined3d_resource; + + TRACE("iface %p, src_surface %p, src_rect %p, dst_surface %p, dst_rect %p, filter %#x.\n", + iface, src_surface, src_rect, dst_surface, dst_rect, filter); + + wined3d_mutex_lock(); + wined3d_resource = wined3d_surface_get_resource(dst->wined3d_surface); + wined3d_resource_get_desc(wined3d_resource, &dst_desc); + + wined3d_resource = wined3d_surface_get_resource(src->wined3d_surface); + wined3d_resource_get_desc(wined3d_resource, &src_desc); + + if (src_desc.usage & WINED3DUSAGE_DEPTHSTENCIL) + { + if (device->in_scene) + { + WARN("Rejecting depth / stencil blit while in scene.\n"); + goto done; + } + + if (src_rect) + { + if (src_rect->left || src_rect->top || src_rect->right != src_desc.width + || src_rect->bottom != src_desc.height) + { + WARN("Rejecting depth / stencil blit with invalid source rect %s.\n", + wine_dbgstr_rect(src_rect)); + goto done; + } + } + if (dst_rect) + { + if (dst_rect->left || dst_rect->top || dst_rect->right != dst_desc.width + || dst_rect->bottom != dst_desc.height) + { + WARN("Rejecting depth / stencil blit with invalid destination rect %s.\n", + wine_dbgstr_rect(dst_rect)); + goto done; + } + } + if (src_desc.width != dst_desc.width || src_desc.height != dst_desc.height) + { + WARN("Rejecting depth / stencil blit with mismatched surface sizes.\n"); + goto done; + } + } + + hr = wined3d_surface_blt(dst->wined3d_surface, dst_rect, src->wined3d_surface, src_rect, 0, NULL, filter); + if (hr == WINEDDERR_INVALIDRECT) + hr = D3DERR_INVALIDCALL; + +done: + wined3d_mutex_unlock(); + return hr; +} + +static HRESULT WINAPI d3d9_device_ColorFill(IDirect3DDevice9Ex *iface, + IDirect3DSurface9 *surface, const RECT *rect, D3DCOLOR color) +{ + const struct wined3d_color c = + { + ((color >> 16) & 0xff) / 255.0f, + ((color >> 8) & 0xff) / 255.0f, + (color & 0xff) / 255.0f, + ((color >> 24) & 0xff) / 255.0f, + }; + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_surface *surface_impl = unsafe_impl_from_IDirect3DSurface9(surface); + struct wined3d_resource *wined3d_resource; + struct wined3d_resource_desc desc; + HRESULT hr; + + TRACE("iface %p, surface %p, rect %p, color 0x%08x.\n", iface, surface, rect, color); + + wined3d_mutex_lock(); + + wined3d_resource = wined3d_surface_get_resource(surface_impl->wined3d_surface); + wined3d_resource_get_desc(wined3d_resource, &desc); + + /* This method is only allowed with surfaces that are render targets, or + * offscreen plain surfaces in D3DPOOL_DEFAULT. */ + if (!(desc.usage & WINED3DUSAGE_RENDERTARGET) && desc.pool != WINED3D_POOL_DEFAULT) + { + wined3d_mutex_unlock(); + WARN("Surface is not a render target, or not a stand-alone D3DPOOL_DEFAULT surface\n"); + return D3DERR_INVALIDCALL; + } + + /* Colorfill can only be used on rendertarget surfaces, or offscreen plain surfaces in D3DPOOL_DEFAULT */ + hr = wined3d_device_color_fill(device->wined3d_device, surface_impl->wined3d_surface, rect, &c); + + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_CreateOffscreenPlainSurface(IDirect3DDevice9Ex *iface, + UINT width, UINT height, D3DFORMAT format, D3DPOOL pool, IDirect3DSurface9 **surface, + HANDLE *shared_handle) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, width %u, height %u, format %#x, pool %#x, surface %p, shared_handle %p.\n", + iface, width, height, format, pool, surface, shared_handle); + + if (shared_handle) + FIXME("Resource sharing not implemented, *shared_handle %p.\n", *shared_handle); + + if (pool == D3DPOOL_MANAGED) + { + WARN("Attempting to create a managed offscreen plain surface.\n"); + return D3DERR_INVALIDCALL; + } + /* FIXME: Offscreen surfaces are supposed to be always lockable, + * regardless of the pool they're created in. Should we set dynamic usage + * here? */ + return d3d9_device_create_surface(device, width, height, format, + WINED3D_SURFACE_MAPPABLE, surface, 0, pool, D3DMULTISAMPLE_NONE, 0 +#ifdef VBOX_WITH_WDDM + , shared_handle + , NULL +#endif + ); +} + +static HRESULT WINAPI d3d9_device_SetRenderTarget(IDirect3DDevice9Ex *iface, DWORD idx, IDirect3DSurface9 *surface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_surface *surface_impl = unsafe_impl_from_IDirect3DSurface9(surface); + HRESULT hr; + + TRACE("iface %p, idx %u, surface %p.\n", iface, idx, surface); + + if (idx >= D3D9_MAX_SIMULTANEOUS_RENDERTARGETS) + { + WARN("Invalid index %u specified.\n", idx); + return D3DERR_INVALIDCALL; + } + + wined3d_mutex_lock(); + hr = wined3d_device_set_render_target(device->wined3d_device, idx, + surface_impl ? surface_impl->wined3d_surface : NULL, TRUE); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetRenderTarget(IDirect3DDevice9Ex *iface, DWORD idx, IDirect3DSurface9 **surface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct wined3d_surface *wined3d_surface; + struct d3d9_surface *surface_impl; + HRESULT hr = D3D_OK; + + TRACE("iface %p, idx %u, surface %p.\n", iface, idx, surface); + + if (!surface) + return D3DERR_INVALIDCALL; + + if (idx >= D3D9_MAX_SIMULTANEOUS_RENDERTARGETS) + { + WARN("Invalid index %u specified.\n", idx); + return D3DERR_INVALIDCALL; + } + + wined3d_mutex_lock(); + if ((wined3d_surface = wined3d_device_get_render_target(device->wined3d_device, idx))) + { + surface_impl = wined3d_surface_get_parent(wined3d_surface); + *surface = &surface_impl->IDirect3DSurface9_iface; + IDirect3DSurface9_AddRef(*surface); + } + else + { + hr = WINED3DERR_NOTFOUND; + *surface = NULL; + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_SetDepthStencilSurface(IDirect3DDevice9Ex *iface, IDirect3DSurface9 *depth_stencil) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_surface *ds_impl = unsafe_impl_from_IDirect3DSurface9(depth_stencil); + + TRACE("iface %p, depth_stencil %p.\n", iface, depth_stencil); + + wined3d_mutex_lock(); + wined3d_device_set_depth_stencil(device->wined3d_device, ds_impl ? ds_impl->wined3d_surface : NULL); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_GetDepthStencilSurface(IDirect3DDevice9Ex *iface, IDirect3DSurface9 **depth_stencil) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct wined3d_surface *wined3d_surface; + struct d3d9_surface *surface_impl; + HRESULT hr = D3D_OK; + + TRACE("iface %p, depth_stencil %p.\n", iface, depth_stencil); + + if (!depth_stencil) + return D3DERR_INVALIDCALL; + + wined3d_mutex_lock(); + if ((wined3d_surface = wined3d_device_get_depth_stencil(device->wined3d_device))) + { + surface_impl = wined3d_surface_get_parent(wined3d_surface); + *depth_stencil = &surface_impl->IDirect3DSurface9_iface; + IDirect3DSurface9_AddRef(*depth_stencil); + } + else + { + hr = WINED3DERR_NOTFOUND; + *depth_stencil = NULL; + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_BeginScene(IDirect3DDevice9Ex *iface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + if (SUCCEEDED(hr = wined3d_device_begin_scene(device->wined3d_device))) + device->in_scene = TRUE; + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_device_EndScene(IDirect3DDevice9Ex *iface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + if (SUCCEEDED(hr = wined3d_device_end_scene(device->wined3d_device))) + device->in_scene = FALSE; + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_Clear(IDirect3DDevice9Ex *iface, DWORD rect_count, + const D3DRECT *rects, DWORD flags, D3DCOLOR color, float z, DWORD stencil) +{ + const struct wined3d_color c = + { + ((color >> 16) & 0xff) / 255.0f, + ((color >> 8) & 0xff) / 255.0f, + (color & 0xff) / 255.0f, + ((color >> 24) & 0xff) / 255.0f, + }; + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, rect_count %u, rects %p, flags %#x, color 0x%08x, z %.8e, stencil %u.\n", + iface, rect_count, rects, flags, color, z, stencil); + + wined3d_mutex_lock(); + hr = wined3d_device_clear(device->wined3d_device, rect_count, (const RECT *)rects, flags, &c, z, stencil); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_SetTransform(IDirect3DDevice9Ex *iface, + D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix); + + /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */ + wined3d_mutex_lock(); + wined3d_device_set_transform(device->wined3d_device, state, (const struct wined3d_matrix *)matrix); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_GetTransform(IDirect3DDevice9Ex *iface, + D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix); + + /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */ + wined3d_mutex_lock(); + wined3d_device_get_transform(device->wined3d_device, state, (struct wined3d_matrix *)matrix); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_MultiplyTransform(IDirect3DDevice9Ex *iface, + D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix); + + /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */ + wined3d_mutex_lock(); + wined3d_device_multiply_transform(device->wined3d_device, state, (const struct wined3d_matrix *)matrix); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_SetViewport(IDirect3DDevice9Ex *iface, const D3DVIEWPORT9 *viewport) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, viewport %p.\n", iface, viewport); + + /* Note: D3DVIEWPORT9 is compatible with struct wined3d_viewport. */ + wined3d_mutex_lock(); + wined3d_device_set_viewport(device->wined3d_device, (const struct wined3d_viewport *)viewport); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_GetViewport(IDirect3DDevice9Ex *iface, D3DVIEWPORT9 *viewport) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, viewport %p.\n", iface, viewport); + + /* Note: D3DVIEWPORT9 is compatible with struct wined3d_viewport. */ + wined3d_mutex_lock(); + wined3d_device_get_viewport(device->wined3d_device, (struct wined3d_viewport *)viewport); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_SetMaterial(IDirect3DDevice9Ex *iface, const D3DMATERIAL9 *material) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, material %p.\n", iface, material); + + /* Note: D3DMATERIAL9 is compatible with struct wined3d_material. */ + wined3d_mutex_lock(); + wined3d_device_set_material(device->wined3d_device, (const struct wined3d_material *)material); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_GetMaterial(IDirect3DDevice9Ex *iface, D3DMATERIAL9 *material) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, material %p.\n", iface, material); + + /* Note: D3DMATERIAL9 is compatible with struct wined3d_material. */ + wined3d_mutex_lock(); + wined3d_device_get_material(device->wined3d_device, (struct wined3d_material *)material); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_SetLight(IDirect3DDevice9Ex *iface, DWORD index, const D3DLIGHT9 *light) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, index %u, light %p.\n", iface, index, light); + + /* Note: D3DLIGHT9 is compatible with struct wined3d_light. */ + wined3d_mutex_lock(); + hr = wined3d_device_set_light(device->wined3d_device, index, (const struct wined3d_light *)light); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetLight(IDirect3DDevice9Ex *iface, DWORD index, D3DLIGHT9 *light) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, index %u, light %p.\n", iface, index, light); + + /* Note: D3DLIGHT9 is compatible with struct wined3d_light. */ + wined3d_mutex_lock(); + hr = wined3d_device_get_light(device->wined3d_device, index, (struct wined3d_light *)light); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_LightEnable(IDirect3DDevice9Ex *iface, DWORD index, BOOL enable) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, index %u, enable %#x.\n", iface, index, enable); + + wined3d_mutex_lock(); + hr = wined3d_device_set_light_enable(device->wined3d_device, index, enable); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetLightEnable(IDirect3DDevice9Ex *iface, DWORD index, BOOL *enable) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, index %u, enable %p.\n", iface, index, enable); + + wined3d_mutex_lock(); + hr = wined3d_device_get_light_enable(device->wined3d_device, index, enable); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_SetClipPlane(IDirect3DDevice9Ex *iface, DWORD index, const float *plane) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, index %u, plane %p.\n", iface, index, plane); + + wined3d_mutex_lock(); + hr = wined3d_device_set_clip_plane(device->wined3d_device, index, (const struct wined3d_vec4 *)plane); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetClipPlane(IDirect3DDevice9Ex *iface, DWORD index, float *plane) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, index %u, plane %p.\n", iface, index, plane); + + wined3d_mutex_lock(); + hr = wined3d_device_get_clip_plane(device->wined3d_device, index, (struct wined3d_vec4 *)plane); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_device_SetRenderState(IDirect3DDevice9Ex *iface, + D3DRENDERSTATETYPE state, DWORD value) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, state %#x, value %#x.\n", iface, state, value); + + wined3d_mutex_lock(); + wined3d_device_set_render_state(device->wined3d_device, state, value); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_GetRenderState(IDirect3DDevice9Ex *iface, + D3DRENDERSTATETYPE state, DWORD *value) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, state %#x, value %p.\n", iface, state, value); + + wined3d_mutex_lock(); + *value = wined3d_device_get_render_state(device->wined3d_device, state); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_CreateStateBlock(IDirect3DDevice9Ex *iface, + D3DSTATEBLOCKTYPE type, IDirect3DStateBlock9 **stateblock) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_stateblock *object; + HRESULT hr; + + TRACE("iface %p, type %#x, stateblock %p.\n", iface, type, stateblock); + + if (type != D3DSBT_ALL && type != D3DSBT_PIXELSTATE && type != D3DSBT_VERTEXSTATE) + { + WARN("Unexpected stateblock type, returning D3DERR_INVALIDCALL.\n"); + return D3DERR_INVALIDCALL; + } + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!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); + return hr; + } + + TRACE("Created stateblock %p.\n", object); + *stateblock = &object->IDirect3DStateBlock9_iface; + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_BeginStateBlock(IDirect3DDevice9Ex *iface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + hr = wined3d_device_begin_stateblock(device->wined3d_device); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_EndStateBlock(IDirect3DDevice9Ex *iface, IDirect3DStateBlock9 **stateblock) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct wined3d_stateblock *wined3d_stateblock; + struct d3d9_stateblock *object; + HRESULT hr; + + TRACE("iface %p, stateblock %p.\n", iface, stateblock); + + wined3d_mutex_lock(); + hr = wined3d_device_end_stateblock(device->wined3d_device, &wined3d_stateblock); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("IWineD3DDevice_EndStateBlock() failed, hr %#x.\n", hr); + return hr; + } + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!object) + { + wined3d_mutex_lock(); + wined3d_stateblock_decref(wined3d_stateblock); + wined3d_mutex_unlock(); + return E_OUTOFMEMORY; + } + + hr = stateblock_init(object, device, 0, wined3d_stateblock); + if (FAILED(hr)) + { + WARN("Failed to initialize stateblock, hr %#x.\n", hr); + wined3d_mutex_lock(); + wined3d_stateblock_decref(wined3d_stateblock); + wined3d_mutex_unlock(); + HeapFree(GetProcessHeap(), 0, object); + return hr; + } + + TRACE("Created stateblock %p.\n", object); + *stateblock = &object->IDirect3DStateBlock9_iface; + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_SetClipStatus(IDirect3DDevice9Ex *iface, const D3DCLIPSTATUS9 *clip_status) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, clip_status %p.\n", iface, clip_status); + + wined3d_mutex_lock(); + hr = wined3d_device_set_clip_status(device->wined3d_device, (const struct wined3d_clip_status *)clip_status); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetClipStatus(IDirect3DDevice9Ex *iface, D3DCLIPSTATUS9 *clip_status) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, clip_status %p.\n", iface, clip_status); + + wined3d_mutex_lock(); + hr = wined3d_device_get_clip_status(device->wined3d_device, (struct wined3d_clip_status *)clip_status); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetTexture(IDirect3DDevice9Ex *iface, DWORD stage, IDirect3DBaseTexture9 **texture) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct wined3d_texture *wined3d_texture = NULL; + struct d3d9_texture *texture_impl; + + TRACE("iface %p, stage %u, texture %p.\n", iface, stage, texture); + + if (!texture) + return D3DERR_INVALIDCALL; + + wined3d_mutex_lock(); + if ((wined3d_texture = wined3d_device_get_texture(device->wined3d_device, stage))) + { + texture_impl = wined3d_texture_get_parent(wined3d_texture); + *texture = &texture_impl->IDirect3DBaseTexture9_iface; + IDirect3DBaseTexture9_AddRef(*texture); + } + else + { + *texture = NULL; + } + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_SetTexture(IDirect3DDevice9Ex *iface, DWORD stage, IDirect3DBaseTexture9 *texture) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_texture *texture_impl; + HRESULT hr; + + TRACE("iface %p, stage %u, texture %p.\n", iface, stage, texture); + + texture_impl = unsafe_impl_from_IDirect3DBaseTexture9(texture); + + wined3d_mutex_lock(); + hr = wined3d_device_set_texture(device->wined3d_device, stage, + texture_impl ? texture_impl->wined3d_texture : NULL); + wined3d_mutex_unlock(); + + return hr; +} + +static const enum wined3d_texture_stage_state tss_lookup[] = +{ + WINED3D_TSS_INVALID, /* 0, unused */ + WINED3D_TSS_COLOR_OP, /* 1, D3DTSS_COLOROP */ + WINED3D_TSS_COLOR_ARG1, /* 2, D3DTSS_COLORARG1 */ + WINED3D_TSS_COLOR_ARG2, /* 3, D3DTSS_COLORARG2 */ + WINED3D_TSS_ALPHA_OP, /* 4, D3DTSS_ALPHAOP */ + WINED3D_TSS_ALPHA_ARG1, /* 5, D3DTSS_ALPHAARG1 */ + WINED3D_TSS_ALPHA_ARG2, /* 6, D3DTSS_ALPHAARG2 */ + WINED3D_TSS_BUMPENV_MAT00, /* 7, D3DTSS_BUMPENVMAT00 */ + WINED3D_TSS_BUMPENV_MAT01, /* 8, D3DTSS_BUMPENVMAT01 */ + WINED3D_TSS_BUMPENV_MAT10, /* 9, D3DTSS_BUMPENVMAT10 */ + WINED3D_TSS_BUMPENV_MAT11, /* 10, D3DTSS_BUMPENVMAT11 */ + WINED3D_TSS_TEXCOORD_INDEX, /* 11, D3DTSS_TEXCOORDINDEX */ + WINED3D_TSS_INVALID, /* 12, unused */ + WINED3D_TSS_INVALID, /* 13, unused */ + WINED3D_TSS_INVALID, /* 14, unused */ + WINED3D_TSS_INVALID, /* 15, unused */ + WINED3D_TSS_INVALID, /* 16, unused */ + WINED3D_TSS_INVALID, /* 17, unused */ + WINED3D_TSS_INVALID, /* 18, unused */ + WINED3D_TSS_INVALID, /* 19, unused */ + WINED3D_TSS_INVALID, /* 20, unused */ + WINED3D_TSS_INVALID, /* 21, unused */ + WINED3D_TSS_BUMPENV_LSCALE, /* 22, D3DTSS_BUMPENVLSCALE */ + WINED3D_TSS_BUMPENV_LOFFSET, /* 23, D3DTSS_BUMPENVLOFFSET */ + WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS, /* 24, D3DTSS_TEXTURETRANSFORMFLAGS */ + WINED3D_TSS_INVALID, /* 25, unused */ + WINED3D_TSS_COLOR_ARG0, /* 26, D3DTSS_COLORARG0 */ + WINED3D_TSS_ALPHA_ARG0, /* 27, D3DTSS_ALPHAARG0 */ + WINED3D_TSS_RESULT_ARG, /* 28, D3DTSS_RESULTARG */ + WINED3D_TSS_INVALID, /* 29, unused */ + WINED3D_TSS_INVALID, /* 30, unused */ + WINED3D_TSS_INVALID, /* 31, unused */ + WINED3D_TSS_CONSTANT, /* 32, D3DTSS_CONSTANT */ +}; + +static HRESULT WINAPI d3d9_device_GetTextureStageState(IDirect3DDevice9Ex *iface, + DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD *value) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, stage %u, state %#x, value %p.\n", iface, stage, state, value); + + if (state >= sizeof(tss_lookup) / sizeof(*tss_lookup)) + { + WARN("Invalid state %#x passed.\n", state); + return D3D_OK; + } + + wined3d_mutex_lock(); + *value = wined3d_device_get_texture_stage_state(device->wined3d_device, stage, tss_lookup[state]); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_SetTextureStageState(IDirect3DDevice9Ex *iface, + DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD value) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, stage %u, state %#x, value %#x.\n", iface, stage, state, value); + + if (state >= sizeof(tss_lookup) / sizeof(*tss_lookup)) + { + WARN("Invalid state %#x passed.\n", state); + return D3D_OK; + } + + wined3d_mutex_lock(); + wined3d_device_set_texture_stage_state(device->wined3d_device, stage, tss_lookup[state], value); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_GetSamplerState(IDirect3DDevice9Ex *iface, + DWORD sampler, D3DSAMPLERSTATETYPE state, DWORD *value) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, sampler %u, state %#x, value %p.\n", iface, sampler, state, value); + + wined3d_mutex_lock(); + *value = wined3d_device_get_sampler_state(device->wined3d_device, sampler, state); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_device_SetSamplerState(IDirect3DDevice9Ex *iface, + DWORD sampler, D3DSAMPLERSTATETYPE state, DWORD value) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, sampler %u, state %#x, value %#x.\n", iface, sampler, state, value); + + wined3d_mutex_lock(); + wined3d_device_set_sampler_state(device->wined3d_device, sampler, state, value); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_ValidateDevice(IDirect3DDevice9Ex *iface, DWORD *pass_count) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, pass_count %p.\n", iface, pass_count); + + wined3d_mutex_lock(); + hr = wined3d_device_validate_device(device->wined3d_device, pass_count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_SetPaletteEntries(IDirect3DDevice9Ex *iface, + UINT palette_idx, const PALETTEENTRY *entries) +{ + WARN("iface %p, palette_idx %u, entries %p unimplemented.\n", iface, palette_idx, entries); + + /* The d3d9 palette API is non-functional on Windows. Getters and setters are implemented, + * and some drivers allow the creation of P8 surfaces. These surfaces can be copied to + * other P8 surfaces with StretchRect, but cannot be converted to (A)RGB. + * + * Some older(dx7) cards may have support for P8 textures, but games cannot rely on this. */ + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_GetPaletteEntries(IDirect3DDevice9Ex *iface, + UINT palette_idx, PALETTEENTRY *entries) +{ + FIXME("iface %p, palette_idx %u, entries %p unimplemented.\n", iface, palette_idx, entries); + + return D3DERR_INVALIDCALL; +} + +static HRESULT WINAPI d3d9_device_SetCurrentTexturePalette(IDirect3DDevice9Ex *iface, UINT palette_idx) +{ + WARN("iface %p, palette_idx %u unimplemented.\n", iface, palette_idx); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_GetCurrentTexturePalette(IDirect3DDevice9Ex *iface, UINT *palette_idx) +{ + FIXME("iface %p, palette_idx %p.\n", iface, palette_idx); + + return D3DERR_INVALIDCALL; +} + +static HRESULT WINAPI d3d9_device_SetScissorRect(IDirect3DDevice9Ex *iface, const RECT *rect) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, rect %p.\n", iface, rect); + + wined3d_mutex_lock(); + wined3d_device_set_scissor_rect(device->wined3d_device, rect); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_GetScissorRect(IDirect3DDevice9Ex *iface, RECT *rect) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, rect %p.\n", iface, rect); + + wined3d_mutex_lock(); + wined3d_device_get_scissor_rect(device->wined3d_device, rect); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_SetSoftwareVertexProcessing(IDirect3DDevice9Ex *iface, BOOL software) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + + TRACE("iface %p, software %#x.\n", iface, software); + + wined3d_mutex_lock(); + wined3d_device_set_software_vertex_processing(device->wined3d_device, software); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static BOOL WINAPI d3d9_device_GetSoftwareVertexProcessing(IDirect3DDevice9Ex *iface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + BOOL ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_device_get_software_vertex_processing(device->wined3d_device); + wined3d_mutex_unlock(); + + return ret; +} + +static HRESULT WINAPI d3d9_device_SetNPatchMode(IDirect3DDevice9Ex *iface, float segment_count) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, segment_count %.8e.\n", iface, segment_count); + + wined3d_mutex_lock(); + hr = wined3d_device_set_npatch_mode(device->wined3d_device, segment_count); + wined3d_mutex_unlock(); + + return hr; +} + +static float WINAPI d3d9_device_GetNPatchMode(IDirect3DDevice9Ex *iface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + float ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_device_get_npatch_mode(device->wined3d_device); + wined3d_mutex_unlock(); + + return ret; +} + +static HRESULT WINAPI d3d9_device_DrawPrimitive(IDirect3DDevice9Ex *iface, + D3DPRIMITIVETYPE primitive_type, UINT start_vertex, UINT primitive_count) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, primitive_type %#x, start_vertex %u, primitive_count %u.\n", + iface, primitive_type, start_vertex, primitive_count); + + wined3d_mutex_lock(); + wined3d_device_set_primitive_type(device->wined3d_device, primitive_type); + hr = wined3d_device_draw_primitive(device->wined3d_device, start_vertex, + vertex_count_from_primitive_count(primitive_type, primitive_count)); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_DrawIndexedPrimitive(IDirect3DDevice9Ex *iface, + D3DPRIMITIVETYPE primitive_type, INT base_vertex_idx, UINT min_vertex_idx, + UINT vertex_count, UINT start_idx, UINT primitive_count) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, primitive_type %#x, base_vertex_idx %u, min_vertex_idx %u,\n" + "vertex_count %u, start_idx %u, primitive_count %u.\n", + iface, primitive_type, base_vertex_idx, min_vertex_idx, + vertex_count, start_idx, primitive_count); + + wined3d_mutex_lock(); + wined3d_device_set_base_vertex_index(device->wined3d_device, base_vertex_idx); + wined3d_device_set_primitive_type(device->wined3d_device, primitive_type); + hr = wined3d_device_draw_indexed_primitive(device->wined3d_device, start_idx, + vertex_count_from_primitive_count(primitive_type, primitive_count)); + wined3d_mutex_unlock(); + + return hr; +} + +static void STDMETHODCALLTYPE d3d9_null_wined3d_object_destroyed(void *parent) {} + +static const struct wined3d_parent_ops d3d9_null_wined3d_parent_ops = +{ + d3d9_null_wined3d_object_destroyed, +}; + +/* The caller is responsible for wined3d locking */ +static HRESULT d3d9_device_prepare_vertex_buffer(struct d3d9_device *device, UINT min_size) +{ + HRESULT hr; + + if (device->vertex_buffer_size < min_size || !device->vertex_buffer) + { + UINT size = max(device->vertex_buffer_size * 2, min_size); + 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)) + { + ERR("(%p) wined3d_buffer_create_vb failed with hr = %08x\n", device, hr); + return hr; + } + + if (device->vertex_buffer) + wined3d_buffer_decref(device->vertex_buffer); + + device->vertex_buffer = buffer; + device->vertex_buffer_size = size; + device->vertex_buffer_pos = 0; + } + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_DrawPrimitiveUP(IDirect3DDevice9Ex *iface, + D3DPRIMITIVETYPE primitive_type, UINT primitive_count, const void *data, UINT stride) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + UINT vtx_count = vertex_count_from_primitive_count(primitive_type, primitive_count); + UINT size = vtx_count * stride; + UINT vb_pos, align; + BYTE *buffer_data; + + TRACE("iface %p, primitive_type %#x, primitive_count %u, data %p, stride %u.\n", + iface, primitive_type, primitive_count, data, stride); + + if (!primitive_count) + { + WARN("primitive_count is 0, returning D3D_OK\n"); + return D3D_OK; + } + + wined3d_mutex_lock(); + + hr = d3d9_device_prepare_vertex_buffer(device, size); + if (FAILED(hr)) + goto done; + + vb_pos = device->vertex_buffer_pos; + align = vb_pos % stride; + if (align) align = stride - align; + if (vb_pos + size + align > device->vertex_buffer_size) + vb_pos = 0; + else + vb_pos += align; + + hr = wined3d_buffer_map(device->vertex_buffer, vb_pos, size, &buffer_data, + vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD); + if (FAILED(hr)) + goto done; + memcpy(buffer_data, data, size); + wined3d_buffer_unmap(device->vertex_buffer); + device->vertex_buffer_pos = vb_pos + size; + + hr = wined3d_device_set_stream_source(device->wined3d_device, 0, device->vertex_buffer, 0, stride); + if (FAILED(hr)) + goto done; + + wined3d_device_set_primitive_type(device->wined3d_device, primitive_type); + 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); + +done: + wined3d_mutex_unlock(); + return hr; +} + +/* The caller is responsible for wined3d locking */ +static HRESULT d3d9_device_prepare_index_buffer(struct d3d9_device *device, UINT min_size) +{ + HRESULT hr; + + if (device->index_buffer_size < min_size || !device->index_buffer) + { + UINT size = max(device->index_buffer_size * 2, min_size); + 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)) + { + ERR("(%p) wined3d_buffer_create_ib failed with hr = %08x\n", device, hr); + return hr; + } + + if (device->index_buffer) + wined3d_buffer_decref(device->index_buffer); + + device->index_buffer = buffer; + device->index_buffer_size = size; + device->index_buffer_pos = 0; + } + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_DrawIndexedPrimitiveUP(IDirect3DDevice9Ex *iface, + D3DPRIMITIVETYPE primitive_type, UINT min_vertex_idx, UINT vertex_count, + UINT primitive_count, const void *index_data, D3DFORMAT index_format, + const void *vertex_data, UINT vertex_stride) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + BYTE *buffer_data; + + UINT idx_count = vertex_count_from_primitive_count(primitive_type, primitive_count); + UINT idx_fmt_size = index_format == D3DFMT_INDEX16 ? 2 : 4; + UINT idx_size = idx_count * idx_fmt_size; + UINT ib_pos; + + UINT vtx_size = vertex_count * vertex_stride; + UINT vb_pos, align; + + TRACE("iface %p, primitive_type %#x, min_vertex_idx %u, vertex_count %u, primitive_count %u,\n" + "index_data %p, index_format %#x, vertex_data %p, vertex_stride %u.\n", + iface, primitive_type, min_vertex_idx, vertex_count, primitive_count, + index_data, index_format, vertex_data, vertex_stride); + + if (!primitive_count) + { + WARN("primitive_count is 0, returning D3D_OK\n"); + return D3D_OK; + } + + wined3d_mutex_lock(); + + hr = d3d9_device_prepare_vertex_buffer(device, vtx_size); + if (FAILED(hr)) + goto done; + + vb_pos = device->vertex_buffer_pos; + align = vb_pos % vertex_stride; + if (align) align = vertex_stride - align; + if (vb_pos + vtx_size + align > device->vertex_buffer_size) + vb_pos = 0; + else + vb_pos += align; + + hr = wined3d_buffer_map(device->vertex_buffer, vb_pos, vtx_size, &buffer_data, + vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD); + if (FAILED(hr)) + goto done; + memcpy(buffer_data, vertex_data, vtx_size); + wined3d_buffer_unmap(device->vertex_buffer); + device->vertex_buffer_pos = vb_pos + vtx_size; + + hr = d3d9_device_prepare_index_buffer(device, idx_size); + if (FAILED(hr)) + goto done; + + ib_pos = device->index_buffer_pos; + align = ib_pos % idx_fmt_size; + if (align) align = idx_fmt_size - align; + if (ib_pos + idx_size + align > device->index_buffer_size) + ib_pos = 0; + else + ib_pos += align; + + hr = wined3d_buffer_map(device->index_buffer, ib_pos, idx_size, &buffer_data, + ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD); + if (FAILED(hr)) + goto done; + memcpy(buffer_data, index_data, idx_size); + wined3d_buffer_unmap(device->index_buffer); + device->index_buffer_pos = ib_pos + idx_size; + + hr = wined3d_device_set_stream_source(device->wined3d_device, 0, device->vertex_buffer, 0, vertex_stride); + if (FAILED(hr)) + goto done; + + wined3d_device_set_index_buffer(device->wined3d_device, device->index_buffer, + wined3dformat_from_d3dformat(index_format)); + wined3d_device_set_base_vertex_index(device->wined3d_device, vb_pos / vertex_stride); + + wined3d_device_set_primitive_type(device->wined3d_device, primitive_type); + hr = wined3d_device_draw_indexed_primitive(device->wined3d_device, ib_pos / idx_fmt_size, idx_count); + + wined3d_device_set_stream_source(device->wined3d_device, 0, NULL, 0, 0); + wined3d_device_set_index_buffer(device->wined3d_device, NULL, WINED3DFMT_UNKNOWN); + wined3d_device_set_base_vertex_index(device->wined3d_device, 0); + +done: + wined3d_mutex_unlock(); + return hr; +} + +static HRESULT WINAPI d3d9_device_ProcessVertices(IDirect3DDevice9Ex *iface, + UINT src_start_idx, UINT dst_idx, UINT vertex_count, IDirect3DVertexBuffer9 *dst_buffer, + IDirect3DVertexDeclaration9 *declaration, DWORD flags) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_vertexbuffer *dst_impl = unsafe_impl_from_IDirect3DVertexBuffer9(dst_buffer); + struct d3d9_vertex_declaration *decl_impl = unsafe_impl_from_IDirect3DVertexDeclaration9(declaration); + HRESULT hr; + + TRACE("iface %p, src_start_idx %u, dst_idx %u, vertex_count %u, dst_buffer %p, declaration %p, flags %#x.\n", + iface, src_start_idx, dst_idx, vertex_count, dst_buffer, declaration, flags); + + wined3d_mutex_lock(); + hr = wined3d_device_process_vertices(device->wined3d_device, src_start_idx, dst_idx, vertex_count, + dst_impl->wined3d_buffer, decl_impl ? decl_impl->wined3d_declaration : NULL, + flags, dst_impl->fvf); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_CreateVertexDeclaration(IDirect3DDevice9Ex *iface, + const D3DVERTEXELEMENT9 *elements, IDirect3DVertexDeclaration9 **declaration) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_vertex_declaration *object; + HRESULT hr; + + TRACE("iface %p, elements %p, declaration %p.\n", iface, elements, declaration); + + if (!declaration) + { + WARN("Caller passed a NULL declaration, returning D3DERR_INVALIDCALL.\n"); + return D3DERR_INVALIDCALL; + } + + if (SUCCEEDED(hr = d3d9_vertex_declaration_create(device, elements, &object))) + *declaration = &object->IDirect3DVertexDeclaration9_iface; + + return hr; +} + +static HRESULT WINAPI d3d9_device_SetVertexDeclaration(IDirect3DDevice9Ex *iface, + IDirect3DVertexDeclaration9 *declaration) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_vertex_declaration *decl_impl = unsafe_impl_from_IDirect3DVertexDeclaration9(declaration); + + TRACE("iface %p, declaration %p.\n", iface, declaration); + + wined3d_mutex_lock(); + wined3d_device_set_vertex_declaration(device->wined3d_device, + decl_impl ? decl_impl->wined3d_declaration : NULL); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_GetVertexDeclaration(IDirect3DDevice9Ex *iface, + IDirect3DVertexDeclaration9 **declaration) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct wined3d_vertex_declaration *wined3d_declaration; + struct d3d9_vertex_declaration *declaration_impl; + + TRACE("iface %p, declaration %p.\n", iface, declaration); + + if (!declaration) return D3DERR_INVALIDCALL; + + wined3d_mutex_lock(); + if ((wined3d_declaration = wined3d_device_get_vertex_declaration(device->wined3d_device))) + { + declaration_impl = wined3d_vertex_declaration_get_parent(wined3d_declaration); + *declaration = &declaration_impl->IDirect3DVertexDeclaration9_iface; + IDirect3DVertexDeclaration9_AddRef(*declaration); + } + else + { + *declaration = NULL; + } + wined3d_mutex_unlock(); + + TRACE("Returning %p.\n", *declaration); + return D3D_OK; +} + +static struct wined3d_vertex_declaration *device_get_fvf_declaration(struct d3d9_device *device, DWORD fvf) +{ + struct wined3d_vertex_declaration *wined3d_declaration; + struct fvf_declaration *fvf_decls = device->fvf_decls; + struct d3d9_vertex_declaration *d3d9_declaration; + D3DVERTEXELEMENT9 *elements; + int p, low, high; /* deliberately signed */ + HRESULT hr; + + TRACE("Searching for declaration for fvf %08x... ", fvf); + + low = 0; + high = device->fvf_decl_count - 1; + while (low <= high) + { + p = (low + high) >> 1; + TRACE("%d ", p); + + if (fvf_decls[p].fvf == fvf) + { + TRACE("found %p.\n", fvf_decls[p].decl); + return fvf_decls[p].decl; + } + + if (fvf_decls[p].fvf < fvf) + low = p + 1; + else + high = p - 1; + } + TRACE("not found. Creating and inserting at position %d.\n", low); + + if (FAILED(hr = vdecl_convert_fvf(fvf, &elements))) + return NULL; + + hr = d3d9_vertex_declaration_create(device, elements, &d3d9_declaration); + HeapFree(GetProcessHeap(), 0, elements); + if (FAILED(hr)) + return NULL; + + if (device->fvf_decl_size == device->fvf_decl_count) + { + 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) + { + IDirect3DVertexDeclaration9_Release(&d3d9_declaration->IDirect3DVertexDeclaration9_iface); + return NULL; + } + device->fvf_decls = fvf_decls; + device->fvf_decl_size += grow; + } + + d3d9_declaration->fvf = fvf; + wined3d_declaration = d3d9_declaration->wined3d_declaration; + wined3d_vertex_declaration_incref(wined3d_declaration); + IDirect3DVertexDeclaration9_Release(&d3d9_declaration->IDirect3DVertexDeclaration9_iface); + + memmove(fvf_decls + low + 1, fvf_decls + low, sizeof(*fvf_decls) * (device->fvf_decl_count - low)); + fvf_decls[low].decl = wined3d_declaration; + fvf_decls[low].fvf = fvf; + ++device->fvf_decl_count; + + TRACE("Returning %p. %u declatations in array.\n", wined3d_declaration, device->fvf_decl_count); + + return wined3d_declaration; +} + +static HRESULT WINAPI d3d9_device_SetFVF(IDirect3DDevice9Ex *iface, DWORD fvf) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct wined3d_vertex_declaration *decl; + + TRACE("iface %p, fvf %#x.\n", iface, fvf); + + if (!fvf) + { + WARN("%#x is not a valid FVF.\n", fvf); + return D3D_OK; + } + + wined3d_mutex_lock(); + if (!(decl = device_get_fvf_declaration(device, fvf))) + { + wined3d_mutex_unlock(); + ERR("Failed to create a vertex declaration for fvf %#x.\n", fvf); + return D3DERR_DRIVERINTERNALERROR; + } + + wined3d_device_set_vertex_declaration(device->wined3d_device, decl); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_GetFVF(IDirect3DDevice9Ex *iface, DWORD *fvf) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct wined3d_vertex_declaration *wined3d_declaration; + struct d3d9_vertex_declaration *d3d9_declaration; + + TRACE("iface %p, fvf %p.\n", iface, fvf); + + wined3d_mutex_lock(); + if ((wined3d_declaration = wined3d_device_get_vertex_declaration(device->wined3d_device))) + { + d3d9_declaration = wined3d_vertex_declaration_get_parent(wined3d_declaration); + *fvf = d3d9_declaration->fvf; + } + else + { + *fvf = 0; + } + wined3d_mutex_unlock(); + + TRACE("Returning FVF %#x.\n", *fvf); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_CreateVertexShader(IDirect3DDevice9Ex *iface, + const DWORD *byte_code, IDirect3DVertexShader9 **shader) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_vertexshader *object; + HRESULT hr; + + TRACE("iface %p, byte_code %p, shader %p.\n", iface, byte_code, shader); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!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); + return hr; + } + + TRACE("Created vertex shader %p.\n", object); + *shader = &object->IDirect3DVertexShader9_iface; + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_SetVertexShader(IDirect3DDevice9Ex *iface, IDirect3DVertexShader9 *shader) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_vertexshader *shader_obj = unsafe_impl_from_IDirect3DVertexShader9(shader); + + TRACE("iface %p, shader %p.\n", iface, shader); + + wined3d_mutex_lock(); + wined3d_device_set_vertex_shader(device->wined3d_device, + shader_obj ? shader_obj->wined3d_shader : NULL); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_GetVertexShader(IDirect3DDevice9Ex *iface, IDirect3DVertexShader9 **shader) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_vertexshader *shader_impl; + struct wined3d_shader *wined3d_shader; + + TRACE("iface %p, shader %p.\n", iface, shader); + + wined3d_mutex_lock(); + if ((wined3d_shader = wined3d_device_get_vertex_shader(device->wined3d_device))) + { + shader_impl = wined3d_shader_get_parent(wined3d_shader); + *shader = &shader_impl->IDirect3DVertexShader9_iface; + IDirect3DVertexShader9_AddRef(*shader); + } + else + { + *shader = NULL; + } + wined3d_mutex_unlock(); + + TRACE("Returning %p.\n", *shader); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_SetVertexShaderConstantF(IDirect3DDevice9Ex *iface, + UINT reg_idx, const float *data, UINT count) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, reg_idx %u, data %p, count %u.\n", iface, reg_idx, data, count); + + if (reg_idx + count > D3D9_MAX_VERTEX_SHADER_CONSTANTF) + { + WARN("Trying to access %u constants, but d3d9 only supports %u\n", + reg_idx + count, D3D9_MAX_VERTEX_SHADER_CONSTANTF); + return D3DERR_INVALIDCALL; + } + + wined3d_mutex_lock(); + hr = wined3d_device_set_vs_consts_f(device->wined3d_device, reg_idx, data, count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetVertexShaderConstantF(IDirect3DDevice9Ex *iface, + UINT reg_idx, float *data, UINT count) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, reg_idx %u, data %p, count %u.\n", iface, reg_idx, data, count); + + if (reg_idx + count > D3D9_MAX_VERTEX_SHADER_CONSTANTF) + { + WARN("Trying to access %u constants, but d3d9 only supports %u\n", + reg_idx + count, D3D9_MAX_VERTEX_SHADER_CONSTANTF); + return D3DERR_INVALIDCALL; + } + + wined3d_mutex_lock(); + hr = wined3d_device_get_vs_consts_f(device->wined3d_device, reg_idx, data, count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_SetVertexShaderConstantI(IDirect3DDevice9Ex *iface, + UINT reg_idx, const int *data, UINT count) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, reg_idx %u, data %p, count %u.\n", iface, reg_idx, data, count); + + wined3d_mutex_lock(); + hr = wined3d_device_set_vs_consts_i(device->wined3d_device, reg_idx, data, count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetVertexShaderConstantI(IDirect3DDevice9Ex *iface, + UINT reg_idx, int *data, UINT count) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, reg_idx %u, data %p, count %u.\n", iface, reg_idx, data, count); + + wined3d_mutex_lock(); + hr = wined3d_device_get_vs_consts_i(device->wined3d_device, reg_idx, data, count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_SetVertexShaderConstantB(IDirect3DDevice9Ex *iface, + UINT reg_idx, const BOOL *data, UINT count) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, reg_idx %u, data %p, count %u.\n", iface, reg_idx, data, count); + + wined3d_mutex_lock(); + hr = wined3d_device_set_vs_consts_b(device->wined3d_device, reg_idx, data, count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetVertexShaderConstantB(IDirect3DDevice9Ex *iface, + UINT reg_idx, BOOL *data, UINT count) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, reg_idx %u, data %p, count %u.\n", iface, reg_idx, data, count); + + wined3d_mutex_lock(); + hr = wined3d_device_get_vs_consts_b(device->wined3d_device, reg_idx, data, count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_SetStreamSource(IDirect3DDevice9Ex *iface, + UINT stream_idx, IDirect3DVertexBuffer9 *buffer, UINT offset, UINT stride) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_vertexbuffer *buffer_impl = unsafe_impl_from_IDirect3DVertexBuffer9(buffer); + HRESULT hr; + + TRACE("iface %p, stream_idx %u, buffer %p, offset %u, stride %u.\n", + iface, stream_idx, buffer, offset, stride); + + wined3d_mutex_lock(); + hr = wined3d_device_set_stream_source(device->wined3d_device, stream_idx, + buffer_impl ? buffer_impl->wined3d_buffer : NULL, offset, stride); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetStreamSource(IDirect3DDevice9Ex *iface, + UINT stream_idx, IDirect3DVertexBuffer9 **buffer, UINT *offset, UINT *stride) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_vertexbuffer *buffer_impl; + struct wined3d_buffer *wined3d_buffer; + HRESULT hr; + + TRACE("iface %p, stream_idx %u, buffer %p, offset %p, stride %p.\n", + iface, stream_idx, buffer, offset, stride); + + if (!buffer) + return D3DERR_INVALIDCALL; + + wined3d_mutex_lock(); + hr = wined3d_device_get_stream_source(device->wined3d_device, stream_idx, &wined3d_buffer, offset, stride); + if (SUCCEEDED(hr) && wined3d_buffer) + { + buffer_impl = wined3d_buffer_get_parent(wined3d_buffer); + *buffer = &buffer_impl->IDirect3DVertexBuffer9_iface; + IDirect3DVertexBuffer9_AddRef(*buffer); + wined3d_buffer_decref(wined3d_buffer); + } + else + { + if (FAILED(hr)) + FIXME("Call to GetStreamSource failed %p %p\n", offset, stride); + *buffer = NULL; + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_SetStreamSourceFreq(IDirect3DDevice9Ex *iface, UINT stream_idx, UINT freq) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, stream_idx %u, freq %u.\n", iface, stream_idx, freq); + + wined3d_mutex_lock(); + hr = wined3d_device_set_stream_source_freq(device->wined3d_device, stream_idx, freq); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetStreamSourceFreq(IDirect3DDevice9Ex *iface, UINT stream_idx, UINT *freq) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, stream_idx %u, freq %p.\n", iface, stream_idx, freq); + + wined3d_mutex_lock(); + hr = wined3d_device_get_stream_source_freq(device->wined3d_device, stream_idx, freq); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_SetIndices(IDirect3DDevice9Ex *iface, IDirect3DIndexBuffer9 *buffer) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_indexbuffer *ib = unsafe_impl_from_IDirect3DIndexBuffer9(buffer); + + TRACE("iface %p, buffer %p.\n", iface, buffer); + + wined3d_mutex_lock(); + wined3d_device_set_index_buffer(device->wined3d_device, + ib ? ib->wined3d_buffer : NULL, + ib ? ib->format : WINED3DFMT_UNKNOWN); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_GetIndices(IDirect3DDevice9Ex *iface, IDirect3DIndexBuffer9 **buffer) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + enum wined3d_format_id wined3d_format; + struct wined3d_buffer *wined3d_buffer; + struct d3d9_indexbuffer *buffer_impl; + + TRACE("iface %p, buffer %p.\n", iface, buffer); + + if (!buffer) + return D3DERR_INVALIDCALL; + + wined3d_mutex_lock(); + if ((wined3d_buffer = wined3d_device_get_index_buffer(device->wined3d_device, &wined3d_format))) + { + buffer_impl = wined3d_buffer_get_parent(wined3d_buffer); + *buffer = &buffer_impl->IDirect3DIndexBuffer9_iface; + IDirect3DIndexBuffer9_AddRef(*buffer); + } + else + { + *buffer = NULL; + } + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_CreatePixelShader(IDirect3DDevice9Ex *iface, + const DWORD *byte_code, IDirect3DPixelShader9 **shader) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_pixelshader *object; + HRESULT hr; + + TRACE("iface %p, byte_code %p, shader %p.\n", iface, byte_code, shader); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!object) + { + FIXME("Failed to allocate pixel shader memory.\n"); + return E_OUTOFMEMORY; + } + + hr = pixelshader_init(object, device, byte_code); + if (FAILED(hr)) + { + WARN("Failed to initialize pixel shader, hr %#x.\n", hr); + HeapFree(GetProcessHeap(), 0, object); + return hr; + } + + TRACE("Created pixel shader %p.\n", object); + *shader = &object->IDirect3DPixelShader9_iface; + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_SetPixelShader(IDirect3DDevice9Ex *iface, IDirect3DPixelShader9 *shader) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_pixelshader *shader_obj = unsafe_impl_from_IDirect3DPixelShader9(shader); + + TRACE("iface %p, shader %p.\n", iface, shader); + + wined3d_mutex_lock(); + wined3d_device_set_pixel_shader(device->wined3d_device, + shader_obj ? shader_obj->wined3d_shader : NULL); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_GetPixelShader(IDirect3DDevice9Ex *iface, IDirect3DPixelShader9 **shader) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_pixelshader *shader_impl; + struct wined3d_shader *wined3d_shader; + + TRACE("iface %p, shader %p.\n", iface, shader); + + if (!shader) return D3DERR_INVALIDCALL; + + wined3d_mutex_lock(); + if ((wined3d_shader = wined3d_device_get_pixel_shader(device->wined3d_device))) + { + shader_impl = wined3d_shader_get_parent(wined3d_shader); + *shader = &shader_impl->IDirect3DPixelShader9_iface; + IDirect3DPixelShader9_AddRef(*shader); + } + else + { + *shader = NULL; + } + wined3d_mutex_unlock(); + + TRACE("Returning %p.\n", *shader); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_SetPixelShaderConstantF(IDirect3DDevice9Ex *iface, + UINT reg_idx, const float *data, UINT count) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, reg_idx %u, data %p, count %u.\n", iface, reg_idx, data, count); + + wined3d_mutex_lock(); + hr = wined3d_device_set_ps_consts_f(device->wined3d_device, reg_idx, data, count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetPixelShaderConstantF(IDirect3DDevice9Ex *iface, + UINT reg_idx, float *data, UINT count) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, reg_idx %u, data %p, count %u.\n", iface, reg_idx, data, count); + + wined3d_mutex_lock(); + hr = wined3d_device_get_ps_consts_f(device->wined3d_device, reg_idx, data, count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_SetPixelShaderConstantI(IDirect3DDevice9Ex *iface, + UINT reg_idx, const int *data, UINT count) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, reg_idx %u, data %p, count %u.\n", iface, reg_idx, data, count); + + wined3d_mutex_lock(); + hr = wined3d_device_set_ps_consts_i(device->wined3d_device, reg_idx, data, count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetPixelShaderConstantI(IDirect3DDevice9Ex *iface, + UINT reg_idx, int *data, UINT count) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, reg_idx %u, data %p, count %u.\n", iface, reg_idx, data, count); + + wined3d_mutex_lock(); + hr = wined3d_device_get_ps_consts_i(device->wined3d_device, reg_idx, data, count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_SetPixelShaderConstantB(IDirect3DDevice9Ex *iface, + UINT reg_idx, const BOOL *data, UINT count) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, reg_idx %u, data %p, count %u.\n", iface, reg_idx, data, count); + + wined3d_mutex_lock(); + hr = wined3d_device_set_ps_consts_b(device->wined3d_device, reg_idx, data, count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetPixelShaderConstantB(IDirect3DDevice9Ex *iface, + UINT reg_idx, BOOL *data, UINT count) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, reg_idx %u, data %p, count %u.\n", iface, reg_idx, data, count); + + wined3d_mutex_lock(); + hr = wined3d_device_get_ps_consts_b(device->wined3d_device, reg_idx, data, count); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_DrawRectPatch(IDirect3DDevice9Ex *iface, UINT handle, + const float *segment_count, const D3DRECTPATCH_INFO *patch_info) +{ + FIXME("iface %p, handle %#x, segment_count %p, patch_info %p unimplemented.\n", + iface, handle, segment_count, patch_info); + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_DrawTriPatch(IDirect3DDevice9Ex *iface, UINT handle, + const float *segment_count, const D3DTRIPATCH_INFO *patch_info) +{ + FIXME("iface %p, handle %#x, segment_count %p, patch_info %p unimplemented.\n", + iface, handle, segment_count, patch_info); + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_DeletePatch(IDirect3DDevice9Ex *iface, UINT handle) +{ + FIXME("iface %p, handle %#x unimplemented.\n", iface, handle); + return D3DERR_INVALIDCALL; +} + +static HRESULT WINAPI d3d9_device_CreateQuery(IDirect3DDevice9Ex *iface, D3DQUERYTYPE type, IDirect3DQuery9 **query) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_query *object; + HRESULT hr; + + TRACE("iface %p, type %#x, query %p.\n", iface, type, query); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!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); + return hr; + } + + TRACE("Created query %p.\n", object); + if (query) *query = &object->IDirect3DQuery9_iface; + else IDirect3DQuery9_Release(&object->IDirect3DQuery9_iface); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_SetConvolutionMonoKernel(IDirect3DDevice9Ex *iface, + UINT width, UINT height, float *rows, float *columns) +{ + FIXME("iface %p, width %u, height %u, rows %p, columns %p stub!\n", + iface, width, height, rows, columns); + + return E_NOTIMPL; +} + +static HRESULT WINAPI d3d9_device_ComposeRects(IDirect3DDevice9Ex *iface, + IDirect3DSurface9 *src_surface, IDirect3DSurface9 *dst_surface, IDirect3DVertexBuffer9 *src_descs, + UINT rect_count, IDirect3DVertexBuffer9 *dst_descs, D3DCOMPOSERECTSOP operation, INT offset_x, INT offset_y) +{ + FIXME("iface %p, src_surface %p, dst_surface %p, src_descs %p, rect_count %u,\n" + "dst_descs %p, operation %#x, offset_x %u, offset_y %u stub!\n", + iface, src_surface, dst_surface, src_descs, rect_count, + dst_descs, operation, offset_x, offset_y); + + return E_NOTIMPL; +} + +static HRESULT WINAPI d3d9_device_PresentEx(IDirect3DDevice9Ex *iface, + const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override, + const RGNDATA *dirty_region, DWORD flags) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + HRESULT hr; + + TRACE("iface %p, src_rect %s, dst_rect %s, dst_window_override %p, dirty_region %p, flags %#x.\n", + iface, wine_dbgstr_rect(src_rect), wine_dbgstr_rect(dst_rect), + dst_window_override, dirty_region, flags); + + wined3d_mutex_lock(); + hr = wined3d_device_present(device->wined3d_device, src_rect, dst_rect, + dst_window_override, dirty_region, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetGPUThreadPriority(IDirect3DDevice9Ex *iface, INT *priority) +{ + FIXME("iface %p, priority %p stub!\n", iface, priority); + + return E_NOTIMPL; +} + +static HRESULT WINAPI d3d9_device_SetGPUThreadPriority(IDirect3DDevice9Ex *iface, INT priority) +{ + FIXME("iface %p, priority %d stub!\n", iface, priority); + + return E_NOTIMPL; +} + +static HRESULT WINAPI d3d9_device_WaitForVBlank(IDirect3DDevice9Ex *iface, UINT swapchain_idx) +{ + FIXME("iface %p, swapchain_idx %u stub!\n", iface, swapchain_idx); + + return E_NOTIMPL; +} + +static HRESULT WINAPI d3d9_device_CheckResourceResidency(IDirect3DDevice9Ex *iface, + IDirect3DResource9 **resources, UINT32 resource_count) +{ + FIXME("iface %p, resources %p, resource_count %u stub!\n", + iface, resources, resource_count); + + return E_NOTIMPL; +} + +static HRESULT WINAPI d3d9_device_SetMaximumFrameLatency(IDirect3DDevice9Ex *iface, UINT max_latency) +{ + FIXME("iface %p, max_latency %u stub!\n", iface, max_latency); + + return E_NOTIMPL; +} + +static HRESULT WINAPI d3d9_device_GetMaximumFrameLatency(IDirect3DDevice9Ex *iface, UINT *max_latency) +{ + FIXME("iface %p, max_latency %p stub!\n", iface, max_latency); + + *max_latency = 2; + + return E_NOTIMPL; +} + +static HRESULT WINAPI d3d9_device_CheckDeviceState(IDirect3DDevice9Ex *iface, HWND dst_window) +{ + static int i; + + TRACE("iface %p, dst_window %p stub!\n", iface, dst_window); + + if (!i++) + FIXME("iface %p, dst_window %p stub!\n", iface, dst_window); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_device_CreateRenderTargetEx(IDirect3DDevice9Ex *iface, + UINT width, UINT height, D3DFORMAT format, D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality, + BOOL lockable, IDirect3DSurface9 **surface, HANDLE *shared_handle, DWORD usage) +{ + FIXME("iface %p, width %u, height %u, format %#x, multisample_type %#x, multisample_quality %u,\n" + "lockable %#x, surface %p, shared_handle %p, usage %#x stub!\n", + iface, width, height, format, multisample_type, multisample_quality, + lockable, surface, shared_handle, usage); + + if (shared_handle) + FIXME("Resource sharing not implemented, *shared_handle %p.\n", *shared_handle); + + return E_NOTIMPL; +} + +static HRESULT WINAPI d3d9_device_CreateOffscreenPlainSurfaceEx(IDirect3DDevice9Ex *iface, + UINT width, UINT height, D3DFORMAT format, D3DPOOL pool, IDirect3DSurface9 **surface, + HANDLE *shared_handle, DWORD usage) +{ + FIXME("iface %p, width %u, height %u, format %#x, pool %#x, surface %p, shared_handle %p, usage %#x stub!\n", + iface, width, height, format, pool, surface, shared_handle, usage); + + return E_NOTIMPL; +} + +static HRESULT WINAPI d3d9_device_CreateDepthStencilSurfaceEx(IDirect3DDevice9Ex *iface, + UINT width, UINT height, D3DFORMAT format, D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality, + BOOL discard, IDirect3DSurface9 **surface, HANDLE *shared_handle, DWORD usage) +{ + FIXME("iface %p, width %u, height %u, format %#x, multisample_type %#x, multisample_quality %u,\n" + "discard %#x, surface %p, shared_handle %p, usage %#x stub!\n", + iface, width, height, format, multisample_type, multisample_quality, + discard, surface, shared_handle, usage); + + if (shared_handle) + FIXME("Resource sharing not implemented, *shared_handle %p.\n", *shared_handle); + + return E_NOTIMPL; +} + +static HRESULT WINAPI d3d9_device_ResetEx(IDirect3DDevice9Ex *iface, + D3DPRESENT_PARAMETERS *present_parameters, D3DDISPLAYMODEEX *mode) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct wined3d_swapchain_desc swapchain_desc; + struct wined3d_display_mode wined3d_mode; + HRESULT hr; + + TRACE("iface %p, present_parameters %p, mode %p.\n", iface, present_parameters, mode); + + if (mode) + { + wined3d_mode.width = mode->Width; + wined3d_mode.height = mode->Height; + wined3d_mode.refresh_rate = mode->RefreshRate; + wined3d_mode.format_id = wined3dformat_from_d3dformat(mode->Format); + wined3d_mode.scanline_ordering = mode->ScanLineOrdering; + } + + wined3d_mutex_lock(); + + if (device->vertex_buffer) + { + wined3d_buffer_decref(device->vertex_buffer); + device->vertex_buffer = NULL; + device->vertex_buffer_size = 0; + } + if (device->index_buffer) + { + wined3d_buffer_decref(device->index_buffer); + device->index_buffer = NULL; + device->index_buffer_size = 0; + } + + wined3d_swapchain_desc_from_present_parameters(&swapchain_desc, present_parameters); + hr = wined3d_device_reset(device->wined3d_device, &swapchain_desc, + mode ? &wined3d_mode : NULL, reset_enum_callback, FALSE); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_device_GetDisplayModeEx(IDirect3DDevice9Ex *iface, + UINT swapchain_idx, D3DDISPLAYMODEEX *mode, D3DDISPLAYROTATION *rotation) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct wined3d_display_mode wined3d_mode; + HRESULT hr; + + TRACE("iface %p, swapchain_idx %u, mode %p, rotation %p.\n", + iface, swapchain_idx, mode, rotation); + + if (mode->Size != sizeof(*mode)) + return D3DERR_INVALIDCALL; + + wined3d_mutex_lock(); + hr = wined3d_device_get_display_mode(device->wined3d_device, swapchain_idx, &wined3d_mode, + (enum wined3d_display_rotation *)rotation); + wined3d_mutex_unlock(); + + if (SUCCEEDED(hr)) + { + mode->Width = wined3d_mode.width; + mode->Height = wined3d_mode.height; + mode->RefreshRate = wined3d_mode.refresh_rate; + mode->Format = d3dformat_from_wined3dformat(wined3d_mode.format_id); + mode->ScanLineOrdering = wined3d_mode.scanline_ordering; + } + + return hr; +} + +static const struct IDirect3DDevice9ExVtbl d3d9_device_vtbl = +{ + /* IUnknown */ + d3d9_device_QueryInterface, + d3d9_device_AddRef, + d3d9_device_Release, + /* IDirect3DDevice9 */ + d3d9_device_TestCooperativeLevel, + d3d9_device_GetAvailableTextureMem, + d3d9_device_EvictManagedResources, + d3d9_device_GetDirect3D, + d3d9_device_GetDeviceCaps, + d3d9_device_GetDisplayMode, + d3d9_device_GetCreationParameters, + d3d9_device_SetCursorProperties, + d3d9_device_SetCursorPosition, + d3d9_device_ShowCursor, + d3d9_device_CreateAdditionalSwapChain, + d3d9_device_GetSwapChain, + d3d9_device_GetNumberOfSwapChains, + d3d9_device_Reset, + d3d9_device_Present, + d3d9_device_GetBackBuffer, + d3d9_device_GetRasterStatus, + d3d9_device_SetDialogBoxMode, + d3d9_device_SetGammaRamp, + d3d9_device_GetGammaRamp, + d3d9_device_CreateTexture, + d3d9_device_CreateVolumeTexture, + d3d9_device_CreateCubeTexture, + d3d9_device_CreateVertexBuffer, + d3d9_device_CreateIndexBuffer, + d3d9_device_CreateRenderTarget, + d3d9_device_CreateDepthStencilSurface, + d3d9_device_UpdateSurface, + d3d9_device_UpdateTexture, + d3d9_device_GetRenderTargetData, + d3d9_device_GetFrontBufferData, + d3d9_device_StretchRect, + d3d9_device_ColorFill, + d3d9_device_CreateOffscreenPlainSurface, + d3d9_device_SetRenderTarget, + d3d9_device_GetRenderTarget, + d3d9_device_SetDepthStencilSurface, + d3d9_device_GetDepthStencilSurface, + d3d9_device_BeginScene, + d3d9_device_EndScene, + d3d9_device_Clear, + d3d9_device_SetTransform, + d3d9_device_GetTransform, + d3d9_device_MultiplyTransform, + d3d9_device_SetViewport, + d3d9_device_GetViewport, + d3d9_device_SetMaterial, + d3d9_device_GetMaterial, + d3d9_device_SetLight, + d3d9_device_GetLight, + d3d9_device_LightEnable, + d3d9_device_GetLightEnable, + d3d9_device_SetClipPlane, + d3d9_device_GetClipPlane, + d3d9_device_SetRenderState, + d3d9_device_GetRenderState, + d3d9_device_CreateStateBlock, + d3d9_device_BeginStateBlock, + d3d9_device_EndStateBlock, + d3d9_device_SetClipStatus, + d3d9_device_GetClipStatus, + d3d9_device_GetTexture, + d3d9_device_SetTexture, + d3d9_device_GetTextureStageState, + d3d9_device_SetTextureStageState, + d3d9_device_GetSamplerState, + d3d9_device_SetSamplerState, + d3d9_device_ValidateDevice, + d3d9_device_SetPaletteEntries, + d3d9_device_GetPaletteEntries, + d3d9_device_SetCurrentTexturePalette, + d3d9_device_GetCurrentTexturePalette, + d3d9_device_SetScissorRect, + d3d9_device_GetScissorRect, + d3d9_device_SetSoftwareVertexProcessing, + d3d9_device_GetSoftwareVertexProcessing, + d3d9_device_SetNPatchMode, + d3d9_device_GetNPatchMode, + d3d9_device_DrawPrimitive, + d3d9_device_DrawIndexedPrimitive, + d3d9_device_DrawPrimitiveUP, + d3d9_device_DrawIndexedPrimitiveUP, + d3d9_device_ProcessVertices, + d3d9_device_CreateVertexDeclaration, + d3d9_device_SetVertexDeclaration, + d3d9_device_GetVertexDeclaration, + d3d9_device_SetFVF, + d3d9_device_GetFVF, + d3d9_device_CreateVertexShader, + d3d9_device_SetVertexShader, + d3d9_device_GetVertexShader, + d3d9_device_SetVertexShaderConstantF, + d3d9_device_GetVertexShaderConstantF, + d3d9_device_SetVertexShaderConstantI, + d3d9_device_GetVertexShaderConstantI, + d3d9_device_SetVertexShaderConstantB, + d3d9_device_GetVertexShaderConstantB, + d3d9_device_SetStreamSource, + d3d9_device_GetStreamSource, + d3d9_device_SetStreamSourceFreq, + d3d9_device_GetStreamSourceFreq, + d3d9_device_SetIndices, + d3d9_device_GetIndices, + d3d9_device_CreatePixelShader, + d3d9_device_SetPixelShader, + d3d9_device_GetPixelShader, + d3d9_device_SetPixelShaderConstantF, + d3d9_device_GetPixelShaderConstantF, + d3d9_device_SetPixelShaderConstantI, + d3d9_device_GetPixelShaderConstantI, + d3d9_device_SetPixelShaderConstantB, + d3d9_device_GetPixelShaderConstantB, + d3d9_device_DrawRectPatch, + d3d9_device_DrawTriPatch, + d3d9_device_DeletePatch, + d3d9_device_CreateQuery, + /* IDirect3DDevice9Ex */ + d3d9_device_SetConvolutionMonoKernel, + d3d9_device_ComposeRects, + d3d9_device_PresentEx, + d3d9_device_GetGPUThreadPriority, + d3d9_device_SetGPUThreadPriority, + d3d9_device_WaitForVBlank, + d3d9_device_CheckResourceResidency, + d3d9_device_SetMaximumFrameLatency, + d3d9_device_GetMaximumFrameLatency, + d3d9_device_CheckDeviceState, + d3d9_device_CreateRenderTargetEx, + d3d9_device_CreateOffscreenPlainSurfaceEx, + d3d9_device_CreateDepthStencilSurfaceEx, + d3d9_device_ResetEx, + d3d9_device_GetDisplayModeEx, +}; + +static inline struct d3d9_device *device_from_device_parent(struct wined3d_device_parent *device_parent) +{ + return CONTAINING_RECORD(device_parent, struct d3d9_device, device_parent); +} + +static void CDECL device_parent_wined3d_device_created(struct wined3d_device_parent *device_parent, + struct wined3d_device *device) +{ + TRACE("device_parent %p, device %p.\n", device_parent, device); +} + +static void CDECL device_parent_mode_changed(struct wined3d_device_parent *device_parent) +{ + TRACE("device_parent %p.\n", device_parent); +} + +static HRESULT CDECL device_parent_create_texture_surface(struct wined3d_device_parent *device_parent, + void *container_parent, const struct wined3d_resource_desc *desc, UINT sub_resource_idx, + DWORD flags, struct wined3d_surface **surface +#ifdef VBOX_WITH_WDDM + , HANDLE *shared_handle + , void *pvClientMem +#endif + ) +{ + struct d3d9_device *device = device_from_device_parent(device_parent); + struct d3d9_surface *d3d_surface; + HRESULT hr; + + TRACE("device_parent %p, container_parent %p, desc %p, sub_resource_idx %u, flags %#x, surface %p.\n", + device_parent, container_parent, desc, sub_resource_idx, flags, surface); + +#ifdef VBOX_WITH_WDDM + if (FAILED(hr = d3d9_device_create_surface(device, desc->width, desc->height, + d3dformat_from_wined3dformat(desc->format), flags, (IDirect3DSurface9 **)&d3d_surface, + desc->usage, desc->pool, desc->multisample_type, desc->multisample_quality + , shared_handle + , pvClientMem + ))) +#else + if (FAILED(hr = d3d9_device_create_surface(device, desc->width, desc->height, + d3dformat_from_wined3dformat(desc->format), flags, (IDirect3DSurface9 **)&d3d_surface, + desc->usage, desc->pool, desc->multisample_type, desc->multisample_quality))) +#endif + { + WARN("Failed to create surface, hr %#x.\n", hr); + return hr; + } + + *surface = d3d_surface->wined3d_surface; + wined3d_surface_incref(*surface); + + d3d_surface->container = container_parent; + IDirect3DDevice9Ex_Release(d3d_surface->parent_device); + d3d_surface->parent_device = NULL; + + IDirect3DSurface9_Release(&d3d_surface->IDirect3DSurface9_iface); + d3d_surface->forwardReference = container_parent; + + return hr; +} + +static HRESULT CDECL device_parent_create_swapchain_surface(struct wined3d_device_parent *device_parent, + void *container_parent, const struct wined3d_resource_desc *desc, struct wined3d_surface **surface) +{ + struct d3d9_device *device = device_from_device_parent(device_parent); + struct wined3d_resource_desc texture_desc; + struct d3d9_surface *d3d_surface; + struct wined3d_texture *texture; + HRESULT hr; + + TRACE("device_parent %p, container_parent %p, desc %p, surface %p.\n", + device_parent, container_parent, desc, surface); + + if (container_parent == device_parent) + container_parent = &device->IDirect3DDevice9Ex_iface; + + texture_desc = *desc; + texture_desc.resource_type = WINED3D_RTYPE_TEXTURE; +#ifdef VBOX_WITH_WDDM + if (FAILED(hr = wined3d_texture_create_2d(device->wined3d_device, &texture_desc, 1, + WINED3D_SURFACE_MAPPABLE, container_parent, &d3d9_null_wined3d_parent_ops, &texture + , NULL, NULL))) +#else + if (FAILED(hr = wined3d_texture_create_2d(device->wined3d_device, &texture_desc, 1, + WINED3D_SURFACE_MAPPABLE, container_parent, &d3d9_null_wined3d_parent_ops, &texture))) +#endif + { + WARN("Failed to create texture, hr %#x.\n", hr); + return hr; + } + + *surface = wined3d_surface_from_resource(wined3d_texture_get_sub_resource(texture, 0)); + wined3d_surface_incref(*surface); + wined3d_texture_decref(texture); + + d3d_surface = wined3d_surface_get_parent(*surface); + d3d_surface->forwardReference = NULL; + d3d_surface->parent_device = &device->IDirect3DDevice9Ex_iface; + return hr; +} + +static HRESULT CDECL device_parent_create_volume(struct wined3d_device_parent *device_parent, + void *container_parent, UINT width, UINT height, UINT depth, enum wined3d_format_id format, + enum wined3d_pool pool, DWORD usage, struct wined3d_volume **volume +#ifdef VBOX_WITH_WDDM + , HANDLE *shared_handle + , void *pvClientMem +#endif + ) +{ + struct d3d9_device *device = device_from_device_parent(device_parent); + struct d3d9_volume *object; + HRESULT hr; + + TRACE("device_parent %p, container_parent %p, width %u, height %u, depth %u, " + "format %#x, pool %#x, usage %#x, volume %p\n", + device_parent, container_parent, width, height, depth, + format, pool, usage, volume); + + /* Allocate the storage for the device */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!object) + { + FIXME("Allocation of memory failed\n"); + *volume = NULL; + return D3DERR_OUTOFVIDEOMEMORY; + } + + hr = volume_init(object, device, width, height, depth, usage, format, pool +#ifdef VBOX_WITH_WDDM + , shared_handle + , pvClientMem +#endif + ); + if (FAILED(hr)) + { + WARN("Failed to initialize volume, hr %#x.\n", hr); + HeapFree(GetProcessHeap(), 0, object); + return hr; + } + + *volume = object->wined3d_volume; + wined3d_volume_incref(*volume); + IDirect3DVolume9_Release(&object->IDirect3DVolume9_iface); + + object->container = container_parent; + object->forwardReference = container_parent; + + TRACE("Created volume %p.\n", object); + + return hr; +} + +static HRESULT CDECL device_parent_create_swapchain(struct wined3d_device_parent *device_parent, + struct wined3d_swapchain_desc *desc, struct wined3d_swapchain **swapchain) +{ + struct d3d9_device *device = device_from_device_parent(device_parent); + struct d3d9_swapchain *d3d_swapchain; + HRESULT hr; + + TRACE("device_parent %p, desc %p, swapchain %p\n", device_parent, desc, swapchain); + + hr = d3d9_swapchain_create(device, desc, &d3d_swapchain); + if (FAILED(hr)) + { + WARN("Failed to create swapchain, hr %#x.\n", hr); + *swapchain = NULL; + return hr; + } + + *swapchain = d3d_swapchain->wined3d_swapchain; + wined3d_swapchain_incref(*swapchain); + IDirect3DSwapChain9_Release(&d3d_swapchain->IDirect3DSwapChain9_iface); + + return hr; +} + +static const struct wined3d_device_parent_ops d3d9_wined3d_device_parent_ops = +{ + device_parent_wined3d_device_created, + device_parent_mode_changed, + device_parent_create_swapchain_surface, + device_parent_create_texture_surface, + device_parent_create_volume, + device_parent_create_swapchain, +}; + +static void setup_fpu(void) +{ +#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) + WORD cw; + __asm__ volatile ("fnstcw %0" : "=m" (cw)); + cw = (cw & ~0xf3f) | 0x3f; + __asm__ volatile ("fldcw %0" : : "m" (cw)); +#elif defined(__i386__) && defined(_MSC_VER) + WORD cw; + __asm fnstcw cw; + cw = (cw & ~0xf3f) | 0x3f; + __asm fldcw cw; +#elif defined(RT_ARCH_AMD64) + unsigned int currentControl = 0; + _controlfp_s(¤tControl, 0x3f, 0xf3f); +#else + FIXME("FPU setup not implemented for this platform.\n"); +#endif +} + +HRESULT device_init(struct d3d9_device *device, struct d3d9 *parent, struct wined3d *wined3d, + UINT adapter, D3DDEVTYPE device_type, HWND focus_window, DWORD flags +#ifdef VBOX_WITH_WDDM + , VBOXWINEEX_D3DPRESENT_PARAMETERS *parameters +#else + , D3DPRESENT_PARAMETERS *parameters +#endif + , D3DDISPLAYMODEEX *mode) +{ + struct wined3d_swapchain_desc *swapchain_desc; + UINT i, count = 1; + HRESULT hr; + + if (mode) + FIXME("Ignoring display mode.\n"); + + device->IDirect3DDevice9Ex_iface.lpVtbl = &d3d9_device_vtbl; + device->device_parent.ops = &d3d9_wined3d_device_parent_ops; + device->refcount = 1; + + if (!(flags & D3DCREATE_FPU_PRESERVE)) setup_fpu(); + + wined3d_mutex_lock(); + hr = wined3d_device_create(wined3d, adapter, device_type, focus_window, flags, 4, + &device->device_parent, &device->wined3d_device); + if (FAILED(hr)) + { + WARN("Failed to create wined3d device, hr %#x.\n", hr); + wined3d_mutex_unlock(); + return hr; + } + + if (flags & D3DCREATE_ADAPTERGROUP_DEVICE) + { + WINED3DCAPS caps; + + wined3d_get_device_caps(wined3d, adapter, device_type, &caps); + count = caps.NumberOfAdaptersInGroup; + } + + if (flags & D3DCREATE_MULTITHREADED) + wined3d_device_set_multithreaded(device->wined3d_device); + +#ifndef VBOX_WITH_WDDM + if (!parameters->Windowed) + { + if (!focus_window) + focus_window = parameters->hDeviceWindow; + if (FAILED(hr = wined3d_device_acquire_focus_window(device->wined3d_device, focus_window))) + { + ERR("Failed to acquire focus window, hr %#x.\n", hr); + wined3d_device_decref(device->wined3d_device); + wined3d_mutex_unlock(); + return hr; + } + + for (i = 0; i < count; ++i) + { + HWND device_window = parameters[i].hDeviceWindow; + + if (!device_window) device_window = focus_window; + wined3d_device_setup_fullscreen_window(device->wined3d_device, device_window, + parameters[i].BackBufferWidth, + parameters[i].BackBufferHeight); + } + } +#else + if (!parameters->Base.Windowed) + { + ERR("non-windowed mode unsupported!"); + parameters->Base.Windowed = TRUE; + } +#endif + + swapchain_desc = HeapAlloc(GetProcessHeap(), 0, sizeof(*swapchain_desc) * count); + if (!swapchain_desc) + { + ERR("Failed to allocate wined3d parameters.\n"); + wined3d_device_decref(device->wined3d_device); + wined3d_mutex_unlock(); + return E_OUTOFMEMORY; + } + + for (i = 0; i < count; ++i) + { +#ifdef VBOX_WITH_WDDM + wined3d_swapchain_desc_from_present_parameters(&swapchain_desc[i], ¶meters[i].Base); + swapchain_desc[i].pHgsmi = parameters[i].pHgsmi; +#else + wined3d_swapchain_desc_from_present_parameters(&swapchain_desc[i], ¶meters[i]); +#endif + } + + hr = wined3d_device_init_3d(device->wined3d_device, swapchain_desc); + if (FAILED(hr)) + { + WARN("Failed to initialize 3D, hr %#x.\n", hr); +#ifndef VBOX_WITH_WDDM + wined3d_device_release_focus_window(device->wined3d_device); +#endif + HeapFree(GetProcessHeap(), 0, swapchain_desc); + wined3d_device_decref(device->wined3d_device); + wined3d_mutex_unlock(); + return hr; + } + + wined3d_mutex_unlock(); + + for (i = 0; i < count; ++i) + { +#ifndef VBOX_WITH_WDDM + present_parameters_from_wined3d_swapchain_desc(¶meters[i], &swapchain_desc[i]); +#else + present_parameters_from_wined3d_swapchain_desc(¶meters[i].Base, &swapchain_desc[i]); +#endif + } + HeapFree(GetProcessHeap(), 0, 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) + { + ERR("Failed to allocate FVF vertex declaration map memory.\n"); + wined3d_mutex_lock(); + wined3d_device_uninit_3d(device->wined3d_device); +#ifndef VBOX_WITH_WDDM + wined3d_device_release_focus_window(device->wined3d_device); +#endif + wined3d_device_decref(device->wined3d_device); + wined3d_mutex_unlock(); + return E_OUTOFMEMORY; + } + + IDirect3D9Ex_AddRef(&parent->IDirect3D9Ex_iface); + device->d3d_parent = parent; + + return D3D_OK; +} + +#ifdef VBOX_WITH_WDDM +AssertCompile(sizeof (struct wined3d_box) == sizeof (VBOXBOX3D)); +AssertCompile(RT_SIZEOFMEMB(struct wined3d_box, left) == RT_SIZEOFMEMB(VBOXBOX3D, Left)); +AssertCompile(RT_SIZEOFMEMB(struct wined3d_box, top) == RT_SIZEOFMEMB(VBOXBOX3D, Top)); +AssertCompile(RT_SIZEOFMEMB(struct wined3d_box, right) == RT_SIZEOFMEMB(VBOXBOX3D, Right)); +AssertCompile(RT_SIZEOFMEMB(struct wined3d_box, bottom) == RT_SIZEOFMEMB(VBOXBOX3D, Bottom)); +AssertCompile(RT_SIZEOFMEMB(struct wined3d_box, front) == RT_SIZEOFMEMB(VBOXBOX3D, Front)); +AssertCompile(RT_SIZEOFMEMB(struct wined3d_box, back) == RT_SIZEOFMEMB(VBOXBOX3D, Back)); + +AssertCompile(RT_OFFSETOF(struct wined3d_box, left) == RT_OFFSETOF(VBOXBOX3D, Left)); +AssertCompile(RT_OFFSETOF(struct wined3d_box, top) == RT_OFFSETOF(VBOXBOX3D, Top)); +AssertCompile(RT_OFFSETOF(struct wined3d_box, right) == RT_OFFSETOF(VBOXBOX3D, Right)); +AssertCompile(RT_OFFSETOF(struct wined3d_box, bottom) == RT_OFFSETOF(VBOXBOX3D, Bottom)); +AssertCompile(RT_OFFSETOF(struct wined3d_box, front) == RT_OFFSETOF(VBOXBOX3D, Front)); +AssertCompile(RT_OFFSETOF(struct wined3d_box, back) == RT_OFFSETOF(VBOXBOX3D, Back)); + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9VolBlt(IDirect3DDevice9Ex *iface, + IDirect3DVolume9 *pSourceVolume, IDirect3DVolume9 *pDestinationVolume, + const VBOXBOX3D *pSrcBoxArg, + const VBOXPOINT3D *pDstPoin3D) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_volume *src = unsafe_impl_from_IDirect3DVolume9(pSourceVolume); + struct d3d9_volume *dst = unsafe_impl_from_IDirect3DVolume9(pDestinationVolume); + HRESULT hr; + + wined3d_mutex_lock(); + hr = wined3d_device_blt_vol(device->wined3d_device, src->wined3d_volume, dst->wined3d_volume, (struct wined3d_box*)pSrcBoxArg, pDstPoin3D); + wined3d_mutex_unlock(); + + return hr; +} + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9VolTexBlt(IDirect3DDevice9Ex *iface, + IDirect3DVolumeTexture9 *pSourceTexture, IDirect3DVolumeTexture9 *pDestinationTexture, + const VBOXBOX3D *pSrcBoxArg, + const VBOXPOINT3D *pDstPoin3D) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + struct d3d9_texture *src = unsafe_impl_from_IDirect3DBaseTexture9((IDirect3DBaseTexture9*)pSourceTexture); + struct d3d9_texture *dst = unsafe_impl_from_IDirect3DBaseTexture9((IDirect3DBaseTexture9*)pDestinationTexture); + HRESULT hr; + + wined3d_mutex_lock(); + hr = wined3d_device_blt_voltex(device->wined3d_device, src->wined3d_texture, dst->wined3d_texture, (struct wined3d_box*)pSrcBoxArg, pDstPoin3D); + wined3d_mutex_unlock(); + + return hr; +} + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9Term(IDirect3DDevice9Ex *iface) +{ + struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface); + LONG wined3d_refs; + if (device->refcount != 1) + { + ERR("unexpected ref count %d, destroying in anyway", device->refcount); + } + wined3d_refs = d3d9_device_Term(device); + if (wined3d_refs) + { + ERR("unexpected wined3dRefs %d, destroying in anyway", wined3d_refs); + while (wined3d_device_decref(device->wined3d_device)) {} + } + return D3D_OK; +} +#endif Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/directx.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/directx.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/directx.c (revision 46521) @@ -0,0 +1,655 @@ +/* + * IDirect3D9 implementation + * + * Copyright 2002 Jason Edmeades + * Copyright 2005 Oliver Stieber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * 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); +} + +static HRESULT WINAPI d3d9_QueryInterface(IDirect3D9Ex *iface, REFIID riid, void **out) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3D9) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3D9Ex_AddRef(&d3d9->IDirect3D9Ex_iface); + *out = &d3d9->IDirect3D9Ex_iface; + return S_OK; + } + + if (IsEqualGUID(riid, &IID_IDirect3D9Ex)) + { + if (!d3d9->extended) + { + WARN("Application asks for IDirect3D9Ex, but this instance wasn't created with Direct3DCreate9Ex.\n"); + *out = NULL; + return E_NOINTERFACE; + } + + IDirect3D9Ex_AddRef(&d3d9->IDirect3D9Ex_iface); + *out = &d3d9->IDirect3D9Ex_iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d9_AddRef(IDirect3D9Ex *iface) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + ULONG refcount = InterlockedIncrement(&d3d9->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, refcount); + + return refcount; +} + +static ULONG WINAPI d3d9_Release(IDirect3D9Ex *iface) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + ULONG refcount = InterlockedDecrement(&d3d9->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, refcount); + + if (!refcount) + { + wined3d_mutex_lock(); + wined3d_decref(d3d9->wined3d); + wined3d_mutex_unlock(); + + HeapFree(GetProcessHeap(), 0, d3d9); + } + + return refcount; +} + +static HRESULT WINAPI d3d9_RegisterSoftwareDevice(IDirect3D9Ex *iface, void *init_function) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + HRESULT hr; + + TRACE("iface %p, init_function %p.\n", iface, init_function); + + wined3d_mutex_lock(); + hr = wined3d_register_software_device(d3d9->wined3d, init_function); + wined3d_mutex_unlock(); + + return hr; +} + +static UINT WINAPI d3d9_GetAdapterCount(IDirect3D9Ex *iface) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + UINT ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_get_adapter_count(d3d9->wined3d); + wined3d_mutex_unlock(); + + return ret; +} + +static HRESULT WINAPI d3d9_GetAdapterIdentifier(IDirect3D9Ex *iface, UINT adapter, + DWORD flags, D3DADAPTER_IDENTIFIER9 *identifier) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + struct wined3d_adapter_identifier adapter_id; + HRESULT hr; + + TRACE("iface %p, adapter %u, flags %#x, identifier %p.\n", + iface, adapter, flags, identifier); + + adapter_id.driver = identifier->Driver; + adapter_id.driver_size = sizeof(identifier->Driver); + adapter_id.description = identifier->Description; + adapter_id.description_size = sizeof(identifier->Description); + adapter_id.device_name = identifier->DeviceName; + adapter_id.device_name_size = sizeof(identifier->DeviceName); + + wined3d_mutex_lock(); + hr = wined3d_get_adapter_identifier(d3d9->wined3d, adapter, flags, &adapter_id); + wined3d_mutex_unlock(); + + identifier->DriverVersion = adapter_id.driver_version; + identifier->VendorId = adapter_id.vendor_id; + identifier->DeviceId = adapter_id.device_id; + identifier->SubSysId = adapter_id.subsystem_id; + identifier->Revision = adapter_id.revision; + memcpy(&identifier->DeviceIdentifier, &adapter_id.device_identifier, sizeof(identifier->DeviceIdentifier)); + identifier->WHQLLevel = adapter_id.whql_level; + + return hr; +} + +static UINT WINAPI d3d9_GetAdapterModeCount(IDirect3D9Ex *iface, UINT adapter, D3DFORMAT format) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + UINT ret; + + TRACE("iface %p, adapter %u, format %#x.\n", iface, adapter, format); + + /* Others than that not supported by d3d9, but reported by wined3d for ddraw. Filter them out. */ + if (format != D3DFMT_X8R8G8B8 && format != D3DFMT_R5G6B5) + return 0; + + wined3d_mutex_lock(); + ret = wined3d_get_adapter_mode_count(d3d9->wined3d, adapter, + wined3dformat_from_d3dformat(format), WINED3D_SCANLINE_ORDERING_UNKNOWN); + wined3d_mutex_unlock(); + + return ret; +} + +static HRESULT WINAPI d3d9_EnumAdapterModes(IDirect3D9Ex *iface, UINT adapter, + D3DFORMAT format, UINT mode_idx, D3DDISPLAYMODE *mode) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + struct wined3d_display_mode wined3d_mode; + HRESULT hr; + + TRACE("iface %p, adapter %u, format %#x, mode_idx %u, mode %p.\n", + iface, adapter, format, mode_idx, mode); + + if (format != D3DFMT_X8R8G8B8 && format != D3DFMT_R5G6B5) + return D3DERR_INVALIDCALL; + + wined3d_mutex_lock(); + hr = wined3d_enum_adapter_modes(d3d9->wined3d, adapter, wined3dformat_from_d3dformat(format), + WINED3D_SCANLINE_ORDERING_UNKNOWN, mode_idx, &wined3d_mode); + wined3d_mutex_unlock(); + + if (SUCCEEDED(hr)) + { + mode->Width = wined3d_mode.width; + mode->Height = wined3d_mode.height; + mode->RefreshRate = wined3d_mode.refresh_rate; + mode->Format = d3dformat_from_wined3dformat(wined3d_mode.format_id); + } + + return hr; +} + +static HRESULT WINAPI d3d9_GetAdapterDisplayMode(IDirect3D9Ex *iface, UINT adapter, D3DDISPLAYMODE *mode) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + struct wined3d_display_mode wined3d_mode; + HRESULT hr; + + TRACE("iface %p, adapter %u, mode %p.\n", iface, adapter, mode); + + wined3d_mutex_lock(); + hr = wined3d_get_adapter_display_mode(d3d9->wined3d, adapter, &wined3d_mode, NULL); + wined3d_mutex_unlock(); + + if (SUCCEEDED(hr)) + { + mode->Width = wined3d_mode.width; + mode->Height = wined3d_mode.height; + mode->RefreshRate = wined3d_mode.refresh_rate; + mode->Format = d3dformat_from_wined3dformat(wined3d_mode.format_id); + } + + return hr; +} + +static HRESULT WINAPI d3d9_CheckDeviceType(IDirect3D9Ex *iface, UINT adapter, D3DDEVTYPE device_type, + D3DFORMAT display_format, D3DFORMAT backbuffer_format, BOOL windowed) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + HRESULT hr; + + TRACE("iface %p, adapter %u, device_type %#x, display_format %#x, backbuffer_format %#x, windowed %#x.\n", + iface, adapter, device_type, display_format, backbuffer_format, windowed); + + wined3d_mutex_lock(); + hr = wined3d_check_device_type(d3d9->wined3d, adapter, device_type, wined3dformat_from_d3dformat(display_format), + wined3dformat_from_d3dformat(backbuffer_format), windowed); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_CheckDeviceFormat(IDirect3D9Ex *iface, UINT adapter, D3DDEVTYPE device_type, + D3DFORMAT adapter_format, DWORD usage, D3DRESOURCETYPE resource_type, D3DFORMAT format) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + enum wined3d_resource_type wined3d_rtype; + HRESULT hr; + + TRACE("iface %p, adapter %u, device_type %#x, adapter_format %#x, usage %#x, resource_type %#x, format %#x.\n", + iface, adapter, device_type, adapter_format, usage, resource_type, format); + + switch (resource_type) + { + case D3DRTYPE_VERTEXBUFFER: + case D3DRTYPE_INDEXBUFFER: + wined3d_rtype = WINED3D_RTYPE_BUFFER; + break; + + default: + wined3d_rtype = resource_type; + break; + } + + wined3d_mutex_lock(); + hr = wined3d_check_device_format(d3d9->wined3d, adapter, device_type, wined3dformat_from_d3dformat(adapter_format), + usage, wined3d_rtype, wined3dformat_from_d3dformat(format)); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_CheckDeviceMultiSampleType(IDirect3D9Ex *iface, UINT adapter, D3DDEVTYPE device_type, + D3DFORMAT format, BOOL windowed, D3DMULTISAMPLE_TYPE multisample_type, DWORD *levels) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + HRESULT hr; + + TRACE("iface %p, adapter %u, device_type %#x, format %#x, windowed %#x, multisample_type %#x, levels %p.\n", + iface, adapter, device_type, format, windowed, multisample_type, levels); + + wined3d_mutex_lock(); + hr = wined3d_check_device_multisample_type(d3d9->wined3d, adapter, device_type, + wined3dformat_from_d3dformat(format), windowed, multisample_type, levels); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_CheckDepthStencilMatch(IDirect3D9Ex *iface, UINT adapter, D3DDEVTYPE device_type, + D3DFORMAT adapter_format, D3DFORMAT rt_format, D3DFORMAT ds_format) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + HRESULT hr; + + TRACE("iface %p, adapter %u, device_type %#x, adapter_format %#x, rt_format %#x, ds_format %#x.\n", + iface, adapter, device_type, adapter_format, rt_format, ds_format); + + wined3d_mutex_lock(); + hr = wined3d_check_depth_stencil_match(d3d9->wined3d, adapter, device_type, + wined3dformat_from_d3dformat(adapter_format), wined3dformat_from_d3dformat(rt_format), + wined3dformat_from_d3dformat(ds_format)); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_CheckDeviceFormatConversion(IDirect3D9Ex *iface, UINT adapter, + D3DDEVTYPE device_type, D3DFORMAT src_format, D3DFORMAT dst_format) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + HRESULT hr; + + TRACE("iface %p, adapter %u, device_type %#x, src_format %#x, dst_format %#x.\n", + iface, adapter, device_type, src_format, dst_format); + + wined3d_mutex_lock(); + hr = wined3d_check_device_format_conversion(d3d9->wined3d, adapter, device_type, + wined3dformat_from_d3dformat(src_format), wined3dformat_from_d3dformat(dst_format)); + wined3d_mutex_unlock(); + + return hr; +} + +void filter_caps(D3DCAPS9* pCaps) +{ + DWORD ps_minor_version[] = {0, 4, 0, 0}; + DWORD vs_minor_version[] = {0, 1, 0, 0}; + DWORD textureFilterCaps = + D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MINFLINEAR | D3DPTFILTERCAPS_MINFANISOTROPIC | + D3DPTFILTERCAPS_MINFPYRAMIDALQUAD | D3DPTFILTERCAPS_MINFGAUSSIANQUAD| + D3DPTFILTERCAPS_MIPFPOINT | D3DPTFILTERCAPS_MIPFLINEAR | D3DPTFILTERCAPS_MAGFPOINT | + D3DPTFILTERCAPS_MAGFLINEAR |D3DPTFILTERCAPS_MAGFANISOTROPIC|D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD| + D3DPTFILTERCAPS_MAGFGAUSSIANQUAD; + pCaps->TextureFilterCaps &= textureFilterCaps; + pCaps->CubeTextureFilterCaps &= textureFilterCaps; + pCaps->VolumeTextureFilterCaps &= textureFilterCaps; + + pCaps->DevCaps &= + D3DDEVCAPS_EXECUTESYSTEMMEMORY | D3DDEVCAPS_EXECUTEVIDEOMEMORY | D3DDEVCAPS_TLVERTEXSYSTEMMEMORY | + D3DDEVCAPS_TLVERTEXVIDEOMEMORY | D3DDEVCAPS_TEXTURESYSTEMMEMORY| D3DDEVCAPS_TEXTUREVIDEOMEMORY | + D3DDEVCAPS_DRAWPRIMTLVERTEX | D3DDEVCAPS_CANRENDERAFTERFLIP | D3DDEVCAPS_TEXTURENONLOCALVIDMEM| + D3DDEVCAPS_DRAWPRIMITIVES2 | D3DDEVCAPS_SEPARATETEXTUREMEMORIES | + D3DDEVCAPS_DRAWPRIMITIVES2EX | D3DDEVCAPS_HWTRANSFORMANDLIGHT| D3DDEVCAPS_CANBLTSYSTONONLOCAL | + D3DDEVCAPS_HWRASTERIZATION | D3DDEVCAPS_PUREDEVICE | D3DDEVCAPS_QUINTICRTPATCHES | + D3DDEVCAPS_RTPATCHES | D3DDEVCAPS_RTPATCHHANDLEZERO | D3DDEVCAPS_NPATCHES; + + pCaps->ShadeCaps &= + D3DPSHADECAPS_COLORGOURAUDRGB | D3DPSHADECAPS_SPECULARGOURAUDRGB | + D3DPSHADECAPS_ALPHAGOURAUDBLEND | D3DPSHADECAPS_FOGGOURAUD; + + pCaps->RasterCaps &= + D3DPRASTERCAPS_DITHER | D3DPRASTERCAPS_ZTEST | D3DPRASTERCAPS_FOGVERTEX | + D3DPRASTERCAPS_FOGTABLE | D3DPRASTERCAPS_MIPMAPLODBIAS | D3DPRASTERCAPS_ZBUFFERLESSHSR | + D3DPRASTERCAPS_FOGRANGE | D3DPRASTERCAPS_ANISOTROPY | D3DPRASTERCAPS_WBUFFER | + D3DPRASTERCAPS_WFOG | D3DPRASTERCAPS_ZFOG | D3DPRASTERCAPS_COLORPERSPECTIVE | + D3DPRASTERCAPS_SCISSORTEST | D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS | + D3DPRASTERCAPS_DEPTHBIAS | D3DPRASTERCAPS_MULTISAMPLE_TOGGLE; + + pCaps->DevCaps2 &= + D3DDEVCAPS2_STREAMOFFSET | D3DDEVCAPS2_DMAPNPATCH | D3DDEVCAPS2_ADAPTIVETESSRTPATCH | + D3DDEVCAPS2_ADAPTIVETESSNPATCH | D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES | + D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH| D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET; + + pCaps->Caps2 &= + D3DCAPS2_FULLSCREENGAMMA | D3DCAPS2_CANCALIBRATEGAMMA | D3DCAPS2_RESERVED | + D3DCAPS2_CANMANAGERESOURCE | D3DCAPS2_DYNAMICTEXTURES | D3DCAPS2_CANAUTOGENMIPMAP; + + pCaps->VertexProcessingCaps &= + D3DVTXPCAPS_TEXGEN | D3DVTXPCAPS_MATERIALSOURCE7 | D3DVTXPCAPS_DIRECTIONALLIGHTS | + D3DVTXPCAPS_POSITIONALLIGHTS | D3DVTXPCAPS_LOCALVIEWER | D3DVTXPCAPS_TWEENING | + D3DVTXPCAPS_TEXGEN_SPHEREMAP | D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER; + + pCaps->TextureCaps &= + D3DPTEXTURECAPS_PERSPECTIVE | D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_ALPHA | + D3DPTEXTURECAPS_SQUAREONLY | D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE | + D3DPTEXTURECAPS_ALPHAPALETTE | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | + D3DPTEXTURECAPS_PROJECTED | D3DPTEXTURECAPS_CUBEMAP | D3DPTEXTURECAPS_VOLUMEMAP | + D3DPTEXTURECAPS_MIPMAP | D3DPTEXTURECAPS_MIPVOLUMEMAP | D3DPTEXTURECAPS_MIPCUBEMAP | + D3DPTEXTURECAPS_CUBEMAP_POW2 | D3DPTEXTURECAPS_VOLUMEMAP_POW2| D3DPTEXTURECAPS_NOPROJECTEDBUMPENV; + + pCaps->MaxVertexShaderConst = min(D3D9_MAX_VERTEX_SHADER_CONSTANTF, pCaps->MaxVertexShaderConst); + pCaps->NumSimultaneousRTs = min(D3D9_MAX_SIMULTANEOUS_RENDERTARGETS, pCaps->NumSimultaneousRTs); + + if (pCaps->PixelShaderVersion > 3) + pCaps->PixelShaderVersion = D3DPS_VERSION(3,0); + else + { + DWORD major = pCaps->PixelShaderVersion; + pCaps->PixelShaderVersion = D3DPS_VERSION(major,ps_minor_version[major]); + } + + if (pCaps->VertexShaderVersion > 3) + pCaps->VertexShaderVersion = D3DVS_VERSION(3,0); + else + { + DWORD major = pCaps->VertexShaderVersion; + pCaps->VertexShaderVersion = D3DVS_VERSION(major,vs_minor_version[major]); + } +} + +static HRESULT WINAPI d3d9_GetDeviceCaps(IDirect3D9Ex *iface, UINT adapter, D3DDEVTYPE device_type, D3DCAPS9 *caps) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + WINED3DCAPS *wined3d_caps; + HRESULT hr; + + TRACE("iface %p, adapter %u, device_type %#x, caps %p.\n", iface, adapter, device_type, caps); + + if (!caps) + return D3DERR_INVALIDCALL; + + if (!(wined3d_caps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINED3DCAPS)))) + return D3DERR_INVALIDCALL; /*well this is what MSDN says to return*/ + memset(caps, 0, sizeof(*caps)); + + wined3d_mutex_lock(); + hr = wined3d_get_device_caps(d3d9->wined3d, adapter, device_type, wined3d_caps); + wined3d_mutex_unlock(); + + WINECAPSTOD3D9CAPS(caps, wined3d_caps) + HeapFree(GetProcessHeap(), 0, wined3d_caps); + + /* Some functionality is implemented in d3d9.dll, not wined3d.dll. Add the needed caps */ + caps->DevCaps2 |= D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES; + + filter_caps(caps); + + return hr; +} + +static HMONITOR WINAPI d3d9_GetAdapterMonitor(IDirect3D9Ex *iface, UINT adapter) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + HMONITOR ret; + + TRACE("iface %p, adapter %u.\n", iface, adapter); + + wined3d_mutex_lock(); + ret = wined3d_get_adapter_monitor(d3d9->wined3d, adapter); + wined3d_mutex_unlock(); + + return ret; +} + +static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_CreateDevice(IDirect3D9Ex *iface, UINT adapter, + D3DDEVTYPE device_type, HWND focus_window, DWORD flags, D3DPRESENT_PARAMETERS *parameters, + IDirect3DDevice9 **device) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + struct d3d9_device *object; + HRESULT hr; + + 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) + return E_OUTOFMEMORY; + + hr = device_init(object, d3d9, d3d9->wined3d, adapter, device_type, focus_window, flags, +#ifdef VBOX_WITH_WDDM + (VBOXWINEEX_D3DPRESENT_PARAMETERS *) +#endif + parameters, NULL); + if (FAILED(hr)) + { + WARN("Failed to initialize device, hr %#x.\n", hr); + HeapFree(GetProcessHeap(), 0, object); + return hr; + } + + TRACE("Created device %p.\n", object); + *device = (IDirect3DDevice9 *)object; + + return D3D_OK; +} + +static UINT WINAPI d3d9_GetAdapterModeCountEx(IDirect3D9Ex *iface, + UINT adapter, const D3DDISPLAYMODEFILTER *filter) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + UINT ret; + + TRACE("iface %p, adapter %u, filter %p.\n", iface, adapter, filter); + + if (filter->Format != D3DFMT_X8R8G8B8 && filter->Format != D3DFMT_R5G6B5) + return 0; + + wined3d_mutex_lock(); + ret = wined3d_get_adapter_mode_count(d3d9->wined3d, adapter, + wined3dformat_from_d3dformat(filter->Format), filter->ScanLineOrdering); + wined3d_mutex_unlock(); + + return ret; +} + +static HRESULT WINAPI d3d9_EnumAdapterModesEx(IDirect3D9Ex *iface, + UINT adapter, const D3DDISPLAYMODEFILTER *filter, UINT mode_idx, D3DDISPLAYMODEEX *mode) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + struct wined3d_display_mode wined3d_mode; + HRESULT hr; + + TRACE("iface %p, adapter %u, filter %p, mode_idx %u, mode %p.\n", + iface, adapter, filter, mode_idx, mode); + + if (filter->Format != D3DFMT_X8R8G8B8 && filter->Format != D3DFMT_R5G6B5) + return D3DERR_INVALIDCALL; + + wined3d_mutex_lock(); + hr = wined3d_enum_adapter_modes(d3d9->wined3d, adapter, wined3dformat_from_d3dformat(filter->Format), + filter->ScanLineOrdering, mode_idx, &wined3d_mode); + wined3d_mutex_unlock(); + + if (SUCCEEDED(hr)) + { + mode->Width = wined3d_mode.width; + mode->Height = wined3d_mode.height; + mode->RefreshRate = wined3d_mode.refresh_rate; + mode->Format = d3dformat_from_wined3dformat(wined3d_mode.format_id); + mode->ScanLineOrdering = wined3d_mode.scanline_ordering; + } + + return hr; +} + +static HRESULT WINAPI d3d9_GetAdapterDisplayModeEx(IDirect3D9Ex *iface, + UINT adapter, D3DDISPLAYMODEEX *mode, D3DDISPLAYROTATION *rotation) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + struct wined3d_display_mode wined3d_mode; + HRESULT hr; + + TRACE("iface %p, adapter %u, mode %p, rotation %p.\n", + iface, adapter, mode, rotation); + + if (mode->Size != sizeof(*mode)) + return D3DERR_INVALIDCALL; + + wined3d_mutex_lock(); + hr = wined3d_get_adapter_display_mode(d3d9->wined3d, adapter, &wined3d_mode, + (enum wined3d_display_rotation *)rotation); + wined3d_mutex_unlock(); + + if (SUCCEEDED(hr)) + { + mode->Width = wined3d_mode.width; + mode->Height = wined3d_mode.height; + mode->RefreshRate = wined3d_mode.refresh_rate; + mode->Format = d3dformat_from_wined3dformat(wined3d_mode.format_id); + mode->ScanLineOrdering = wined3d_mode.scanline_ordering; + } + + return hr; +} + +static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_CreateDeviceEx(IDirect3D9Ex *iface, + UINT adapter, D3DDEVTYPE device_type, HWND focus_window, DWORD flags, + D3DPRESENT_PARAMETERS *parameters, D3DDISPLAYMODEEX *mode, IDirect3DDevice9Ex **device) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + struct d3d9_device *object; + HRESULT hr; + + 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) + return E_OUTOFMEMORY; + + hr = device_init(object, d3d9, d3d9->wined3d, adapter, device_type, focus_window, flags, +#ifdef VBOX_WITH_WDDM + (VBOXWINEEX_D3DPRESENT_PARAMETERS *) +#endif + parameters, mode); + if (FAILED(hr)) + { + WARN("Failed to initialize device, hr %#x.\n", hr); + HeapFree(GetProcessHeap(), 0, object); + return hr; + } + + TRACE("Created device %p.\n", object); + *device = &object->IDirect3DDevice9Ex_iface; + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_GetAdapterLUID(IDirect3D9Ex *iface, UINT adapter, LUID *luid) +{ + struct d3d9 *d3d9 = impl_from_IDirect3D9Ex(iface); + struct wined3d_adapter_identifier adapter_id; + HRESULT hr; + + TRACE("iface %p, adapter %u, luid %p.\n", iface, adapter, luid); + + adapter_id.driver_size = 0; + adapter_id.description_size = 0; + adapter_id.device_name_size = 0; + + wined3d_mutex_lock(); + hr = wined3d_get_adapter_identifier(d3d9->wined3d, adapter, 0, &adapter_id); + wined3d_mutex_unlock(); + + memcpy(luid, &adapter_id.adapter_luid, sizeof(*luid)); + + return hr; +} + +static const struct IDirect3D9ExVtbl d3d9_vtbl = +{ + /* IUnknown */ + d3d9_QueryInterface, + d3d9_AddRef, + d3d9_Release, + /* IDirect3D9 */ + d3d9_RegisterSoftwareDevice, + d3d9_GetAdapterCount, + d3d9_GetAdapterIdentifier, + d3d9_GetAdapterModeCount, + d3d9_EnumAdapterModes, + d3d9_GetAdapterDisplayMode, + d3d9_CheckDeviceType, + d3d9_CheckDeviceFormat, + d3d9_CheckDeviceMultiSampleType, + d3d9_CheckDepthStencilMatch, + d3d9_CheckDeviceFormatConversion, + d3d9_GetDeviceCaps, + d3d9_GetAdapterMonitor, + d3d9_CreateDevice, + /* IDirect3D9Ex */ + d3d9_GetAdapterModeCountEx, + d3d9_EnumAdapterModesEx, + d3d9_GetAdapterDisplayModeEx, + d3d9_CreateDeviceEx, + d3d9_GetAdapterLUID, +}; + +BOOL d3d9_init(struct d3d9 *d3d9, BOOL extended) +{ + DWORD flags = extended ? 0 : WINED3D_VIDMEM_ACCOUNTING; + d3d9->IDirect3D9Ex_iface.lpVtbl = &d3d9_vtbl; + d3d9->refcount = 1; + + wined3d_mutex_lock(); + d3d9->wined3d = wined3d_create(9, flags); + wined3d_mutex_unlock(); + if (!d3d9->wined3d) + return FALSE; + d3d9->extended = extended; + + return TRUE; +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/query.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/query.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/query.c (revision 46521) @@ -0,0 +1,184 @@ +/* + * IDirect3DQuery9 implementation + * + * Copyright 2002-2003 Raphael Junqueira + * Copyright 2002-2003 Jason Edmeades + * Copyright 2005 Oliver Stieber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * 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); +} + +static HRESULT WINAPI d3d9_query_QueryInterface(IDirect3DQuery9 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DQuery9) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DQuery9_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d9_query_AddRef(IDirect3DQuery9 *iface) +{ + struct d3d9_query *query = impl_from_IDirect3DQuery9(iface); + ULONG refcount = InterlockedIncrement(&query->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, refcount); + + return refcount; +} + +static ULONG WINAPI d3d9_query_Release(IDirect3DQuery9 *iface) +{ + struct d3d9_query *query = impl_from_IDirect3DQuery9(iface); + ULONG refcount = InterlockedDecrement(&query->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, refcount); + + if (!refcount) + { + wined3d_mutex_lock(); + wined3d_query_decref(query->wined3d_query); + wined3d_mutex_unlock(); + + IDirect3DDevice9Ex_Release(query->parent_device); + HeapFree(GetProcessHeap(), 0, query); + } + return refcount; +} + +static HRESULT WINAPI d3d9_query_GetDevice(IDirect3DQuery9 *iface, IDirect3DDevice9 **device) +{ + struct d3d9_query *query = impl_from_IDirect3DQuery9(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = (IDirect3DDevice9 *)query->parent_device; + IDirect3DDevice9_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static D3DQUERYTYPE WINAPI d3d9_query_GetType(IDirect3DQuery9 *iface) +{ + struct d3d9_query *query = impl_from_IDirect3DQuery9(iface); + D3DQUERYTYPE type; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + type = wined3d_query_get_type(query->wined3d_query); + wined3d_mutex_unlock(); + + return type; +} + +static DWORD WINAPI d3d9_query_GetDataSize(IDirect3DQuery9 *iface) +{ + struct d3d9_query *query = impl_from_IDirect3DQuery9(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_query_get_data_size(query->wined3d_query); + wined3d_mutex_unlock(); + + return ret; +} + +static HRESULT WINAPI d3d9_query_Issue(IDirect3DQuery9 *iface, DWORD flags) +{ + struct d3d9_query *query = impl_from_IDirect3DQuery9(iface); + HRESULT hr; + + TRACE("iface %p, flags %#x.\n", iface, flags); + + wined3d_mutex_lock(); + hr = wined3d_query_issue(query->wined3d_query, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_query_GetData(IDirect3DQuery9 *iface, void *data, DWORD size, DWORD flags) +{ + struct d3d9_query *query = impl_from_IDirect3DQuery9(iface); + HRESULT hr; + + TRACE("iface %p, data %p, size %u, flags %#x.\n", + iface, data, size, flags); + + wined3d_mutex_lock(); + hr = wined3d_query_get_data(query->wined3d_query, data, size, flags); + wined3d_mutex_unlock(); + + return hr; +} + + +static const struct IDirect3DQuery9Vtbl d3d9_query_vtbl = +{ + d3d9_query_QueryInterface, + d3d9_query_AddRef, + d3d9_query_Release, + d3d9_query_GetDevice, + d3d9_query_GetType, + d3d9_query_GetDataSize, + d3d9_query_Issue, + d3d9_query_GetData, +}; + +HRESULT query_init(struct d3d9_query *query, struct d3d9_device *device, D3DQUERYTYPE type) +{ + HRESULT hr; + + query->IDirect3DQuery9_iface.lpVtbl = &d3d9_query_vtbl; + query->refcount = 1; + + wined3d_mutex_lock(); + hr = wined3d_query_create(device->wined3d_device, type, &query->wined3d_query); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d query, hr %#x.\n", hr); + return hr; + } + + query->parent_device = &device->IDirect3DDevice9Ex_iface; + IDirect3DDevice9Ex_AddRef(query->parent_device); + + return D3D_OK; +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/shader.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/shader.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/shader.c (revision 46521) @@ -0,0 +1,311 @@ +/* + * Copyright 2002-2003 Jason Edmeades + * Raphael Junqueira + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * 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); +} + +static HRESULT WINAPI d3d9_vertexshader_QueryInterface(IDirect3DVertexShader9 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DVertexShader9) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DVertexShader9_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d9_vertexshader_AddRef(IDirect3DVertexShader9 *iface) +{ + struct d3d9_vertexshader *shader = impl_from_IDirect3DVertexShader9(iface); + ULONG refcount = InterlockedIncrement(&shader->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, refcount); + + if (refcount == 1) + { + IDirect3DDevice9Ex_AddRef(shader->parent_device); + wined3d_mutex_lock(); + wined3d_shader_incref(shader->wined3d_shader); + wined3d_mutex_unlock(); + } + + return refcount; +} + +static ULONG WINAPI d3d9_vertexshader_Release(IDirect3DVertexShader9 *iface) +{ + struct d3d9_vertexshader *shader = impl_from_IDirect3DVertexShader9(iface); + ULONG refcount = InterlockedDecrement(&shader->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, refcount); + + if (!refcount) + { + IDirect3DDevice9Ex *device = shader->parent_device; + + wined3d_mutex_lock(); + wined3d_shader_decref(shader->wined3d_shader); + wined3d_mutex_unlock(); + + /* Release the device last, as it may cause the device to be destroyed. */ + IDirect3DDevice9Ex_Release(device); + } + + return refcount; +} + +static HRESULT WINAPI d3d9_vertexshader_GetDevice(IDirect3DVertexShader9 *iface, IDirect3DDevice9 **device) +{ + struct d3d9_vertexshader *shader = impl_from_IDirect3DVertexShader9(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = (IDirect3DDevice9 *)shader->parent_device; + IDirect3DDevice9_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_vertexshader_GetFunction(IDirect3DVertexShader9 *iface, void *data, UINT *data_size) +{ + struct d3d9_vertexshader *shader = impl_from_IDirect3DVertexShader9(iface); + HRESULT hr; + + TRACE("iface %p, data %p, data_size %p.\n", iface, data, data_size); + + wined3d_mutex_lock(); + hr = wined3d_shader_get_byte_code(shader->wined3d_shader, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static const IDirect3DVertexShader9Vtbl d3d9_vertexshader_vtbl = +{ + /* IUnknown */ + d3d9_vertexshader_QueryInterface, + d3d9_vertexshader_AddRef, + d3d9_vertexshader_Release, + /* IDirect3DVertexShader9 */ + d3d9_vertexshader_GetDevice, + d3d9_vertexshader_GetFunction, +}; + +static void STDMETHODCALLTYPE d3d9_vertexshader_wined3d_object_destroyed(void *parent) +{ + HeapFree(GetProcessHeap(), 0, parent); +} + +static const struct wined3d_parent_ops d3d9_vertexshader_wined3d_parent_ops = +{ + d3d9_vertexshader_wined3d_object_destroyed, +}; + +HRESULT vertexshader_init(struct d3d9_vertexshader *shader, struct d3d9_device *device, const DWORD *byte_code) +{ + HRESULT hr; + + shader->refcount = 1; + shader->IDirect3DVertexShader9_iface.lpVtbl = &d3d9_vertexshader_vtbl; + + wined3d_mutex_lock(); + hr = wined3d_shader_create_vs(device->wined3d_device, byte_code, NULL, + shader, &d3d9_vertexshader_wined3d_parent_ops, &shader->wined3d_shader, 3); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d vertex shader, hr %#x.\n", hr); + return hr; + } + + shader->parent_device = &device->IDirect3DDevice9Ex_iface; + IDirect3DDevice9Ex_AddRef(shader->parent_device); + + return D3D_OK; +} + +struct d3d9_vertexshader *unsafe_impl_from_IDirect3DVertexShader9(IDirect3DVertexShader9 *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == &d3d9_vertexshader_vtbl); + + return impl_from_IDirect3DVertexShader9(iface); +} + +static inline struct d3d9_pixelshader *impl_from_IDirect3DPixelShader9(IDirect3DPixelShader9 *iface) +{ + return CONTAINING_RECORD(iface, struct d3d9_pixelshader, IDirect3DPixelShader9_iface); +} + +static HRESULT WINAPI d3d9_pixelshader_QueryInterface(IDirect3DPixelShader9 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DPixelShader9) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DPixelShader9_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d9_pixelshader_AddRef(IDirect3DPixelShader9 *iface) +{ + struct d3d9_pixelshader *shader = impl_from_IDirect3DPixelShader9(iface); + ULONG refcount = InterlockedIncrement(&shader->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, refcount); + + if (refcount == 1) + { + IDirect3DDevice9Ex_AddRef(shader->parent_device); + wined3d_mutex_lock(); + wined3d_shader_incref(shader->wined3d_shader); + wined3d_mutex_unlock(); + } + + return refcount; +} + +static ULONG WINAPI d3d9_pixelshader_Release(IDirect3DPixelShader9 *iface) +{ + struct d3d9_pixelshader *shader = impl_from_IDirect3DPixelShader9(iface); + ULONG refcount = InterlockedDecrement(&shader->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, refcount); + + if (!refcount) + { + IDirect3DDevice9Ex *device = shader->parent_device; + + wined3d_mutex_lock(); + wined3d_shader_decref(shader->wined3d_shader); + wined3d_mutex_unlock(); + + /* Release the device last, as it may cause the device to be destroyed. */ + IDirect3DDevice9Ex_Release(device); + } + + return refcount; +} + +static HRESULT WINAPI d3d9_pixelshader_GetDevice(IDirect3DPixelShader9 *iface, IDirect3DDevice9 **device) +{ + struct d3d9_pixelshader *shader = impl_from_IDirect3DPixelShader9(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = (IDirect3DDevice9 *)shader->parent_device; + IDirect3DDevice9_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_pixelshader_GetFunction(IDirect3DPixelShader9 *iface, void *data, UINT *data_size) +{ + struct d3d9_pixelshader *shader = impl_from_IDirect3DPixelShader9(iface); + HRESULT hr; + + TRACE("iface %p, data %p, data_size %p.\n", iface, data, data_size); + + wined3d_mutex_lock(); + hr = wined3d_shader_get_byte_code(shader->wined3d_shader, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static const IDirect3DPixelShader9Vtbl d3d9_pixelshader_vtbl = +{ + /* IUnknown */ + d3d9_pixelshader_QueryInterface, + d3d9_pixelshader_AddRef, + d3d9_pixelshader_Release, + /* IDirect3DPixelShader9 */ + d3d9_pixelshader_GetDevice, + d3d9_pixelshader_GetFunction, +}; + +static void STDMETHODCALLTYPE d3d9_pixelshader_wined3d_object_destroyed(void *parent) +{ + HeapFree(GetProcessHeap(), 0, parent); +} + +static const struct wined3d_parent_ops d3d9_pixelshader_wined3d_parent_ops = +{ + d3d9_pixelshader_wined3d_object_destroyed, +}; + +HRESULT pixelshader_init(struct d3d9_pixelshader *shader, struct d3d9_device *device, const DWORD *byte_code) +{ + HRESULT hr; + + shader->refcount = 1; + shader->IDirect3DPixelShader9_iface.lpVtbl = &d3d9_pixelshader_vtbl; + + wined3d_mutex_lock(); + hr = wined3d_shader_create_ps(device->wined3d_device, byte_code, NULL, shader, + &d3d9_pixelshader_wined3d_parent_ops, &shader->wined3d_shader, 3); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to created wined3d pixel shader, hr %#x.\n", hr); + return hr; + } + + shader->parent_device = &device->IDirect3DDevice9Ex_iface; + IDirect3DDevice9Ex_AddRef(shader->parent_device); + + return D3D_OK; +} + +struct d3d9_pixelshader *unsafe_impl_from_IDirect3DPixelShader9(IDirect3DPixelShader9 *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == &d3d9_pixelshader_vtbl); + + return impl_from_IDirect3DPixelShader9(iface); +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/stateblock.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/stateblock.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/stateblock.c (revision 46521) @@ -0,0 +1,163 @@ +/* + * IDirect3DStateBlock9 implementation + * + * Copyright 2002-2003 Raphael Junqueira + * Copyright 2002-2003 Jason Edmeades + * Copyright 2005 Oliver Stieber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * 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); +} + +static HRESULT WINAPI d3d9_stateblock_QueryInterface(IDirect3DStateBlock9 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DStateBlock9) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DStateBlock9_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d9_stateblock_AddRef(IDirect3DStateBlock9 *iface) +{ + struct d3d9_stateblock *stateblock = impl_from_IDirect3DStateBlock9(iface); + ULONG refcount = InterlockedIncrement(&stateblock->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, refcount); + + return refcount; +} + +static ULONG WINAPI d3d9_stateblock_Release(IDirect3DStateBlock9 *iface) +{ + struct d3d9_stateblock *stateblock = impl_from_IDirect3DStateBlock9(iface); + ULONG refcount = InterlockedDecrement(&stateblock->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, refcount); + + if (!refcount) + { + wined3d_mutex_lock(); + wined3d_stateblock_decref(stateblock->wined3d_stateblock); + wined3d_mutex_unlock(); + + IDirect3DDevice9Ex_Release(stateblock->parent_device); + HeapFree(GetProcessHeap(), 0, stateblock); + } + + return refcount; +} + +static HRESULT WINAPI d3d9_stateblock_GetDevice(IDirect3DStateBlock9 *iface, IDirect3DDevice9 **device) +{ + struct d3d9_stateblock *stateblock = impl_from_IDirect3DStateBlock9(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = (IDirect3DDevice9 *)stateblock->parent_device; + IDirect3DDevice9_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_stateblock_Capture(IDirect3DStateBlock9 *iface) +{ + struct d3d9_stateblock *stateblock = impl_from_IDirect3DStateBlock9(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_stateblock_capture(stateblock->wined3d_stateblock); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_stateblock_Apply(IDirect3DStateBlock9 *iface) +{ + struct d3d9_stateblock *stateblock = impl_from_IDirect3DStateBlock9(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_stateblock_apply(stateblock->wined3d_stateblock); + wined3d_mutex_unlock(); + + return D3D_OK; +} + + +static const struct IDirect3DStateBlock9Vtbl d3d9_stateblock_vtbl = +{ + /* IUnknown */ + d3d9_stateblock_QueryInterface, + d3d9_stateblock_AddRef, + d3d9_stateblock_Release, + /* IDirect3DStateBlock9 */ + d3d9_stateblock_GetDevice, + d3d9_stateblock_Capture, + d3d9_stateblock_Apply, +}; + +HRESULT stateblock_init(struct d3d9_stateblock *stateblock, struct d3d9_device *device, + D3DSTATEBLOCKTYPE type, struct wined3d_stateblock *wined3d_stateblock) +{ + HRESULT hr; + + stateblock->IDirect3DStateBlock9_iface.lpVtbl = &d3d9_stateblock_vtbl; + stateblock->refcount = 1; + + if (wined3d_stateblock) + { + stateblock->wined3d_stateblock = wined3d_stateblock; + } + else + { + wined3d_mutex_lock(); + hr = wined3d_stateblock_create(device->wined3d_device, + (enum wined3d_stateblock_type)type, &stateblock->wined3d_stateblock); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d stateblock, hr %#x.\n", hr); + return hr; + } + } + + stateblock->parent_device = &device->IDirect3DDevice9Ex_iface; + IDirect3DDevice9Ex_AddRef(stateblock->parent_device); + + return D3D_OK; +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/surface.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/surface.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/surface.c (revision 46521) @@ -0,0 +1,459 @@ +/* + * IDirect3DSurface9 implementation + * + * Copyright 2002-2005 Jason Edmeades + * Raphael Junqueira + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * 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); +} + +static HRESULT WINAPI d3d9_surface_QueryInterface(IDirect3DSurface9 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DSurface9) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DSurface9_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d9_surface_AddRef(IDirect3DSurface9 *iface) +{ + struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface); + ULONG refcount; + + TRACE("iface %p.\n", iface); + + if (surface->forwardReference) + { + TRACE("Forwarding to %p.\n", surface->forwardReference); + return IUnknown_AddRef(surface->forwardReference); + } + + refcount = InterlockedIncrement(&surface->refcount); + TRACE("%p increasing refcount to %u.\n", iface, refcount); + + if (refcount == 1) + { + if (surface->parent_device) + IDirect3DDevice9Ex_AddRef(surface->parent_device); + wined3d_mutex_lock(); + wined3d_surface_incref(surface->wined3d_surface); + wined3d_mutex_unlock(); + } + + return refcount; +} + +static ULONG WINAPI d3d9_surface_Release(IDirect3DSurface9 *iface) +{ + struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface); + ULONG refcount; + + TRACE("iface %p.\n", iface); + + if (surface->forwardReference) + { + TRACE("Forwarding to %p.\n", surface->forwardReference); + return IUnknown_Release(surface->forwardReference); + } + + refcount = InterlockedDecrement(&surface->refcount); + TRACE("%p decreasing refcount to %u.\n", iface, refcount); + + if (!refcount) + { + IDirect3DDevice9Ex *parent_device = surface->parent_device; + + wined3d_mutex_lock(); + wined3d_surface_decref(surface->wined3d_surface); + wined3d_mutex_unlock(); + + /* Release the device last, as it may cause the device to be destroyed. */ + if (parent_device) + IDirect3DDevice9Ex_Release(parent_device); + } + + return refcount; +} + +static HRESULT WINAPI d3d9_surface_GetDevice(IDirect3DSurface9 *iface, IDirect3DDevice9 **device) +{ + struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + if (surface->forwardReference) + { + IDirect3DResource9 *resource; + HRESULT hr; + + hr = IUnknown_QueryInterface(surface->forwardReference, &IID_IDirect3DResource9, (void **)&resource); + if (SUCCEEDED(hr)) + { + hr = IDirect3DResource9_GetDevice(resource, device); + IDirect3DResource9_Release(resource); + + TRACE("Returning device %p.\n", *device); + } + + return hr; + } + + *device = (IDirect3DDevice9 *)surface->parent_device; + IDirect3DDevice9_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_surface_SetPrivateData(IDirect3DSurface9 *iface, REFGUID guid, + const void *data, DWORD data_size, DWORD flags) +{ + struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n", + iface, debugstr_guid(guid), data, data_size, flags); + + wined3d_mutex_lock(); + resource = wined3d_surface_get_resource(surface->wined3d_surface); + hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_surface_GetPrivateData(IDirect3DSurface9 *iface, REFGUID guid, + void *data, DWORD *data_size) +{ + struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %p.\n", + iface, debugstr_guid(guid), data, data_size); + + wined3d_mutex_lock(); + resource = wined3d_surface_get_resource(surface->wined3d_surface); + hr = wined3d_resource_get_private_data(resource, guid, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_surface_FreePrivateData(IDirect3DSurface9 *iface, REFGUID guid) +{ + struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid)); + + wined3d_mutex_lock(); + resource = wined3d_surface_get_resource(surface->wined3d_surface); + hr = wined3d_resource_free_private_data(resource, guid); + wined3d_mutex_unlock(); + + return hr; +} + +static DWORD WINAPI d3d9_surface_SetPriority(IDirect3DSurface9 *iface, DWORD priority) +{ + struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface); + DWORD ret; + + TRACE("iface %p, priority %u.\n", iface, priority); + + wined3d_mutex_lock(); + ret = wined3d_surface_set_priority(surface->wined3d_surface, priority); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d9_surface_GetPriority(IDirect3DSurface9 *iface) +{ + struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_surface_get_priority(surface->wined3d_surface); + wined3d_mutex_unlock(); + + return ret; +} + +static void WINAPI d3d9_surface_PreLoad(IDirect3DSurface9 *iface) +{ + struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_surface_preload(surface->wined3d_surface); + wined3d_mutex_unlock(); +} + +static D3DRESOURCETYPE WINAPI d3d9_surface_GetType(IDirect3DSurface9 *iface) +{ + TRACE("iface %p.\n", iface); + + return D3DRTYPE_SURFACE; +} + +static HRESULT WINAPI d3d9_surface_GetContainer(IDirect3DSurface9 *iface, REFIID riid, void **container) +{ + struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface); + HRESULT hr; + + TRACE("iface %p, riid %s, container %p.\n", iface, debugstr_guid(riid), container); + + if (!surface->container) + return E_NOINTERFACE; + + hr = IUnknown_QueryInterface(surface->container, riid, container); + + TRACE("Returning %p.\n", *container); + + return hr; +} + +static HRESULT WINAPI d3d9_surface_GetDesc(IDirect3DSurface9 *iface, D3DSURFACE_DESC *desc) +{ + struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface); + struct wined3d_resource_desc wined3d_desc; + struct wined3d_resource *wined3d_resource; + + TRACE("iface %p, desc %p.\n", iface, desc); + + wined3d_mutex_lock(); + wined3d_resource = wined3d_surface_get_resource(surface->wined3d_surface); + wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); + wined3d_mutex_unlock(); + + desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); + desc->Type = wined3d_desc.resource_type; + desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; + desc->Pool = wined3d_desc.pool; + desc->MultiSampleType = wined3d_desc.multisample_type; + desc->MultiSampleQuality = wined3d_desc.multisample_quality; + desc->Width = wined3d_desc.width; + desc->Height = wined3d_desc.height; + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_surface_LockRect(IDirect3DSurface9 *iface, + D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) +{ + struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface); + struct wined3d_map_desc map_desc; + HRESULT hr; + + TRACE("iface %p, locked_rect %p, rect %s, flags %#x.\n", + iface, locked_rect, wine_dbgstr_rect(rect), flags); + + wined3d_mutex_lock(); + hr = wined3d_surface_map(surface->wined3d_surface, &map_desc, rect, flags); + wined3d_mutex_unlock(); + + locked_rect->Pitch = map_desc.row_pitch; + locked_rect->pBits = map_desc.data; + + return hr; +} + +static HRESULT WINAPI d3d9_surface_UnlockRect(IDirect3DSurface9 *iface) +{ + struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface); + HRESULT hr; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + hr = wined3d_surface_unmap(surface->wined3d_surface); + wined3d_mutex_unlock(); + + switch(hr) + { + case WINEDDERR_NOTLOCKED: return D3DERR_INVALIDCALL; + default: return hr; + } +} + +static HRESULT WINAPI d3d9_surface_GetDC(IDirect3DSurface9 *iface, HDC *dc) +{ + struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface); + HRESULT hr; + + TRACE("iface %p, dc %p.\n", iface, dc); + + if (!surface->getdc_supported) + { + WARN("Surface does not support GetDC, returning D3DERR_INVALIDCALL\n"); + /* Don't touch the DC */ + return D3DERR_INVALIDCALL; + } + + wined3d_mutex_lock(); + hr = wined3d_surface_getdc(surface->wined3d_surface, dc); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_surface_ReleaseDC(IDirect3DSurface9 *iface, HDC dc) +{ + struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface); + HRESULT hr; + + TRACE("iface %p, dc %p.\n", iface, dc); + + wined3d_mutex_lock(); + hr = wined3d_surface_releasedc(surface->wined3d_surface, dc); + wined3d_mutex_unlock(); + + switch (hr) + { + case WINEDDERR_NODC: return D3DERR_INVALIDCALL; + default: return hr; + } +} + +static const struct IDirect3DSurface9Vtbl d3d9_surface_vtbl = +{ + /* IUnknown */ + d3d9_surface_QueryInterface, + d3d9_surface_AddRef, + d3d9_surface_Release, + /* IDirect3DResource9 */ + d3d9_surface_GetDevice, + d3d9_surface_SetPrivateData, + d3d9_surface_GetPrivateData, + d3d9_surface_FreePrivateData, + d3d9_surface_SetPriority, + d3d9_surface_GetPriority, + d3d9_surface_PreLoad, + d3d9_surface_GetType, + /* IDirect3DSurface9 */ + d3d9_surface_GetContainer, + d3d9_surface_GetDesc, + d3d9_surface_LockRect, + d3d9_surface_UnlockRect, + d3d9_surface_GetDC, + d3d9_surface_ReleaseDC, +}; + +static void STDMETHODCALLTYPE surface_wined3d_object_destroyed(void *parent) +{ + HeapFree(GetProcessHeap(), 0, parent); +} + +static const struct wined3d_parent_ops d3d9_surface_wined3d_parent_ops = +{ + surface_wined3d_object_destroyed, +}; + +HRESULT surface_init(struct d3d9_surface *surface, struct d3d9_device *device, UINT width, UINT height, + D3DFORMAT format, DWORD flags, DWORD usage, D3DPOOL pool, D3DMULTISAMPLE_TYPE multisample_type, + DWORD multisample_quality +#ifdef VBOX_WITH_WDDM + , HANDLE *shared_handle + , void *pvClientMem +#endif + ) +{ + HRESULT hr; + + surface->IDirect3DSurface9_iface.lpVtbl = &d3d9_surface_vtbl; + surface->refcount = 1; + + switch (format) + { + case D3DFMT_A8R8G8B8: + case D3DFMT_X8R8G8B8: + case D3DFMT_R5G6B5: + case D3DFMT_X1R5G5B5: + case D3DFMT_A1R5G5B5: + case D3DFMT_R8G8B8: + surface->getdc_supported = TRUE; + break; + + default: + surface->getdc_supported = FALSE; + break; + } + + /* FIXME: Check MAX bounds of MultisampleQuality. */ + if (multisample_quality > 0) + { + FIXME("Multisample quality set to %u, substituting 0.\n", multisample_quality); + multisample_quality = 0; + } + + wined3d_mutex_lock(); + hr = wined3d_surface_create(device->wined3d_device, width, height, wined3dformat_from_d3dformat(format), + usage & WINED3DUSAGE_MASK, (enum wined3d_pool)pool, multisample_type, multisample_quality, + flags, surface, &d3d9_surface_wined3d_parent_ops, &surface->wined3d_surface +#ifdef VBOX_WITH_WDDM + , shared_handle + , pvClientMem +#endif + ); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d surface, hr %#x.\n", hr); + return hr; + } + + surface->parent_device = &device->IDirect3DDevice9Ex_iface; + IDirect3DDevice9Ex_AddRef(surface->parent_device); + + return D3D_OK; +} + +struct d3d9_surface *unsafe_impl_from_IDirect3DSurface9(IDirect3DSurface9 *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == &d3d9_surface_vtbl); + + return impl_from_IDirect3DSurface9(iface); +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/swapchain.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/swapchain.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/swapchain.c (revision 46521) @@ -0,0 +1,308 @@ +/* + * IDirect3DSwapChain9 implementation + * + * Copyright 2002-2003 Jason Edmeades + * Raphael Junqueira + * Copyright 2005 Oliver Stieber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * 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_IDirect3DSwapChain9(IDirect3DSwapChain9 *iface) +{ + return CONTAINING_RECORD(iface, struct d3d9_swapchain, IDirect3DSwapChain9_iface); +} + +static HRESULT WINAPI d3d9_swapchain_QueryInterface(IDirect3DSwapChain9 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DSwapChain9) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DSwapChain9_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d9_swapchain_AddRef(IDirect3DSwapChain9 *iface) +{ + struct d3d9_swapchain *swapchain = impl_from_IDirect3DSwapChain9(iface); + ULONG refcount = InterlockedIncrement(&swapchain->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, refcount); + + if (refcount == 1) + { + if (swapchain->parent_device) + IDirect3DDevice9Ex_AddRef(swapchain->parent_device); + + wined3d_mutex_lock(); + wined3d_swapchain_incref(swapchain->wined3d_swapchain); + wined3d_mutex_unlock(); + } + + return refcount; +} + +static ULONG WINAPI d3d9_swapchain_Release(IDirect3DSwapChain9 *iface) +{ + struct d3d9_swapchain *swapchain = impl_from_IDirect3DSwapChain9(iface); + ULONG refcount = InterlockedDecrement(&swapchain->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, refcount); + + if (!refcount) + { + IDirect3DDevice9Ex *parent_device = swapchain->parent_device; + + wined3d_mutex_lock(); + wined3d_swapchain_decref(swapchain->wined3d_swapchain); + wined3d_mutex_unlock(); + + /* Release the device last, as it may cause the device to be destroyed. */ + if (parent_device) + IDirect3DDevice9Ex_Release(parent_device); + } + + return refcount; +} + +static HRESULT WINAPI DECLSPEC_HOTPATCH d3d9_swapchain_Present(IDirect3DSwapChain9 *iface, + const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override, + const RGNDATA *dirty_region, DWORD flags) +{ + struct d3d9_swapchain *swapchain = impl_from_IDirect3DSwapChain9(iface); + HRESULT hr; + + TRACE("iface %p, src_rect %s, dst_rect %s, dst_window_override %p, dirty_region %p, flags %#x.\n", + iface, wine_dbgstr_rect(src_rect), wine_dbgstr_rect(dst_rect), + dst_window_override, dirty_region, flags); + + wined3d_mutex_lock(); + hr = wined3d_swapchain_present(swapchain->wined3d_swapchain, src_rect, + dst_rect, dst_window_override, dirty_region, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_swapchain_GetFrontBufferData(IDirect3DSwapChain9 *iface, IDirect3DSurface9 *surface) +{ + struct d3d9_swapchain *swapchain = impl_from_IDirect3DSwapChain9(iface); + struct d3d9_surface *dst = unsafe_impl_from_IDirect3DSurface9(surface); + HRESULT hr; + + TRACE("iface %p, surface %p.\n", iface, surface); + + wined3d_mutex_lock(); + hr = wined3d_swapchain_get_front_buffer_data(swapchain->wined3d_swapchain, dst->wined3d_surface); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_swapchain_GetBackBuffer(IDirect3DSwapChain9 *iface, + UINT backbuffer_idx, D3DBACKBUFFER_TYPE backbuffer_type, IDirect3DSurface9 **backbuffer) +{ + struct d3d9_swapchain *swapchain = impl_from_IDirect3DSwapChain9(iface); + struct wined3d_surface *wined3d_surface = NULL; + struct d3d9_surface *surface_impl; + HRESULT hr = D3D_OK; + + TRACE("iface %p, backbuffer_idx %u, backbuffer_type %#x, backbuffer %p.\n", + iface, backbuffer_idx, backbuffer_type, backbuffer); + + wined3d_mutex_lock(); + if ((wined3d_surface = wined3d_swapchain_get_back_buffer(swapchain->wined3d_swapchain, + backbuffer_idx, (enum wined3d_backbuffer_type)backbuffer_type))) + { + surface_impl = wined3d_surface_get_parent(wined3d_surface); + *backbuffer = &surface_impl->IDirect3DSurface9_iface; + IDirect3DSurface9_AddRef(*backbuffer); + } + else + { + hr = D3DERR_INVALIDCALL; + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_swapchain_GetRasterStatus(IDirect3DSwapChain9 *iface, D3DRASTER_STATUS *raster_status) +{ + struct d3d9_swapchain *swapchain = impl_from_IDirect3DSwapChain9(iface); + HRESULT hr; + + TRACE("iface %p, raster_status %p.\n", iface, raster_status); + + wined3d_mutex_lock(); + hr = wined3d_swapchain_get_raster_status(swapchain->wined3d_swapchain, + (struct wined3d_raster_status *)raster_status); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_swapchain_GetDisplayMode(IDirect3DSwapChain9 *iface, D3DDISPLAYMODE *mode) +{ + struct d3d9_swapchain *swapchain = impl_from_IDirect3DSwapChain9(iface); + struct wined3d_display_mode wined3d_mode; + HRESULT hr; + + TRACE("iface %p, mode %p.\n", iface, mode); + + wined3d_mutex_lock(); + hr = wined3d_swapchain_get_display_mode(swapchain->wined3d_swapchain, &wined3d_mode, NULL); + wined3d_mutex_unlock(); + + if (SUCCEEDED(hr)) + { + mode->Width = wined3d_mode.width; + mode->Height = wined3d_mode.height; + mode->RefreshRate = wined3d_mode.refresh_rate; + mode->Format = d3dformat_from_wined3dformat(wined3d_mode.format_id); + } + + return hr; +} + +static HRESULT WINAPI d3d9_swapchain_GetDevice(IDirect3DSwapChain9 *iface, IDirect3DDevice9 **device) +{ + struct d3d9_swapchain *swapchain = impl_from_IDirect3DSwapChain9(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = (IDirect3DDevice9 *)swapchain->parent_device; + IDirect3DDevice9_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_swapchain_GetPresentParameters(IDirect3DSwapChain9 *iface, + D3DPRESENT_PARAMETERS *parameters) +{ + struct d3d9_swapchain *swapchain = impl_from_IDirect3DSwapChain9(iface); + struct wined3d_swapchain_desc desc; + + TRACE("iface %p, parameters %p.\n", iface, parameters); + + wined3d_mutex_lock(); + wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &desc); + wined3d_mutex_unlock(); + present_parameters_from_wined3d_swapchain_desc(parameters, &desc); + + return D3D_OK; +} + + +static const struct IDirect3DSwapChain9Vtbl d3d9_swapchain_vtbl = +{ + d3d9_swapchain_QueryInterface, + d3d9_swapchain_AddRef, + d3d9_swapchain_Release, + d3d9_swapchain_Present, + d3d9_swapchain_GetFrontBufferData, + d3d9_swapchain_GetBackBuffer, + d3d9_swapchain_GetRasterStatus, + d3d9_swapchain_GetDisplayMode, + d3d9_swapchain_GetDevice, + d3d9_swapchain_GetPresentParameters, +}; + +static void STDMETHODCALLTYPE d3d9_swapchain_wined3d_object_released(void *parent) +{ + HeapFree(GetProcessHeap(), 0, parent); +} + +static const struct wined3d_parent_ops d3d9_swapchain_wined3d_parent_ops = +{ + d3d9_swapchain_wined3d_object_released, +}; + +static HRESULT swapchain_init(struct d3d9_swapchain *swapchain, struct d3d9_device *device, + struct wined3d_swapchain_desc *desc) +{ + HRESULT hr; + + swapchain->refcount = 1; + swapchain->IDirect3DSwapChain9_iface.lpVtbl = &d3d9_swapchain_vtbl; + + wined3d_mutex_lock(); + hr = wined3d_swapchain_create(device->wined3d_device, desc, swapchain, + &d3d9_swapchain_wined3d_parent_ops, &swapchain->wined3d_swapchain); + wined3d_mutex_unlock(); + + if (FAILED(hr)) + { + WARN("Failed to create wined3d swapchain, hr %#x.\n", hr); + return hr; + } + + swapchain->parent_device = &device->IDirect3DDevice9Ex_iface; + IDirect3DDevice9Ex_AddRef(swapchain->parent_device); + + return D3D_OK; +} + +HRESULT d3d9_swapchain_create(struct d3d9_device *device, struct wined3d_swapchain_desc *desc, + struct d3d9_swapchain **swapchain) +{ + struct d3d9_swapchain *object; + HRESULT hr; + + if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 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); + return hr; + } + + TRACE("Created swapchain %p.\n", object); + *swapchain = object; + + return D3D_OK; +} + +#ifdef VBOX_WITH_WDDM +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DSwapchain9Present(IDirect3DSwapChain9 *iface, + IDirect3DSurface9 *surf) /* use the given surface as a frontbuffer content source */ +{ + struct d3d9_swapchain *swapchain = impl_from_IDirect3DSwapChain9(iface); + struct d3d9_surface *rt = unsafe_impl_from_IDirect3DSurface9(surf); + HRESULT hr; + wined3d_mutex_lock(); + hr = wined3d_swapchain_present_rt(swapchain->wined3d_swapchain, rt->wined3d_surface); + wined3d_mutex_unlock(); + return hr; +} +#endif Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/texture.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/texture.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/texture.c (revision 46521) @@ -0,0 +1,1453 @@ +/* + * Copyright 2002-2005 Jason Edmeades + * Copyright 2002-2005 Raphael Junqueira + * Copyright 2005 Oliver Stieber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * 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); +} + +static inline struct d3d9_texture *impl_from_IDirect3DCubeTexture9(IDirect3DCubeTexture9 *iface) +{ + return CONTAINING_RECORD(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); +} + +static HRESULT WINAPI d3d9_texture_2d_QueryInterface(IDirect3DTexture9 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DTexture9) + || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DTexture9_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d9_texture_2d_AddRef(IDirect3DTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + ULONG ref = InterlockedIncrement(&texture->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, ref); + + if (ref == 1) + { + IDirect3DDevice9Ex_AddRef(texture->parent_device); + wined3d_mutex_lock(); + wined3d_texture_incref(texture->wined3d_texture); + wined3d_mutex_unlock(); + } + + return ref; +} + +static ULONG WINAPI d3d9_texture_2d_Release(IDirect3DTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + ULONG ref = InterlockedDecrement(&texture->refcount); + + 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); + } + return ref; +} + +static HRESULT WINAPI d3d9_texture_2d_GetDevice(IDirect3DTexture9 *iface, IDirect3DDevice9 **device) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = (IDirect3DDevice9 *)texture->parent_device; + IDirect3DDevice9_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_texture_2d_SetPrivateData(IDirect3DTexture9 *iface, + REFGUID guid, const void *data, DWORD data_size, DWORD flags) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n", + iface, debugstr_guid(guid), data, data_size, flags); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_texture_2d_GetPrivateData(IDirect3DTexture9 *iface, + REFGUID guid, void *data, DWORD *data_size) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %p.\n", + iface, debugstr_guid(guid), data, data_size); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_get_private_data(resource, guid, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_texture_2d_FreePrivateData(IDirect3DTexture9 *iface, REFGUID guid) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid)); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_free_private_data(resource, guid); + wined3d_mutex_unlock(); + + return hr; +} + +static DWORD WINAPI d3d9_texture_2d_SetPriority(IDirect3DTexture9 *iface, DWORD priority) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + DWORD ret; + + TRACE("iface %p, priority %u.\n", iface, priority); + + wined3d_mutex_lock(); + ret = wined3d_texture_set_priority(texture->wined3d_texture, priority); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d9_texture_2d_GetPriority(IDirect3DTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_priority(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +static void WINAPI d3d9_texture_2d_PreLoad(IDirect3DTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_texture_preload(texture->wined3d_texture); + wined3d_mutex_unlock(); +} + +static D3DRESOURCETYPE WINAPI d3d9_texture_2d_GetType(IDirect3DTexture9 *iface) +{ + TRACE("iface %p.\n", iface); + + return D3DRTYPE_TEXTURE; +} + +static DWORD WINAPI d3d9_texture_2d_SetLOD(IDirect3DTexture9 *iface, DWORD lod) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + DWORD ret; + + TRACE("iface %p, lod %u.\n", iface, lod); + + wined3d_mutex_lock(); + ret = wined3d_texture_set_lod(texture->wined3d_texture, lod); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d9_texture_2d_GetLOD(IDirect3DTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_lod(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d9_texture_2d_GetLevelCount(IDirect3DTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_level_count(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +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(); + + return hr; +} + +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(); + + return ret; +} + +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(); + wined3d_texture_generate_mipmaps(texture->wined3d_texture); + wined3d_mutex_unlock(); +} + +static HRESULT WINAPI d3d9_texture_2d_GetLevelDesc(IDirect3DTexture9 *iface, UINT level, D3DSURFACE_DESC *desc) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + struct wined3d_resource *sub_resource; + HRESULT hr = D3D_OK; + + TRACE("iface %p, level %u, desc %p.\n", iface, level, desc); + + wined3d_mutex_lock(); + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + hr = D3DERR_INVALIDCALL; + else + { + struct wined3d_resource_desc wined3d_desc; + + wined3d_resource_get_desc(sub_resource, &wined3d_desc); + desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); + desc->Type = wined3d_desc.resource_type; + desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; + desc->Pool = wined3d_desc.pool; + desc->MultiSampleType = wined3d_desc.multisample_type; + desc->MultiSampleQuality = wined3d_desc.multisample_quality; + desc->Width = wined3d_desc.width; + desc->Height = wined3d_desc.height; + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_texture_2d_GetSurfaceLevel(IDirect3DTexture9 *iface, + UINT level, IDirect3DSurface9 **surface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + struct wined3d_resource *sub_resource; + struct d3d9_surface *surface_impl; + + TRACE("iface %p, level %u, surface %p.\n", iface, level, surface); + + wined3d_mutex_lock(); + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + { + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + + surface_impl = wined3d_resource_get_parent(sub_resource); + *surface = &surface_impl->IDirect3DSurface9_iface; + IDirect3DSurface9_AddRef(*surface); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_texture_2d_LockRect(IDirect3DTexture9 *iface, + UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + struct wined3d_resource *sub_resource; + struct d3d9_surface *surface_impl; + HRESULT hr; + + TRACE("iface %p, level %u, locked_rect %p, rect %p, flags %#x.\n", + iface, level, locked_rect, rect, flags); + + wined3d_mutex_lock(); + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + hr = D3DERR_INVALIDCALL; + else + { + surface_impl = wined3d_resource_get_parent(sub_resource); + hr = IDirect3DSurface9_LockRect(&surface_impl->IDirect3DSurface9_iface, locked_rect, rect, flags); + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_texture_2d_UnlockRect(IDirect3DTexture9 *iface, UINT level) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + struct wined3d_resource *sub_resource; + struct d3d9_surface *surface_impl; + HRESULT hr; + + TRACE("iface %p, level %u.\n", iface, level); + + wined3d_mutex_lock(); + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + hr = D3DERR_INVALIDCALL; + else + { + surface_impl = wined3d_resource_get_parent(sub_resource); + hr = IDirect3DSurface9_UnlockRect(&surface_impl->IDirect3DSurface9_iface); + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_texture_2d_AddDirtyRect(IDirect3DTexture9 *iface, const RECT *dirty_rect) +{ + struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); + HRESULT hr; + + TRACE("iface %p, dirty_rect %s.\n", + iface, wine_dbgstr_rect(dirty_rect)); + + wined3d_mutex_lock(); + if (!dirty_rect) + hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, NULL); + else + { + struct wined3d_box dirty_region; + + dirty_region.left = dirty_rect->left; + dirty_region.top = dirty_rect->top; + dirty_region.right = dirty_rect->right; + dirty_region.bottom = dirty_rect->bottom; + dirty_region.front = 0; + dirty_region.back = 1; + hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, &dirty_region); + } + wined3d_mutex_unlock(); + + return hr; +} + +static const IDirect3DTexture9Vtbl d3d9_texture_2d_vtbl = +{ + /* IUnknown */ + d3d9_texture_2d_QueryInterface, + d3d9_texture_2d_AddRef, + d3d9_texture_2d_Release, + /* IDirect3DResource9 */ + d3d9_texture_2d_GetDevice, + d3d9_texture_2d_SetPrivateData, + d3d9_texture_2d_GetPrivateData, + d3d9_texture_2d_FreePrivateData, + d3d9_texture_2d_SetPriority, + d3d9_texture_2d_GetPriority, + d3d9_texture_2d_PreLoad, + d3d9_texture_2d_GetType, + /* IDirect3dBaseTexture9 */ + d3d9_texture_2d_SetLOD, + d3d9_texture_2d_GetLOD, + d3d9_texture_2d_GetLevelCount, + d3d9_texture_2d_SetAutoGenFilterType, + d3d9_texture_2d_GetAutoGenFilterType, + d3d9_texture_2d_GenerateMipSubLevels, + /* IDirect3DTexture9 */ + d3d9_texture_2d_GetLevelDesc, + d3d9_texture_2d_GetSurfaceLevel, + d3d9_texture_2d_LockRect, + d3d9_texture_2d_UnlockRect, + d3d9_texture_2d_AddDirtyRect, +}; + +static HRESULT WINAPI d3d9_texture_cube_QueryInterface(IDirect3DCubeTexture9 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DCubeTexture9) + || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DCubeTexture9_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d9_texture_cube_AddRef(IDirect3DCubeTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + ULONG ref = InterlockedIncrement(&texture->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, ref); + + if (ref == 1) + { + IDirect3DDevice9Ex_AddRef(texture->parent_device); + wined3d_mutex_lock(); + wined3d_texture_incref(texture->wined3d_texture); + wined3d_mutex_unlock(); + } + + return ref; +} + +static ULONG WINAPI d3d9_texture_cube_Release(IDirect3DCubeTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + ULONG ref = InterlockedDecrement(&texture->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, ref); + + if (!ref) + { + IDirect3DDevice9Ex *parent_device = texture->parent_device; + + TRACE("Releasing child %p.\n", texture->wined3d_texture); + + 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); + } + return ref; +} + +static HRESULT WINAPI d3d9_texture_cube_GetDevice(IDirect3DCubeTexture9 *iface, IDirect3DDevice9 **device) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = (IDirect3DDevice9 *)texture->parent_device; + IDirect3DDevice9_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_texture_cube_SetPrivateData(IDirect3DCubeTexture9 *iface, + REFGUID guid, const void *data, DWORD data_size, DWORD flags) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n", + iface, debugstr_guid(guid), data, data_size, flags); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_texture_cube_GetPrivateData(IDirect3DCubeTexture9 *iface, + REFGUID guid, void *data, DWORD *data_size) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %p.\n", + iface, debugstr_guid(guid), data, data_size); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_get_private_data(resource, guid, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_texture_cube_FreePrivateData(IDirect3DCubeTexture9 *iface, REFGUID guid) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid)); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_free_private_data(resource, guid); + wined3d_mutex_unlock(); + + return hr; +} + +static DWORD WINAPI d3d9_texture_cube_SetPriority(IDirect3DCubeTexture9 *iface, DWORD priority) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + DWORD ret; + + TRACE("iface %p, priority %u.\n", iface, priority); + + wined3d_mutex_lock(); + ret = wined3d_texture_set_priority(texture->wined3d_texture, priority); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d9_texture_cube_GetPriority(IDirect3DCubeTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_priority(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +static void WINAPI d3d9_texture_cube_PreLoad(IDirect3DCubeTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_texture_preload(texture->wined3d_texture); + wined3d_mutex_unlock(); +} + +static D3DRESOURCETYPE WINAPI d3d9_texture_cube_GetType(IDirect3DCubeTexture9 *iface) +{ + TRACE("iface %p.\n", iface); + + return D3DRTYPE_CUBETEXTURE; +} + +static DWORD WINAPI d3d9_texture_cube_SetLOD(IDirect3DCubeTexture9 *iface, DWORD lod) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + DWORD ret; + + TRACE("iface %p, lod %u.\n", iface, lod); + + wined3d_mutex_lock(); + ret = wined3d_texture_set_lod(texture->wined3d_texture, lod); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d9_texture_cube_GetLOD(IDirect3DCubeTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_lod(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d9_texture_cube_GetLevelCount(IDirect3DCubeTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_level_count(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +static HRESULT WINAPI d3d9_texture_cube_SetAutoGenFilterType(IDirect3DCubeTexture9 *iface, + 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(); + + return hr; +} + +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(); + + return ret; +} + +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(); + wined3d_texture_generate_mipmaps(texture->wined3d_texture); + wined3d_mutex_unlock(); +} + +static HRESULT WINAPI d3d9_texture_cube_GetLevelDesc(IDirect3DCubeTexture9 *iface, UINT level, D3DSURFACE_DESC *desc) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + struct wined3d_resource *sub_resource; + HRESULT hr = D3D_OK; + DWORD level_count; + + TRACE("iface %p, level %u, desc %p.\n", iface, level, desc); + + wined3d_mutex_lock(); + level_count = wined3d_texture_get_level_count(texture->wined3d_texture); + if (level >= level_count) + { + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + hr = D3DERR_INVALIDCALL; + else + { + struct wined3d_resource_desc wined3d_desc; + + wined3d_resource_get_desc(sub_resource, &wined3d_desc); + desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); + desc->Type = wined3d_desc.resource_type; + desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; + desc->Pool = wined3d_desc.pool; + desc->MultiSampleType = wined3d_desc.multisample_type; + desc->MultiSampleQuality = wined3d_desc.multisample_quality; + desc->Width = wined3d_desc.width; + desc->Height = wined3d_desc.height; + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_texture_cube_GetCubeMapSurface(IDirect3DCubeTexture9 *iface, + D3DCUBEMAP_FACES face, UINT level, IDirect3DSurface9 **surface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + struct wined3d_resource *sub_resource; + struct d3d9_surface *surface_impl; + UINT sub_resource_idx; + DWORD level_count; + + TRACE("iface %p, face %#x, level %u, surface %p.\n", iface, face, level, surface); + + wined3d_mutex_lock(); + level_count = wined3d_texture_get_level_count(texture->wined3d_texture); + if (level >= level_count) + { + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + + sub_resource_idx = level_count * face + level; + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx))) + { + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + + surface_impl = wined3d_resource_get_parent(sub_resource); + *surface = &surface_impl->IDirect3DSurface9_iface; + IDirect3DSurface9_AddRef(*surface); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_texture_cube_LockRect(IDirect3DCubeTexture9 *iface, + D3DCUBEMAP_FACES face, UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect, + DWORD flags) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + struct wined3d_resource *sub_resource; + struct d3d9_surface *surface_impl; + UINT sub_resource_idx; + HRESULT hr; + + TRACE("iface %p, face %#x, level %u, locked_rect %p, rect %p, flags %#x.\n", + iface, face, level, locked_rect, rect, flags); + + wined3d_mutex_lock(); + sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level; + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx))) + hr = D3DERR_INVALIDCALL; + else + { + surface_impl = wined3d_resource_get_parent(sub_resource); + hr = IDirect3DSurface9_LockRect(&surface_impl->IDirect3DSurface9_iface, locked_rect, rect, flags); + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_texture_cube_UnlockRect(IDirect3DCubeTexture9 *iface, + D3DCUBEMAP_FACES face, UINT level) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + struct wined3d_resource *sub_resource; + struct d3d9_surface *surface_impl; + UINT sub_resource_idx; + HRESULT hr; + + TRACE("iface %p, face %#x, level %u.\n", iface, face, level); + + wined3d_mutex_lock(); + sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level; + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx))) + hr = D3DERR_INVALIDCALL; + else + { + surface_impl = wined3d_resource_get_parent(sub_resource); + hr = IDirect3DSurface9_UnlockRect(&surface_impl->IDirect3DSurface9_iface); + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_texture_cube_AddDirtyRect(IDirect3DCubeTexture9 *iface, + D3DCUBEMAP_FACES face, const RECT *dirty_rect) +{ + struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); + HRESULT hr; + + TRACE("iface %p, face %#x, dirty_rect %s.\n", + iface, face, wine_dbgstr_rect(dirty_rect)); + + wined3d_mutex_lock(); + if (!dirty_rect) + hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, face, NULL); + else + { + struct wined3d_box dirty_region; + + dirty_region.left = dirty_rect->left; + dirty_region.top = dirty_rect->top; + dirty_region.right = dirty_rect->right; + dirty_region.bottom = dirty_rect->bottom; + dirty_region.front = 0; + dirty_region.back = 1; + hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, face, &dirty_region); + } + wined3d_mutex_unlock(); + + return hr; +} + +static const IDirect3DCubeTexture9Vtbl d3d9_texture_cube_vtbl = +{ + /* IUnknown */ + d3d9_texture_cube_QueryInterface, + d3d9_texture_cube_AddRef, + d3d9_texture_cube_Release, + /* IDirect3DResource9 */ + d3d9_texture_cube_GetDevice, + d3d9_texture_cube_SetPrivateData, + d3d9_texture_cube_GetPrivateData, + d3d9_texture_cube_FreePrivateData, + d3d9_texture_cube_SetPriority, + d3d9_texture_cube_GetPriority, + d3d9_texture_cube_PreLoad, + d3d9_texture_cube_GetType, + /* IDirect3DBaseTexture9 */ + d3d9_texture_cube_SetLOD, + d3d9_texture_cube_GetLOD, + d3d9_texture_cube_GetLevelCount, + d3d9_texture_cube_SetAutoGenFilterType, + d3d9_texture_cube_GetAutoGenFilterType, + d3d9_texture_cube_GenerateMipSubLevels, + /* IDirect3DCubeTexture9 */ + d3d9_texture_cube_GetLevelDesc, + d3d9_texture_cube_GetCubeMapSurface, + d3d9_texture_cube_LockRect, + d3d9_texture_cube_UnlockRect, + d3d9_texture_cube_AddDirtyRect, +}; + +static HRESULT WINAPI d3d9_texture_3d_QueryInterface(IDirect3DVolumeTexture9 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DVolumeTexture9) + || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DVolumeTexture9_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d9_texture_3d_AddRef(IDirect3DVolumeTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + ULONG ref = InterlockedIncrement(&texture->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, ref); + + if (ref == 1) + { + IDirect3DDevice9Ex_AddRef(texture->parent_device); + wined3d_mutex_lock(); + wined3d_texture_incref(texture->wined3d_texture); + wined3d_mutex_unlock(); + } + + return ref; +} + +static ULONG WINAPI d3d9_texture_3d_Release(IDirect3DVolumeTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + ULONG ref = InterlockedDecrement(&texture->refcount); + + 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); + } + return ref; +} + +static HRESULT WINAPI d3d9_texture_3d_GetDevice(IDirect3DVolumeTexture9 *iface, IDirect3DDevice9 **device) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = (IDirect3DDevice9 *)texture->parent_device; + IDirect3DDevice9_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_texture_3d_SetPrivateData(IDirect3DVolumeTexture9 *iface, + REFGUID guid, const void *data, DWORD data_size, DWORD flags) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n", + iface, debugstr_guid(guid), data, data_size, flags); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_texture_3d_GetPrivateData(IDirect3DVolumeTexture9 *iface, + REFGUID guid, void *data, DWORD *data_size) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %p.\n", + iface, debugstr_guid(guid), data, data_size); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_get_private_data(resource, guid, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_texture_3d_FreePrivateData(IDirect3DVolumeTexture9 *iface, REFGUID guid) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid)); + + wined3d_mutex_lock(); + resource = wined3d_texture_get_resource(texture->wined3d_texture); + hr = wined3d_resource_free_private_data(resource, guid); + wined3d_mutex_unlock(); + + return hr; +} + +static DWORD WINAPI d3d9_texture_3d_SetPriority(IDirect3DVolumeTexture9 *iface, DWORD priority) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + DWORD ret; + + TRACE("iface %p, priority %u.\n", iface, priority); + + wined3d_mutex_lock(); + ret = wined3d_texture_set_priority(texture->wined3d_texture, priority); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d9_texture_3d_GetPriority(IDirect3DVolumeTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_priority(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +static void WINAPI d3d9_texture_3d_PreLoad(IDirect3DVolumeTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_texture_preload(texture->wined3d_texture); + wined3d_mutex_unlock(); +} + +static D3DRESOURCETYPE WINAPI d3d9_texture_3d_GetType(IDirect3DVolumeTexture9 *iface) +{ + TRACE("iface %p.\n", iface); + + return D3DRTYPE_VOLUMETEXTURE; +} + +static DWORD WINAPI d3d9_texture_3d_SetLOD(IDirect3DVolumeTexture9 *iface, DWORD lod) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + DWORD ret; + + TRACE("iface %p, lod %u.\n", iface, lod); + + wined3d_mutex_lock(); + ret = wined3d_texture_set_lod(texture->wined3d_texture, lod); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d9_texture_3d_GetLOD(IDirect3DVolumeTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_lod(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +static DWORD WINAPI d3d9_texture_3d_GetLevelCount(IDirect3DVolumeTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + DWORD ret; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + ret = wined3d_texture_get_level_count(texture->wined3d_texture); + wined3d_mutex_unlock(); + + return ret; +} + +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; +} + +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; +} + +static void WINAPI d3d9_texture_3d_GenerateMipSubLevels(IDirect3DVolumeTexture9 *iface) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + wined3d_texture_generate_mipmaps(texture->wined3d_texture); + wined3d_mutex_unlock(); +} + +static HRESULT WINAPI d3d9_texture_3d_GetLevelDesc(IDirect3DVolumeTexture9 *iface, UINT level, D3DVOLUME_DESC *desc) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + struct wined3d_resource *sub_resource; + HRESULT hr = D3D_OK; + + TRACE("iface %p, level %u, desc %p.\n", iface, level, desc); + + wined3d_mutex_lock(); + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + hr = D3DERR_INVALIDCALL; + else + { + struct wined3d_resource_desc wined3d_desc; + + wined3d_resource_get_desc(sub_resource, &wined3d_desc); + desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); + desc->Type = wined3d_desc.resource_type; + desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; + desc->Pool = wined3d_desc.pool; + desc->Width = wined3d_desc.width; + desc->Height = wined3d_desc.height; + desc->Depth = wined3d_desc.depth; + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_texture_3d_GetVolumeLevel(IDirect3DVolumeTexture9 *iface, + UINT level, IDirect3DVolume9 **volume) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + struct wined3d_resource *sub_resource; + struct d3d9_volume *volume_impl; + + TRACE("iface %p, level %u, volume %p.\n", iface, level, volume); + + wined3d_mutex_lock(); + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + { + wined3d_mutex_unlock(); + return D3DERR_INVALIDCALL; + } + + volume_impl = wined3d_resource_get_parent(sub_resource); + *volume = &volume_impl->IDirect3DVolume9_iface; + IDirect3DVolume9_AddRef(*volume); + wined3d_mutex_unlock(); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_texture_3d_LockBox(IDirect3DVolumeTexture9 *iface, + UINT level, D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + struct wined3d_resource *sub_resource; + struct d3d9_volume *volume_impl; + HRESULT hr; + + TRACE("iface %p, level %u, locked_box %p, box %p, flags %#x.\n", + iface, level, locked_box, box, flags); + + wined3d_mutex_lock(); + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + hr = D3DERR_INVALIDCALL; + else + { + volume_impl = wined3d_resource_get_parent(sub_resource); + hr = IDirect3DVolume9_LockBox(&volume_impl->IDirect3DVolume9_iface, locked_box, box, flags); + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_texture_3d_UnlockBox(IDirect3DVolumeTexture9 *iface, UINT level) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + struct wined3d_resource *sub_resource; + struct d3d9_volume *volume_impl; + HRESULT hr; + + TRACE("iface %p, level %u.\n", iface, level); + + wined3d_mutex_lock(); + if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) + hr = D3DERR_INVALIDCALL; + else + { + volume_impl = wined3d_resource_get_parent(sub_resource); + hr = IDirect3DVolume9_UnlockBox(&volume_impl->IDirect3DVolume9_iface); + } + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_texture_3d_AddDirtyBox(IDirect3DVolumeTexture9 *iface, const D3DBOX *dirty_box) +{ + struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); + HRESULT hr; + + TRACE("iface %p, dirty_box %p.\n", iface, dirty_box); + + wined3d_mutex_lock(); + hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, (const struct wined3d_box *)dirty_box); + wined3d_mutex_unlock(); + + return hr; +} + + +static const IDirect3DVolumeTexture9Vtbl d3d9_texture_3d_vtbl = +{ + /* IUnknown */ + d3d9_texture_3d_QueryInterface, + d3d9_texture_3d_AddRef, + d3d9_texture_3d_Release, + /* IDirect3DResource9 */ + d3d9_texture_3d_GetDevice, + d3d9_texture_3d_SetPrivateData, + d3d9_texture_3d_GetPrivateData, + d3d9_texture_3d_FreePrivateData, + d3d9_texture_3d_SetPriority, + d3d9_texture_3d_GetPriority, + d3d9_texture_3d_PreLoad, + d3d9_texture_3d_GetType, + /* IDirect3DBaseTexture9 */ + d3d9_texture_3d_SetLOD, + d3d9_texture_3d_GetLOD, + d3d9_texture_3d_GetLevelCount, + d3d9_texture_3d_SetAutoGenFilterType, + d3d9_texture_3d_GetAutoGenFilterType, + d3d9_texture_3d_GenerateMipSubLevels, + /* IDirect3DVolumeTexture9 */ + d3d9_texture_3d_GetLevelDesc, + d3d9_texture_3d_GetVolumeLevel, + d3d9_texture_3d_LockBox, + d3d9_texture_3d_UnlockBox, + d3d9_texture_3d_AddDirtyBox, +}; + +struct d3d9_texture *unsafe_impl_from_IDirect3DBaseTexture9(IDirect3DBaseTexture9 *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_2d_vtbl + || iface->lpVtbl == (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_cube_vtbl + || iface->lpVtbl == (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_3d_vtbl); + return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface); +} + +static void STDMETHODCALLTYPE d3d9_texture_wined3d_object_destroyed(void *parent) +{ + HeapFree(GetProcessHeap(), 0, parent); +} + +static const struct wined3d_parent_ops d3d9_texture_wined3d_parent_ops = +{ + d3d9_texture_wined3d_object_destroyed, +}; + +HRESULT texture_init(struct d3d9_texture *texture, struct d3d9_device *device, + UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool +#ifdef VBOX_WITH_WDDM + , HANDLE *shared_handle + , void **pavClientMem +#endif + ) +{ + struct wined3d_resource_desc desc; + DWORD surface_flags = 0; + HRESULT hr; + + texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_2d_vtbl; + texture->refcount = 1; + + desc.resource_type = WINED3D_RTYPE_TEXTURE; + desc.format = wined3dformat_from_d3dformat(format); + desc.multisample_type = WINED3D_MULTISAMPLE_NONE; + desc.multisample_quality = 0; + desc.usage = usage & WINED3DUSAGE_MASK; + desc.pool = pool; + desc.width = width; + desc.height = height; + desc.depth = 1; + desc.size = 0; + + if (pool != D3DPOOL_DEFAULT || (usage & D3DUSAGE_DYNAMIC)) + surface_flags |= WINED3D_SURFACE_MAPPABLE; + + wined3d_mutex_lock(); + hr = wined3d_texture_create_2d(device->wined3d_device, &desc, levels, surface_flags, + texture, &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture +#ifdef VBOX_WITH_WDDM + , shared_handle + , pavClientMem +#endif + ); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d texture, hr %#x.\n", hr); + return hr; + } + + texture->parent_device = &device->IDirect3DDevice9Ex_iface; + IDirect3DDevice9Ex_AddRef(texture->parent_device); + + return D3D_OK; +} + +HRESULT cubetexture_init(struct d3d9_texture *texture, struct d3d9_device *device, + UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool +#ifdef VBOX_WITH_WDDM + , HANDLE *shared_handle + , void **pavClientMem +#endif + ) +{ + struct wined3d_resource_desc desc; + DWORD surface_flags = 0; + HRESULT hr; + + texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_cube_vtbl; + texture->refcount = 1; + + desc.resource_type = WINED3D_RTYPE_CUBE_TEXTURE; + desc.format = wined3dformat_from_d3dformat(format); + desc.multisample_type = WINED3D_MULTISAMPLE_NONE; + desc.multisample_quality = 0; + desc.usage = usage & WINED3DUSAGE_MASK; + desc.pool = pool; + desc.width = edge_length; + desc.height = edge_length; + desc.depth = 1; + desc.size = 0; + + if (pool != D3DPOOL_DEFAULT || (usage & D3DUSAGE_DYNAMIC)) + surface_flags |= WINED3D_SURFACE_MAPPABLE; + + wined3d_mutex_lock(); + hr = wined3d_texture_create_cube(device->wined3d_device, &desc, levels, surface_flags, + texture, &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture +#ifdef VBOX_WITH_WDDM + , shared_handle + , pavClientMem +#endif + ); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d cube texture, hr %#x.\n", hr); + return hr; + } + + texture->parent_device = &device->IDirect3DDevice9Ex_iface; + IDirect3DDevice9Ex_AddRef(texture->parent_device); + + return D3D_OK; +} + +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 +#ifdef VBOX_WITH_WDDM + , HANDLE *shared_handle + , void **pavClientMem +#endif + ) +{ + struct wined3d_resource_desc desc; + HRESULT hr; + + texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_3d_vtbl; + texture->refcount = 1; + + desc.resource_type = WINED3D_RTYPE_VOLUME_TEXTURE; + desc.format = wined3dformat_from_d3dformat(format); + desc.multisample_type = WINED3D_MULTISAMPLE_NONE; + desc.multisample_quality = 0; + desc.usage = usage & WINED3DUSAGE_MASK; + desc.pool = pool; + desc.width = width; + desc.height = height; + desc.depth = depth; + desc.size = 0; + + wined3d_mutex_lock(); + hr = wined3d_texture_create_3d(device->wined3d_device, &desc, levels, + texture, &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture +#ifdef VBOX_WITH_WDDM + , shared_handle + , pavClientMem +#endif + ); + wined3d_mutex_unlock(); + if (FAILED(hr)) + { + WARN("Failed to create wined3d volume texture, hr %#x.\n", hr); + return hr; + } + + texture->parent_device = &device->IDirect3DDevice9Ex_iface; + IDirect3DDevice9Ex_AddRef(texture->parent_device); + + return D3D_OK; +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/version.rc =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/version.rc (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/version.rc (revision 46521) @@ -0,0 +1,26 @@ +/* + * Copyright 2001 Ove Kaaven + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#define WINE_FILEDESCRIPTION_STR "Wine Direct3D" +#define WINE_FILENAME_STR "d3d9.dll" +#define WINE_FILEVERSION 5,3,1,904 +#define WINE_FILEVERSION_STR "5.3.1.904" +#define WINE_PRODUCTVERSION 5,3,1,904 +#define WINE_PRODUCTVERSION_STR "5.3.1.904" + +#include "wine/wine_common_ver.rc" Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/vertexdeclaration.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/vertexdeclaration.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/vertexdeclaration.c (revision 46521) @@ -0,0 +1,436 @@ +/* + * IDirect3DVertexDeclaration9 implementation + * + * Copyright 2002-2003 Raphael Junqueira + * Jason Edmeades + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * 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; + unsigned int component_count; + unsigned int component_size; +} +d3d_dtype_lookup[] = +{ + /* D3DDECLTYPE_FLOAT1 */ {WINED3DFMT_R32_FLOAT, 1, sizeof(float)}, + /* D3DDECLTYPE_FLOAT2 */ {WINED3DFMT_R32G32_FLOAT, 2, sizeof(float)}, + /* D3DDECLTYPE_FLOAT3 */ {WINED3DFMT_R32G32B32_FLOAT, 3, sizeof(float)}, + /* D3DDECLTYPE_FLOAT4 */ {WINED3DFMT_R32G32B32A32_FLOAT, 4, sizeof(float)}, + /* D3DDECLTYPE_D3DCOLOR */ {WINED3DFMT_B8G8R8A8_UNORM, 4, sizeof(BYTE)}, + /* D3DDECLTYPE_UBYTE4 */ {WINED3DFMT_R8G8B8A8_UINT, 4, sizeof(BYTE)}, + /* D3DDECLTYPE_SHORT2 */ {WINED3DFMT_R16G16_SINT, 2, sizeof(short int)}, + /* D3DDECLTYPE_SHORT4 */ {WINED3DFMT_R16G16B16A16_SINT, 4, sizeof(short int)}, + /* D3DDECLTYPE_UBYTE4N */ {WINED3DFMT_R8G8B8A8_UNORM, 4, sizeof(BYTE)}, + /* D3DDECLTYPE_SHORT2N */ {WINED3DFMT_R16G16_SNORM, 2, sizeof(short int)}, + /* D3DDECLTYPE_SHORT4N */ {WINED3DFMT_R16G16B16A16_SNORM, 4, sizeof(short int)}, + /* D3DDECLTYPE_USHORT2N */ {WINED3DFMT_R16G16_UNORM, 2, sizeof(short int)}, + /* D3DDECLTYPE_USHORT4N */ {WINED3DFMT_R16G16B16A16_UNORM, 4, sizeof(short int)}, + /* D3DDECLTYPE_UDEC3 */ {WINED3DFMT_R10G10B10A2_UINT, 3, sizeof(short int)}, + /* D3DDECLTYPE_DEC3N */ {WINED3DFMT_R10G10B10A2_SNORM, 3, sizeof(short int)}, + /* D3DDECLTYPE_FLOAT16_2 */ {WINED3DFMT_R16G16_FLOAT, 2, sizeof(short int)}, + /* D3DDECLTYPE_FLOAT16_4 */ {WINED3DFMT_R16G16B16A16_FLOAT, 4, sizeof(short int)} +}; + +static inline struct d3d9_vertex_declaration *impl_from_IDirect3DVertexDeclaration9(IDirect3DVertexDeclaration9 *iface) +{ + return CONTAINING_RECORD(iface, struct d3d9_vertex_declaration, IDirect3DVertexDeclaration9_iface); +} + +HRESULT vdecl_convert_fvf( + DWORD fvf, + D3DVERTEXELEMENT9** ppVertexElements) { + + unsigned int idx, idx2; + unsigned int offset; + BOOL has_pos = (fvf & D3DFVF_POSITION_MASK) != 0; + BOOL has_blend = (fvf & D3DFVF_XYZB5) > D3DFVF_XYZRHW; + BOOL has_blend_idx = has_blend && + (((fvf & D3DFVF_XYZB5) == D3DFVF_XYZB5) || + (fvf & D3DFVF_LASTBETA_D3DCOLOR) || + (fvf & D3DFVF_LASTBETA_UBYTE4)); + BOOL has_normal = (fvf & D3DFVF_NORMAL) != 0; + BOOL has_psize = (fvf & D3DFVF_PSIZE) != 0; + + BOOL has_diffuse = (fvf & D3DFVF_DIFFUSE) != 0; + BOOL has_specular = (fvf & D3DFVF_SPECULAR) !=0; + + DWORD num_textures = (fvf & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT; + DWORD texcoords = (fvf & 0xFFFF0000) >> 16; + + D3DVERTEXELEMENT9 end_element = D3DDECL_END(); + D3DVERTEXELEMENT9 *elements = NULL; + + unsigned int size; + DWORD num_blends = 1 + (((fvf & D3DFVF_XYZB5) - D3DFVF_XYZB1) >> 1); + if (has_blend_idx) num_blends--; + + /* Compute declaration size */ + size = has_pos + (has_blend && num_blends > 0) + has_blend_idx + has_normal + + has_psize + has_diffuse + has_specular + num_textures + 1; + + /* convert the declaration */ + elements = HeapAlloc(GetProcessHeap(), 0, size * sizeof(D3DVERTEXELEMENT9)); + if (!elements) return D3DERR_OUTOFVIDEOMEMORY; + + elements[size-1] = end_element; + idx = 0; + if (has_pos) { + if (!has_blend && (fvf & D3DFVF_XYZRHW)) { + elements[idx].Type = D3DDECLTYPE_FLOAT4; + elements[idx].Usage = D3DDECLUSAGE_POSITIONT; + } + else if (!has_blend && (fvf & D3DFVF_XYZW) == D3DFVF_XYZW) { + elements[idx].Type = D3DDECLTYPE_FLOAT4; + elements[idx].Usage = D3DDECLUSAGE_POSITION; + } + else { + elements[idx].Type = D3DDECLTYPE_FLOAT3; + elements[idx].Usage = D3DDECLUSAGE_POSITION; + } + elements[idx].UsageIndex = 0; + idx++; + } + if (has_blend && (num_blends > 0)) { + if (((fvf & D3DFVF_XYZB5) == D3DFVF_XYZB2) && (fvf & D3DFVF_LASTBETA_D3DCOLOR)) + elements[idx].Type = D3DDECLTYPE_D3DCOLOR; + else { + switch(num_blends) { + case 1: elements[idx].Type = D3DDECLTYPE_FLOAT1; break; + case 2: elements[idx].Type = D3DDECLTYPE_FLOAT2; break; + case 3: elements[idx].Type = D3DDECLTYPE_FLOAT3; break; + case 4: elements[idx].Type = D3DDECLTYPE_FLOAT4; break; + default: + ERR("Unexpected amount of blend values: %u\n", num_blends); + } + } + elements[idx].Usage = D3DDECLUSAGE_BLENDWEIGHT; + elements[idx].UsageIndex = 0; + idx++; + } + if (has_blend_idx) { + if (fvf & D3DFVF_LASTBETA_UBYTE4 || + (((fvf & D3DFVF_XYZB5) == D3DFVF_XYZB2) && (fvf & D3DFVF_LASTBETA_D3DCOLOR))) + elements[idx].Type = D3DDECLTYPE_UBYTE4; + else if (fvf & D3DFVF_LASTBETA_D3DCOLOR) + elements[idx].Type = D3DDECLTYPE_D3DCOLOR; + else + elements[idx].Type = D3DDECLTYPE_FLOAT1; + elements[idx].Usage = D3DDECLUSAGE_BLENDINDICES; + elements[idx].UsageIndex = 0; + idx++; + } + if (has_normal) { + elements[idx].Type = D3DDECLTYPE_FLOAT3; + elements[idx].Usage = D3DDECLUSAGE_NORMAL; + elements[idx].UsageIndex = 0; + idx++; + } + if (has_psize) { + elements[idx].Type = D3DDECLTYPE_FLOAT1; + elements[idx].Usage = D3DDECLUSAGE_PSIZE; + elements[idx].UsageIndex = 0; + idx++; + } + if (has_diffuse) { + elements[idx].Type = D3DDECLTYPE_D3DCOLOR; + elements[idx].Usage = D3DDECLUSAGE_COLOR; + elements[idx].UsageIndex = 0; + idx++; + } + if (has_specular) { + elements[idx].Type = D3DDECLTYPE_D3DCOLOR; + elements[idx].Usage = D3DDECLUSAGE_COLOR; + elements[idx].UsageIndex = 1; + idx++; + } + for (idx2 = 0; idx2 < num_textures; idx2++) { + unsigned int numcoords = (texcoords >> (idx2*2)) & 0x03; + switch (numcoords) { + case D3DFVF_TEXTUREFORMAT1: + elements[idx].Type = D3DDECLTYPE_FLOAT1; + break; + case D3DFVF_TEXTUREFORMAT2: + elements[idx].Type = D3DDECLTYPE_FLOAT2; + break; + case D3DFVF_TEXTUREFORMAT3: + elements[idx].Type = D3DDECLTYPE_FLOAT3; + break; + case D3DFVF_TEXTUREFORMAT4: + elements[idx].Type = D3DDECLTYPE_FLOAT4; + break; + } + elements[idx].Usage = D3DDECLUSAGE_TEXCOORD; + elements[idx].UsageIndex = idx2; + idx++; + } + + /* Now compute offsets, and initialize the rest of the fields */ + for (idx = 0, offset = 0; idx < size-1; idx++) { + elements[idx].Stream = 0; + elements[idx].Method = D3DDECLMETHOD_DEFAULT; + elements[idx].Offset = offset; + offset += d3d_dtype_lookup[elements[idx].Type].component_count + * d3d_dtype_lookup[elements[idx].Type].component_size; + } + + *ppVertexElements = elements; + return D3D_OK; +} + +static HRESULT WINAPI d3d9_vertex_declaration_QueryInterface(IDirect3DVertexDeclaration9 *iface, + REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DVertexDeclaration9) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DVertexDeclaration9_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d9_vertex_declaration_AddRef(IDirect3DVertexDeclaration9 *iface) +{ + struct d3d9_vertex_declaration *declaration = impl_from_IDirect3DVertexDeclaration9(iface); + ULONG refcount = InterlockedIncrement(&declaration->refcount); + + TRACE("%p increasing refcount to %u.\n", iface, refcount); + + if (refcount == 1) + { + IDirect3DDevice9Ex_AddRef(declaration->parent_device); + wined3d_mutex_lock(); + wined3d_vertex_declaration_incref(declaration->wined3d_declaration); + wined3d_mutex_unlock(); + } + + return refcount; +} + +static ULONG WINAPI d3d9_vertex_declaration_Release(IDirect3DVertexDeclaration9 *iface) +{ + struct d3d9_vertex_declaration *declaration = impl_from_IDirect3DVertexDeclaration9(iface); + ULONG refcount = InterlockedDecrement(&declaration->refcount); + + TRACE("%p decreasing refcount to %u.\n", iface, refcount); + + if (!refcount) + { + IDirect3DDevice9Ex *parent_device = declaration->parent_device; + wined3d_mutex_lock(); + wined3d_vertex_declaration_decref(declaration->wined3d_declaration); + wined3d_mutex_unlock(); + + /* Release the device last, as it may cause the device to be destroyed. */ + IDirect3DDevice9Ex_Release(parent_device); + } + + return refcount; +} + +static HRESULT WINAPI d3d9_vertex_declaration_GetDevice(IDirect3DVertexDeclaration9 *iface, IDirect3DDevice9 **device) +{ + struct d3d9_vertex_declaration *declaration = impl_from_IDirect3DVertexDeclaration9(iface); + + TRACE("iface %p, device %p.\n", iface, device); + + *device = (IDirect3DDevice9 *)declaration->parent_device; + IDirect3DDevice9_AddRef(*device); + + TRACE("Returning device %p.\n", *device); + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_vertex_declaration_GetDeclaration(IDirect3DVertexDeclaration9 *iface, + D3DVERTEXELEMENT9 *elements, UINT *element_count) +{ + struct d3d9_vertex_declaration *declaration = impl_from_IDirect3DVertexDeclaration9(iface); + + TRACE("iface %p, elements %p, element_count %p.\n", iface, elements, element_count); + + *element_count = declaration->element_count; + + /* Passing a NULL elements is used to just retrieve the number of elements */ + if (!elements) + return D3D_OK; + + TRACE("Copying %p to %p.\n", declaration->elements, elements); + memcpy(elements, declaration->elements, sizeof(*declaration->elements) * declaration->element_count); + + return D3D_OK; +} + +static const struct IDirect3DVertexDeclaration9Vtbl d3d9_vertex_declaration_vtbl = +{ + /* IUnknown */ + d3d9_vertex_declaration_QueryInterface, + d3d9_vertex_declaration_AddRef, + d3d9_vertex_declaration_Release, + /* IDirect3DVertexDeclaration9 */ + d3d9_vertex_declaration_GetDevice, + d3d9_vertex_declaration_GetDeclaration, +}; + +struct d3d9_vertex_declaration *unsafe_impl_from_IDirect3DVertexDeclaration9(IDirect3DVertexDeclaration9 *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == &d3d9_vertex_declaration_vtbl); + return CONTAINING_RECORD(iface, struct d3d9_vertex_declaration, IDirect3DVertexDeclaration9_iface); +} + +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); +} + +static const struct wined3d_parent_ops d3d9_vertexdeclaration_wined3d_parent_ops = +{ + d3d9_vertexdeclaration_wined3d_object_destroyed, +}; + +static HRESULT convert_to_wined3d_declaration(const D3DVERTEXELEMENT9 *d3d9_elements, + struct wined3d_vertex_element **wined3d_elements, UINT *element_count) +{ + const D3DVERTEXELEMENT9* element; + UINT count = 1; + UINT i; + + TRACE("d3d9_elements %p, wined3d_elements %p\n", d3d9_elements, wined3d_elements); + + element = d3d9_elements; + while (element++->Stream != 0xff && count++ < 128); + + if (count == 128) return E_FAIL; + + /* Skip the END element */ + --count; + + *wined3d_elements = HeapAlloc(GetProcessHeap(), 0, count * sizeof(**wined3d_elements)); + if (!*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))) + { + WARN("Invalid element type %#x.\n", d3d9_elements[i].Type); + HeapFree(GetProcessHeap(), 0, *wined3d_elements); + return E_FAIL; + } + (*wined3d_elements)[i].format = d3d_dtype_lookup[d3d9_elements[i].Type].format; + (*wined3d_elements)[i].input_slot = d3d9_elements[i].Stream; + (*wined3d_elements)[i].offset = d3d9_elements[i].Offset; + (*wined3d_elements)[i].output_slot = ~0U; + (*wined3d_elements)[i].method = d3d9_elements[i].Method; + (*wined3d_elements)[i].usage = d3d9_elements[i].Usage; + (*wined3d_elements)[i].usage_idx = d3d9_elements[i].UsageIndex; + } + + *element_count = count; + + return D3D_OK; +} + +static HRESULT vertexdeclaration_init(struct d3d9_vertex_declaration *declaration, + struct d3d9_device *device, const D3DVERTEXELEMENT9 *elements) +{ + struct wined3d_vertex_element *wined3d_elements; + UINT wined3d_element_count; + UINT element_count; + HRESULT hr; + + hr = convert_to_wined3d_declaration(elements, &wined3d_elements, &wined3d_element_count); + if (FAILED(hr)) + { + WARN("Failed to create wined3d vertex declaration elements, hr %#x.\n", hr); + return hr; + } + + declaration->IDirect3DVertexDeclaration9_iface.lpVtbl = &d3d9_vertex_declaration_vtbl; + declaration->refcount = 1; + + element_count = wined3d_element_count + 1; + declaration->elements = HeapAlloc(GetProcessHeap(), 0, element_count * sizeof(*declaration->elements)); + if (!declaration->elements) + { + HeapFree(GetProcessHeap(), 0, wined3d_elements); + ERR("Failed to allocate vertex declaration elements memory.\n"); + return D3DERR_OUTOFVIDEOMEMORY; + } + memcpy(declaration->elements, elements, element_count * sizeof(*elements)); + declaration->element_count = element_count; + + wined3d_mutex_lock(); + 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); + if (FAILED(hr)) + { + HeapFree(GetProcessHeap(), 0, declaration->elements); + WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr); + return hr; + } + + declaration->parent_device = &device->IDirect3DDevice9Ex_iface; + IDirect3DDevice9Ex_AddRef(declaration->parent_device); + + return D3D_OK; +} + +HRESULT d3d9_vertex_declaration_create(struct d3d9_device *device, + const D3DVERTEXELEMENT9 *elements, struct d3d9_vertex_declaration **declaration) +{ + struct d3d9_vertex_declaration *object; + HRESULT hr; + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (!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); + return hr; + } + + TRACE("Created vertex declaration %p.\n", object); + *declaration = object; + + return D3D_OK; +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/volume.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/volume.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/volume.c (revision 46521) @@ -0,0 +1,314 @@ +/* + * IDirect3DVolume9 implementation + * + * Copyright 2002-2005 Jason Edmeades + * Raphael Junqueira + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * 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); +} + +static HRESULT WINAPI d3d9_volume_QueryInterface(IDirect3DVolume9 *iface, REFIID riid, void **out) +{ + TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualGUID(riid, &IID_IDirect3DVolume9) + || IsEqualGUID(riid, &IID_IUnknown)) + { + IDirect3DVolume9_AddRef(iface); + *out = iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid)); + + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI d3d9_volume_AddRef(IDirect3DVolume9 *iface) +{ + struct d3d9_volume *volume = impl_from_IDirect3DVolume9(iface); + ULONG refcount; + + TRACE("iface %p.\n", iface); + + if (volume->forwardReference) + { + TRACE("Forwarding to %p.\n", volume->forwardReference); + return IUnknown_AddRef(volume->forwardReference); + } + + refcount = InterlockedIncrement(&volume->refcount); + TRACE("%p increasing refcount to %u.\n", iface, refcount); + + if (refcount == 1) + { + wined3d_mutex_lock(); + wined3d_volume_incref(volume->wined3d_volume); + wined3d_mutex_unlock(); + } + + return refcount; +} + +static ULONG WINAPI d3d9_volume_Release(IDirect3DVolume9 *iface) +{ + struct d3d9_volume *volume = impl_from_IDirect3DVolume9(iface); + ULONG refcount; + + TRACE("iface %p.\n", iface); + + if (volume->forwardReference) + { + TRACE("Forwarding to %p.\n", volume->forwardReference); + return IUnknown_Release(volume->forwardReference); + } + + refcount = InterlockedDecrement(&volume->refcount); + TRACE("%p decreasing refcount to %u.\n", iface, refcount); + + if (!refcount) + { + wined3d_mutex_lock(); + wined3d_volume_decref(volume->wined3d_volume); + wined3d_mutex_unlock(); + } + + return refcount; +} + +static HRESULT WINAPI d3d9_volume_GetDevice(IDirect3DVolume9 *iface, IDirect3DDevice9 **device) +{ + struct d3d9_volume *volume = impl_from_IDirect3DVolume9(iface); + IDirect3DResource9 *resource; + HRESULT hr; + + TRACE("iface %p, device %p.\n", iface, device); + + hr = IUnknown_QueryInterface(volume->forwardReference, &IID_IDirect3DResource9, (void **)&resource); + if (SUCCEEDED(hr)) + { + hr = IDirect3DResource9_GetDevice(resource, device); + IDirect3DResource9_Release(resource); + + TRACE("Returning device %p.\n", *device); + } + + return hr; +} + +static HRESULT WINAPI d3d9_volume_SetPrivateData(IDirect3DVolume9 *iface, REFGUID guid, + const void *data, DWORD data_size, DWORD flags) +{ + struct d3d9_volume *volume = impl_from_IDirect3DVolume9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n", + iface, debugstr_guid(guid), data, data_size, flags); + + wined3d_mutex_lock(); + resource = wined3d_volume_get_resource(volume->wined3d_volume); + hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_volume_GetPrivateData(IDirect3DVolume9 *iface, REFGUID guid, + void *data, DWORD *data_size) +{ + struct d3d9_volume *volume = impl_from_IDirect3DVolume9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s, data %p, data_size %p.\n", + iface, debugstr_guid(guid), data, data_size); + + wined3d_mutex_lock(); + resource = wined3d_volume_get_resource(volume->wined3d_volume); + hr = wined3d_resource_get_private_data(resource, guid, data, data_size); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_volume_FreePrivateData(IDirect3DVolume9 *iface, REFGUID guid) +{ + struct d3d9_volume *volume = impl_from_IDirect3DVolume9(iface); + struct wined3d_resource *resource; + HRESULT hr; + + TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid)); + + wined3d_mutex_lock(); + resource = wined3d_volume_get_resource(volume->wined3d_volume); + hr = wined3d_resource_free_private_data(resource, guid); + wined3d_mutex_unlock(); + + return hr; +} + +static HRESULT WINAPI d3d9_volume_GetContainer(IDirect3DVolume9 *iface, REFIID riid, void **container) +{ + struct d3d9_volume *volume = impl_from_IDirect3DVolume9(iface); + HRESULT hr; + + TRACE("iface %p, riid %s, container %p.\n", iface, debugstr_guid(riid), container); + + if (!volume->container) + return E_NOINTERFACE; + + hr = IUnknown_QueryInterface(volume->container, riid, container); + + TRACE("Returning %p,\n", *container); + + return hr; +} + +static HRESULT WINAPI d3d9_volume_GetDesc(IDirect3DVolume9 *iface, D3DVOLUME_DESC *desc) +{ + struct d3d9_volume *volume = impl_from_IDirect3DVolume9(iface); + struct wined3d_resource_desc wined3d_desc; + struct wined3d_resource *wined3d_resource; + + TRACE("iface %p, desc %p.\n", iface, desc); + + wined3d_mutex_lock(); + wined3d_resource = wined3d_volume_get_resource(volume->wined3d_volume); + wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); + wined3d_mutex_unlock(); + + desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); + desc->Type = wined3d_desc.resource_type; + desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; + desc->Pool = wined3d_desc.pool; + desc->Width = wined3d_desc.width; + desc->Height = wined3d_desc.height; + desc->Depth = wined3d_desc.depth; + + return D3D_OK; +} + +static HRESULT WINAPI d3d9_volume_LockBox(IDirect3DVolume9 *iface, + D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags) +{ + struct d3d9_volume *volume = impl_from_IDirect3DVolume9(iface); + struct wined3d_map_desc map_desc; + HRESULT hr; + + TRACE("iface %p, locked_box %p, box %p, flags %#x.\n", + iface, locked_box, box, flags); + + wined3d_mutex_lock(); + hr = wined3d_volume_map(volume->wined3d_volume, &map_desc, (const struct wined3d_box *)box, flags); + wined3d_mutex_unlock(); + + locked_box->RowPitch = map_desc.row_pitch; + locked_box->SlicePitch = map_desc.slice_pitch; + locked_box->pBits = map_desc.data; + + return hr; +} + +static HRESULT WINAPI d3d9_volume_UnlockBox(IDirect3DVolume9 *iface) +{ + struct d3d9_volume *volume = impl_from_IDirect3DVolume9(iface); + HRESULT hr; + + TRACE("iface %p.\n", iface); + + wined3d_mutex_lock(); + hr = wined3d_volume_unmap(volume->wined3d_volume); + wined3d_mutex_unlock(); + + return hr; +} + +static const struct IDirect3DVolume9Vtbl d3d9_volume_vtbl = +{ + /* IUnknown */ + d3d9_volume_QueryInterface, + d3d9_volume_AddRef, + d3d9_volume_Release, + /* IDirect3DVolume9 */ + d3d9_volume_GetDevice, + d3d9_volume_SetPrivateData, + d3d9_volume_GetPrivateData, + d3d9_volume_FreePrivateData, + d3d9_volume_GetContainer, + d3d9_volume_GetDesc, + d3d9_volume_LockBox, + d3d9_volume_UnlockBox, +}; + +static void STDMETHODCALLTYPE volume_wined3d_object_destroyed(void *parent) +{ + HeapFree(GetProcessHeap(), 0, parent); +} + +static const struct wined3d_parent_ops d3d9_volume_wined3d_parent_ops = +{ + volume_wined3d_object_destroyed, +}; + +HRESULT volume_init(struct d3d9_volume *volume, struct d3d9_device *device, UINT width, UINT height, + UINT depth, DWORD usage, enum wined3d_format_id format, enum wined3d_pool pool +#ifdef VBOX_WITH_WDDM + , HANDLE *shared_handle + , void *pvClientMem +#endif +) +{ + HRESULT hr; + + volume->IDirect3DVolume9_iface.lpVtbl = &d3d9_volume_vtbl; + volume->refcount = 1; + + hr = wined3d_volume_create(device->wined3d_device, width, height, depth, usage & WINED3DUSAGE_MASK, + format, pool, volume, &d3d9_volume_wined3d_parent_ops, &volume->wined3d_volume +#ifdef VBOX_WITH_WDDM + , shared_handle + , pvClientMem +#endif + ); + if (FAILED(hr)) + { + WARN("Failed to create wined3d volume, hr %#x.\n", hr); + return hr; + } + + return D3D_OK; +} + +#ifdef VBOX_WITH_WDDM +struct d3d9_volume *unsafe_impl_from_IDirect3DVolume9(IDirect3DVolume9 *iface) +{ + if (!iface) + return NULL; + assert(iface->lpVtbl == (const IDirect3DVolume9Vtbl *)&d3d9_volume_vtbl); + return CONTAINING_RECORD(iface, struct d3d9_volume, IDirect3DVolume9_iface); +} +#endif Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/d3d8.rc =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/d3d8.rc (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/d3d8.rc (revision 46521) @@ -0,0 +1,64 @@ +/* $Id$ */ +/** @file + * VBoxD3D8 - Resource file containing version info and icon. + */ + +/* + * Copyright (C) 2009-2010 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#include +#include + +LANGUAGE 0x09, 0x01 + +VS_VERSION_INFO VERSIONINFO + FILEVERSION VBOX_VERSION_MAJOR_NR,VBOX_VERSION_MINOR_NR,VBOX_VERSION_BUILD_NR,0 + PRODUCTVERSION VBOX_VERSION_MAJOR_NR,VBOX_VERSION_MINOR_NR,VBOX_VERSION_BUILD_NR,0 + FILEFLAGSMASK 0x3fL + FILEFLAGS 0x0L + FILEOS 0x40004L + FILETYPE 0x3L + FILESUBTYPE 0x4L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" + BEGIN + VALUE "CompanyName", VBOX_RC_COMPANY_NAME + VALUE "FileDescription", "VirtualBox D3D8 switcher\0" + VALUE "FileVersion", VBOX_VERSION_MAJOR "." VBOX_VERSION_MINOR "." VBOX_VERSION_BUILD "." VBOX_SVN_REV "\0" + VALUE "InternalName", "D3D8\0" + VALUE "LegalCopyright", VBOX_RC_LEGAL_COPYRIGHT + VALUE "OriginalFilename", "D3D8.dll\0" + VALUE "ProductName", VBOX_PRODUCT " Guest Additions\0" + VALUE "ProductVersion", VBOX_VERSION_MAJOR "." VBOX_VERSION_MINOR "." VBOX_VERSION_BUILD ".r" VBOX_SVN_REV "\0" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END + +1 RCDATA +BEGIN +// Machine dependent parameters + 17, // Height of vertical thumb + 17, // Width of horizontal thumb + 2, // Icon horiz compression factor + 2, // Icon vert compression factor + 1, // Cursor horz compression factor + 1, // Cursor vert compression factor + 0, // Kanji window height + 1, // cxBorder (thickness of vertical lines) + 1 // cyBorder (thickness of horizontal lines) +END Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/d3d8_main.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/d3d8_main.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/d3d8_main.c (revision 46521) @@ -0,0 +1,104 @@ +/* $Id$ */ + +/** @file + * VBox D3D8 dll switcher + */ + +/* + * Copyright (C) 2009 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#include "d3d8.h" +#include "switcher.h" + +typedef HRESULT (WINAPI *D3D8GetSWInfoProc)(void); +typedef void (WINAPI *DebugSetMuteProc)(void); +typedef IDirect3D8* (WINAPI *Direct3DCreate8Proc)(UINT SDKVersion); +typedef HRESULT (WINAPI *ValidatePixelShaderProc)(DWORD* pixelshader, DWORD* reserved1, BOOL bool, DWORD* toto); +typedef HRESULT (WINAPI *ValidateVertexShaderProc)(DWORD* vertexshader, DWORD* reserved1, DWORD* reserved2, BOOL bool, DWORD* toto); + +static HRESULT WINAPI vboxD3D8GetSWInfoStub(void) +{ + return E_FAIL; +} + +static void WINAPI vboxDebugSetMuteStub(void) +{ + +} + +static IDirect3D8* WINAPI vboxDirect3DCreate8Stub(UINT SDKVersion) +{ + return NULL; +} + +static HRESULT WINAPI vboxValidatePixelShaderStub(DWORD* pixelshader, DWORD* reserved1, BOOL bool, DWORD* toto) +{ + return E_FAIL; +} + +static HRESULT WINAPI vboxValidateVertexShaderStub(DWORD* vertexshader, DWORD* reserved1, DWORD* reserved2, BOOL bool, DWORD* toto) +{ + return E_FAIL; +} + +typedef struct _D3D8ExTag +{ + int initialized; + const char *vboxName; + const char *msName; + D3D8GetSWInfoProc pD3D8GetSWInfo; + DebugSetMuteProc pDebugSetMute; + Direct3DCreate8Proc pDirect3DCreate8; + ValidatePixelShaderProc pValidatePixelShader; + ValidateVertexShaderProc pValidateVertexShader; +} D3D8Export; + +static D3D8Export g_swd3d8 = {0, "VBoxD3D8.dll", "MSD3D8.dll",}; + +void FillD3DExports(HANDLE hDLL) +{ + SW_FILLPROC(g_swd3d8, hDLL, D3D8GetSWInfo); + SW_FILLPROC(g_swd3d8, hDLL, DebugSetMute); + SW_FILLPROC(g_swd3d8, hDLL, Direct3DCreate8); + SW_FILLPROC(g_swd3d8, hDLL, ValidatePixelShader); + SW_FILLPROC(g_swd3d8, hDLL, ValidateVertexShader); +} + +HRESULT WINAPI D3D8GetSWInfo(void) +{ + SW_CHECKRET(g_swd3d8, D3D8GetSWInfo, E_FAIL); + return g_swd3d8.pD3D8GetSWInfo(); +} + +void WINAPI DebugSetMute(void) +{ + SW_CHECKCALL(g_swd3d8, DebugSetMute); + g_swd3d8.pDebugSetMute(); +} + +IDirect3D8* WINAPI Direct3DCreate8(UINT SDKVersion) +{ + SW_CHECKRET(g_swd3d8, Direct3DCreate8, NULL); + return g_swd3d8.pDirect3DCreate8(SDKVersion); +} + +HRESULT WINAPI ValidatePixelShader(DWORD* pixelshader, DWORD* reserved1, BOOL bool, DWORD* toto) +{ + SW_CHECKRET(g_swd3d8, ValidatePixelShader, E_FAIL); + return g_swd3d8.pValidatePixelShader(pixelshader, reserved1, bool, toto); +} + +HRESULT WINAPI ValidateVertexShader(DWORD* vertexshader, DWORD* reserved1, DWORD* reserved2, BOOL bool, DWORD* toto) +{ + SW_CHECKRET(g_swd3d8, ValidateVertexShader, E_FAIL) + return g_swd3d8.pValidateVertexShader(vertexshader, reserved1, reserved2, bool, toto); +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/d3d9.rc =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/d3d9.rc (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/d3d9.rc (revision 46521) @@ -0,0 +1,64 @@ +/* $Id$ */ +/** @file + * VBoxD3D9 - Resource file containing version info and icon. + */ + +/* + * Copyright (C) 2009-2010 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#include +#include + +LANGUAGE 0x09, 0x01 + +VS_VERSION_INFO VERSIONINFO + FILEVERSION VBOX_VERSION_MAJOR_NR,VBOX_VERSION_MINOR_NR,VBOX_VERSION_BUILD_NR,0 + PRODUCTVERSION VBOX_VERSION_MAJOR_NR,VBOX_VERSION_MINOR_NR,VBOX_VERSION_BUILD_NR,0 + FILEFLAGSMASK 0x3fL + FILEFLAGS 0x0L + FILEOS 0x40004L + FILETYPE 0x3L + FILESUBTYPE 0x4L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" + BEGIN + VALUE "CompanyName", VBOX_RC_COMPANY_NAME + VALUE "FileDescription", "VirtualBox D3D9 switcher\0" + VALUE "FileVersion", VBOX_VERSION_MAJOR "." VBOX_VERSION_MINOR "." VBOX_VERSION_BUILD "." VBOX_SVN_REV "\0" + VALUE "InternalName", "D3D9\0" + VALUE "LegalCopyright", VBOX_RC_LEGAL_COPYRIGHT + VALUE "OriginalFilename", "D3D9.dll\0" + VALUE "ProductName", VBOX_PRODUCT " Guest Additions\0" + VALUE "ProductVersion", VBOX_VERSION_MAJOR "." VBOX_VERSION_MINOR "." VBOX_VERSION_BUILD ".r" VBOX_SVN_REV "\0" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END + +1 RCDATA +BEGIN +// Machine dependent parameters + 17, // Height of vertical thumb + 17, // Width of horizontal thumb + 2, // Icon horiz compression factor + 2, // Icon vert compression factor + 1, // Cursor horz compression factor + 1, // Cursor vert compression factor + 0, // Kanji window height + 1, // cxBorder (thickness of vertical lines) + 1 // cyBorder (thickness of horizontal lines) +END Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/d3d9_main.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/d3d9_main.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/d3d9_main.c (revision 46521) @@ -0,0 +1,195 @@ +/* $Id$ */ + +/** @file + * VBox D3D8 dll switcher + */ + +/* + * Copyright (C) 2009 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#include "d3d9.h" +#include "switcher.h" + +typedef void (WINAPI *DebugSetMuteProc)(void); +typedef IDirect3D9* (WINAPI *Direct3DCreate9Proc)(UINT SDKVersion); +typedef HRESULT (WINAPI *Direct3DCreate9ExProc)(UINT SDKVersion, IDirect3D9Ex **direct3d9ex); +/* @todo: this does not return a value according to MSDN */ +typedef void* (WINAPI *Direct3DShaderValidatorCreate9Proc)(void); +typedef int (WINAPI *D3DPERF_BeginEventProc)(D3DCOLOR color, LPCWSTR name); +typedef int (WINAPI *D3DPERF_EndEventProc)(void); +typedef DWORD (WINAPI *D3DPERF_GetStatusProc)(void); +typedef void (WINAPI *D3DPERF_SetOptionsProc)(DWORD options); +typedef BOOL (WINAPI *D3DPERF_QueryRepeatFrameProc)(void); +typedef void (WINAPI *D3DPERF_SetMarkerProc)(D3DCOLOR color, LPCWSTR name); +typedef void (WINAPI *D3DPERF_SetRegionProc)(D3DCOLOR color, LPCWSTR name); + +static void WINAPI vboxDebugSetMuteStub(void) +{ +} + +static IDirect3D9* WINAPI vboxDirect3DCreate9Stub(UINT SDKVersion) +{ + return NULL; +} + +static HRESULT WINAPI vboxDirect3DCreate9ExStub(UINT SDKVersion, IDirect3D9Ex **direct3d9ex) +{ + if (direct3d9ex) + *direct3d9ex = NULL; + return E_FAIL; +} + +static void* WINAPI vboxDirect3DShaderValidatorCreate9Stub(void) +{ + return NULL; +} + +static int WINAPI vboxD3DPERF_BeginEventStub(D3DCOLOR color, LPCWSTR name) +{ + return 0; +} + +static int WINAPI vboxD3DPERF_EndEventStub(void) +{ + return 0; +} + +static DWORD WINAPI vboxD3DPERF_GetStatusStub(void) +{ + return 0; +} + +static void WINAPI vboxD3DPERF_SetOptionsStub(DWORD options) +{ + +} + +static BOOL WINAPI vboxD3DPERF_QueryRepeatFrameStub(void) +{ + return 0; +} + +static void WINAPI vboxD3DPERF_SetMarkerStub(D3DCOLOR color, LPCWSTR name) +{ + +} + +static void WINAPI vboxD3DPERF_SetRegionStub(D3DCOLOR color, LPCWSTR name) +{ + +} + + +typedef struct _D3D9ExTag +{ + int initialized; + const char *vboxName; + const char *msName; + DebugSetMuteProc pDebugSetMute; + Direct3DCreate9Proc pDirect3DCreate9; + Direct3DCreate9ExProc pDirect3DCreate9Ex; + Direct3DShaderValidatorCreate9Proc pDirect3DShaderValidatorCreate9; + D3DPERF_BeginEventProc pD3DPERF_BeginEvent; + D3DPERF_EndEventProc pD3DPERF_EndEvent; + D3DPERF_GetStatusProc pD3DPERF_GetStatus; + D3DPERF_SetOptionsProc pD3DPERF_SetOptions; + D3DPERF_QueryRepeatFrameProc pD3DPERF_QueryRepeatFrame; + D3DPERF_SetMarkerProc pD3DPERF_SetMarker; + D3DPERF_SetRegionProc pD3DPERF_SetRegion; +} D3D9Export; + +#ifdef VBOX_WDDM_WOW64 +static D3D9Export g_swd3d9 = {0, "VBoxD3D9-x86.dll", "MSD3D9.dll",}; +#else +static D3D9Export g_swd3d9 = {0, "VBoxD3D9.dll", "MSD3D9.dll",}; +#endif + +void FillD3DExports(HANDLE hDLL) +{ + SW_FILLPROC(g_swd3d9, hDLL, DebugSetMute); + SW_FILLPROC(g_swd3d9, hDLL, Direct3DCreate9); + SW_FILLPROC(g_swd3d9, hDLL, Direct3DCreate9Ex); + SW_FILLPROC(g_swd3d9, hDLL, Direct3DShaderValidatorCreate9); + SW_FILLPROC(g_swd3d9, hDLL, D3DPERF_BeginEvent); + SW_FILLPROC(g_swd3d9, hDLL, D3DPERF_EndEvent); + SW_FILLPROC(g_swd3d9, hDLL, D3DPERF_GetStatus); + SW_FILLPROC(g_swd3d9, hDLL, D3DPERF_SetOptions); + SW_FILLPROC(g_swd3d9, hDLL, D3DPERF_QueryRepeatFrame); + SW_FILLPROC(g_swd3d9, hDLL, D3DPERF_SetMarker); + SW_FILLPROC(g_swd3d9, hDLL, D3DPERF_SetRegion); +} + +void WINAPI DebugSetMute(void) +{ + SW_CHECKCALL(g_swd3d9, DebugSetMute); + g_swd3d9.pDebugSetMute(); +} + +IDirect3D9* WINAPI Direct3DCreate9(UINT SDKVersion) +{ + SW_CHECKRET(g_swd3d9, Direct3DCreate9, NULL); + return g_swd3d9.pDirect3DCreate9(SDKVersion); +} + +HRESULT WINAPI Direct3DCreate9Ex(UINT SDKVersion, IDirect3D9Ex **direct3d9ex) +{ + SW_CHECKRET(g_swd3d9, Direct3DCreate9Ex, E_FAIL); + return g_swd3d9.pDirect3DCreate9Ex(SDKVersion, direct3d9ex); +} + +void* WINAPI Direct3DShaderValidatorCreate9(void) +{ + SW_CHECKRET(g_swd3d9, Direct3DShaderValidatorCreate9, NULL); + return g_swd3d9.pDirect3DShaderValidatorCreate9(); +} + +int WINAPI D3DPERF_BeginEvent(D3DCOLOR color, LPCWSTR name) +{ + SW_CHECKRET(g_swd3d9, D3DPERF_BeginEvent, -1); + return g_swd3d9.pD3DPERF_BeginEvent(color, name); +} + +int WINAPI D3DPERF_EndEvent(void) +{ + SW_CHECKRET(g_swd3d9, D3DPERF_EndEvent, -1); + return g_swd3d9.pD3DPERF_EndEvent(); +} + +DWORD WINAPI D3DPERF_GetStatus(void) +{ + SW_CHECKRET(g_swd3d9, D3DPERF_EndEvent, 0); + return g_swd3d9.pD3DPERF_GetStatus(); +} + +void WINAPI D3DPERF_SetOptions(DWORD options) +{ + SW_CHECKCALL(g_swd3d9, D3DPERF_SetOptions); + g_swd3d9.pD3DPERF_SetOptions(options); +} + +BOOL WINAPI D3DPERF_QueryRepeatFrame(void) +{ + SW_CHECKRET(g_swd3d9, D3DPERF_QueryRepeatFrame, FALSE); + return g_swd3d9.pD3DPERF_QueryRepeatFrame(); +} + +void WINAPI D3DPERF_SetMarker(D3DCOLOR color, LPCWSTR name) +{ + SW_CHECKCALL(g_swd3d9, D3DPERF_SetMarker); + g_swd3d9.pD3DPERF_SetMarker(color, name); +} + +void WINAPI D3DPERF_SetRegion(D3DCOLOR color, LPCWSTR name) +{ + SW_CHECKCALL(g_swd3d9, D3DPERF_SetRegion); + g_swd3d9.pD3DPERF_SetRegion(color, name); +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/sw_common.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/sw_common.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/sw_common.c (revision 46521) @@ -0,0 +1,119 @@ +/* $Id$ */ + +/** @file + * VBox D3D8/9 dll switcher + */ + +/* + * Copyright (C) 2009 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#include +#include "switcher.h" + +static char* gsBlackListExe[] = {"Dwm.exe", "java.exe", "javaw.exe", "javaws.exe"/*, "taskeng.exe"*/, NULL}; +static char* gsBlackListDll[] = {"awt.dll", "wpfgfx_v0400.dll", "wpfgfx_v0300.dll", NULL}; + +/* Checks if 3D is enabled for VM and it works on host machine */ +BOOL isVBox3DEnabled(void) +{ + DrvValidateVersionProc pDrvValidateVersion; + HANDLE hDLL; + BOOL result = FALSE; + +#ifdef VBOX_WDDM_WOW64 + hDLL = LoadLibrary("VBoxOGL-x86.dll"); +#else + hDLL = LoadLibrary("VBoxOGL.dll"); +#endif + + /* note: this isn't really needed as our library will refuse to load if it can't connect to host. + so it's in case we'd change it one day. + */ + pDrvValidateVersion = (DrvValidateVersionProc) GetProcAddress(hDLL, "DrvValidateVersion"); + if (pDrvValidateVersion) + { + result = pDrvValidateVersion(0); + } + FreeLibrary(hDLL); + return result; +} + +BOOL checkOptionsDll(void) +{ + int i; + for (i=0; gsBlackListDll[i]; ++i) + { + if (GetModuleHandleA(gsBlackListDll[i])) + return FALSE; + } + + return TRUE; +} + +BOOL checkOptionsExe(void) +{ + char name[1000]; + char *filename = name, *pName; + int i; + + if (!GetModuleFileName(NULL, name, 1000)) + return TRUE; + + /*Extract filename*/ + for (pName=name; *pName; ++pName) + { + switch (*pName) + { + case ':': + case '\\': + case '/': + filename = pName + 1; + break; + } + } + + for (i=0; gsBlackListExe[i]; ++i) + { + if (!stricmp(filename, gsBlackListExe[i])) + return FALSE; + } + + return TRUE; +} + +BOOL checkOptions(void) +{ + if (!checkOptionsDll()) + return FALSE; + + if (!checkOptionsExe()) + return FALSE; + + return TRUE; +} + +void InitD3DExports(const char *vboxName, const char *msName) +{ + const char *dllName; + HANDLE hDLL; + + if (isVBox3DEnabled() && checkOptions()) + { + dllName = vboxName; + } else + { + dllName = msName; + } + + hDLL = LoadLibrary(dllName); + FillD3DExports(hDLL); +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/sw_d3d8.def =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/sw_d3d8.def (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/sw_d3d8.def (revision 46521) @@ -0,0 +1,6 @@ +EXPORTS + D3D8GetSWInfo + DebugSetMute + Direct3DCreate8 + ValidatePixelShader + ValidateVertexShader Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/sw_d3d9.def =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/sw_d3d9.def (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/sw_d3d9.def (revision 46521) @@ -0,0 +1,12 @@ +EXPORTS + Direct3DShaderValidatorCreate9@0=Direct3DShaderValidatorCreate9 + D3DPERF_BeginEvent@8=D3DPERF_BeginEvent + D3DPERF_EndEvent@0=D3DPERF_EndEvent + D3DPERF_GetStatus@0=D3DPERF_GetStatus + D3DPERF_QueryRepeatFrame@0=D3DPERF_QueryRepeatFrame + D3DPERF_SetMarker@8=D3DPERF_SetMarker + D3DPERF_SetOptions@4=D3DPERF_SetOptions + D3DPERF_SetRegion@8=D3DPERF_SetRegion + DebugSetMute@0=DebugSetMute + Direct3DCreate9@4=Direct3DCreate9 + Direct3DCreate9Ex@8=Direct3DCreate9Ex Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/sw_d3d9xpdm.def =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/sw_d3d9xpdm.def (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/sw_d3d9xpdm.def (revision 46521) @@ -0,0 +1,12 @@ +EXPORTS + Direct3DShaderValidatorCreate9 + D3DPERF_BeginEvent + D3DPERF_EndEvent + D3DPERF_GetStatus + D3DPERF_QueryRepeatFrame + D3DPERF_SetMarker + D3DPERF_SetOptions + D3DPERF_SetRegion + DebugSetMute + Direct3DCreate9 + Direct3DCreate9Ex Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/switcher.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/switcher.h (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/switcher/switcher.h (revision 46521) @@ -0,0 +1,54 @@ +/* $Id$ */ + +/** @file + * VBox D3D8/9 dll switcher + */ + +/* + * Copyright (C) 2009 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#ifndef ___CROPENGL_SWITCHER_H_ +#define ___CROPENGL_SWITCHER_H_ + +typedef BOOL (APIENTRY *DrvValidateVersionProc)(DWORD version); + +#define SW_FILLPROC(dispatch, hdll, name) \ + dispatch.p##name = ((hdll) != NULL) ? (name##Proc) GetProcAddress((hdll), #name) : vbox##name##Stub; + +#define SW_DISPINIT(dispatch) \ + { \ + if (!dispatch.initialized) \ + { \ + InitD3DExports(dispatch.vboxName, dispatch.msName); \ + dispatch.initialized = 1; \ + } \ + } + +#define SW_CHECKRET(dispatch, func, failret) \ + { \ + SW_DISPINIT(dispatch) \ + if (!dispatch.p##func) \ + return failret; \ + } + +#define SW_CHECKCALL(dispatch, func) \ + { \ + SW_DISPINIT(dispatch) \ + if (!dispatch.p##func) return; \ + } + +extern BOOL IsVBox3DEnabled(void); +extern BOOL CheckOptions(void); +extern void FillD3DExports(HANDLE hDLL); +extern void InitD3DExports(const char *vboxName, const char *msName); + +#endif /* #ifndef ___CROPENGL_SWITCHER_H_ */ Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/vbox/VBoxDbgGl.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/vbox/VBoxDbgGl.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/vbox/VBoxDbgGl.c (revision 46521) @@ -0,0 +1,389 @@ +/* $Id$ */ + +/** @file + * VBox wine & ogl debugging stuff + */ + +/* + * Copyright (C) 2011 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#include "config.h" +#include "wine/port.h" + +#include +#ifdef HAVE_FLOAT_H +# include +#endif + +#include "../wined3d/wined3d_private.h" + +#include "VBoxDbgGl.h" + +#include + + +DWORD g_VBoxDbgGlFCheckDrawPrim = 0; +DWORD g_VBoxDbgGlFBreakDrawPrimIfCanNotMatch = 0; + +void dbglFree(void *pvData) +{ + HeapFree(GetProcessHeap(), 0, pvData); +} + +void* dbglAlloc(DWORD cbSize) +{ + return HeapAlloc(GetProcessHeap(), 0, cbSize); +} + +GLint dbglFmtGetNumComponents(GLenum format) +{ + switch(format) + { + case GL_COLOR_INDEX: + case GL_RED: + case GL_GREEN: + case GL_BLUE: + case GL_ALPHA: + return 1; + case GL_RGB: + case GL_BGR: + return 3; + case GL_RGBA: + case GL_BGRA: + return 4; + case GL_LUMINANCE: + return 1; + case GL_LUMINANCE_ALPHA: + return 2; + default: + Assert(0); + return 1; + } +} + +GLint dbglFmtGetBpp(GLenum format, GLenum type) +{ + switch (type) + { + case GL_UNSIGNED_BYTE_3_3_2: + return 8; + case GL_UNSIGNED_BYTE_2_3_3_REV: + return 8; + case GL_UNSIGNED_SHORT_5_6_5: + return 16; + case GL_UNSIGNED_SHORT_5_6_5_REV: + return 16; + case GL_UNSIGNED_SHORT_4_4_4_4: + return 16; + case GL_UNSIGNED_SHORT_4_4_4_4_REV: + return 16; + case GL_UNSIGNED_SHORT_5_5_5_1: + return 16; + case GL_UNSIGNED_SHORT_1_5_5_5_REV: + return 16; + case GL_UNSIGNED_INT_8_8_8_8: + return 32; + case GL_UNSIGNED_INT_8_8_8_8_REV: + return 32; + case GL_UNSIGNED_INT_10_10_10_2: + return 32; + case GL_UNSIGNED_INT_2_10_10_10_REV: + return 32; + case GL_BYTE: + case GL_UNSIGNED_BYTE: + return dbglFmtGetNumComponents(format) * 8; + case GL_SHORT: + case GL_UNSIGNED_SHORT: + return dbglFmtGetNumComponents(format) * 16; + case GL_INT: + case GL_UNSIGNED_INT: + case GL_FLOAT: + return dbglFmtGetNumComponents(format) * 32; + case GL_DOUBLE: + return dbglFmtGetNumComponents(format) * 64; + case GL_2_BYTES: + return dbglFmtGetNumComponents(format) * 16; + case GL_3_BYTES: + return dbglFmtGetNumComponents(format) * 24; + case GL_4_BYTES: + return dbglFmtGetNumComponents(format) * 32; + default: + Assert(0); + return 8; + } +} + +#define DBGL_OP(_op) gl##_op +#define DBGL_FBO_OP(_op) (gl_info->fbo_ops.gl##_op) +#define DBGL_EXT_OP(_op) (gl_info->gl_ops.ext.p_gl##_op) + +void dbglGetTexImage2D(const struct wined3d_gl_info *gl_info, GLint texTarget, GLint texName, GLint level, GLvoid **ppvImage, GLint *pw, GLint *ph, GLenum format, GLenum type) +{ + GLint ppb, pub, dstw, dsth, otex; + GLint pa, pr, psp, psr, ua, ur, usp, usr; + GLvoid *pvImage; + GLint rfb, dfb, rb, db; + GLint bpp = dbglFmtGetBpp(format, type); + + DBGL_OP(GetIntegerv(GL_READ_FRAMEBUFFER_BINDING_EXT, &rfb)); + DBGL_OP(GetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, &dfb)); + DBGL_OP(GetIntegerv(GL_READ_BUFFER, &rb)); + DBGL_OP(GetIntegerv(GL_DRAW_BUFFER, &db)); + + DBGL_FBO_OP(BindFramebuffer)(GL_READ_FRAMEBUFFER_BINDING_EXT, 0); + DBGL_FBO_OP(BindFramebuffer)(GL_DRAW_FRAMEBUFFER_BINDING_EXT, 0); + DBGL_OP(ReadBuffer(GL_BACK)); + DBGL_OP(DrawBuffer(GL_BACK)); + + DBGL_OP(GetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING_ARB, &ppb)); + DBGL_OP(GetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING_ARB, &pub)); + DBGL_OP(GetIntegerv(GL_TEXTURE_BINDING_2D, &otex)); + + DBGL_OP(GetIntegerv(GL_PACK_ROW_LENGTH, &pr)); + DBGL_OP(GetIntegerv(GL_PACK_ALIGNMENT, &pa)); + DBGL_OP(GetIntegerv(GL_PACK_SKIP_PIXELS, &psp)); + DBGL_OP(GetIntegerv(GL_PACK_SKIP_ROWS, &psr)); + + DBGL_OP(GetIntegerv(GL_UNPACK_ROW_LENGTH, &ur)); + DBGL_OP(GetIntegerv(GL_UNPACK_ALIGNMENT, &ua)); + DBGL_OP(GetIntegerv(GL_UNPACK_SKIP_PIXELS, &usp)); + DBGL_OP(GetIntegerv(GL_UNPACK_SKIP_ROWS, &usr)); + + DBGL_OP(BindTexture(texTarget, texName)); + DBGL_OP(GetTexLevelParameteriv(texTarget, level, GL_TEXTURE_WIDTH, &dstw)); + DBGL_OP(GetTexLevelParameteriv(texTarget, level, GL_TEXTURE_HEIGHT, &dsth)); + + DBGL_OP(PixelStorei(GL_PACK_ROW_LENGTH, 0)); + DBGL_OP(PixelStorei(GL_PACK_ALIGNMENT, 1)); + DBGL_OP(PixelStorei(GL_PACK_SKIP_PIXELS, 0)); + DBGL_OP(PixelStorei(GL_PACK_SKIP_ROWS, 0)); + + DBGL_OP(PixelStorei(GL_UNPACK_ROW_LENGTH, 0)); + DBGL_OP(PixelStorei(GL_UNPACK_ALIGNMENT, 1)); + DBGL_OP(PixelStorei(GL_UNPACK_SKIP_PIXELS, 0)); + DBGL_OP(PixelStorei(GL_UNPACK_SKIP_ROWS, 0)); + + DBGL_EXT_OP(BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0)); + DBGL_EXT_OP(BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0)); + + pvImage = dbglAlloc(((bpp*dstw + 7) >> 3)*dsth); + DBGL_OP(GetTexImage(texTarget, level, format, type, pvImage)); + + DBGL_OP(BindTexture(texTarget, otex)); + + DBGL_OP(PixelStorei(GL_PACK_ROW_LENGTH, pr)); + DBGL_OP(PixelStorei(GL_PACK_ALIGNMENT, pa)); + DBGL_OP(PixelStorei(GL_PACK_SKIP_PIXELS, psp)); + DBGL_OP(PixelStorei(GL_PACK_SKIP_ROWS, psr)); + + DBGL_OP(PixelStorei(GL_UNPACK_ROW_LENGTH, ur)); + DBGL_OP(PixelStorei(GL_UNPACK_ALIGNMENT, ua)); + DBGL_OP(PixelStorei(GL_UNPACK_SKIP_PIXELS, usp)); + DBGL_OP(PixelStorei(GL_UNPACK_SKIP_ROWS, usr)); + + DBGL_EXT_OP(BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, ppb)); + DBGL_EXT_OP(BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pub)); + + DBGL_FBO_OP(BindFramebuffer)(GL_READ_FRAMEBUFFER_BINDING_EXT, rfb); + DBGL_FBO_OP(BindFramebuffer)(GL_DRAW_FRAMEBUFFER_BINDING_EXT, dfb); + DBGL_OP(ReadBuffer(rb)); + DBGL_OP(DrawBuffer(db)); + + *ppvImage = pvImage; + *pw = dstw; + *ph = dsth; +} + +DECLEXPORT(void) dbglPrint(const char *format, ... ) +{ + va_list args; + static char txt[8092]; + + va_start( args, format ); + vsprintf( txt, format, args ); + + OutputDebugString(txt); +} + +void dbglDumpImage2D(const char* pszDesc, const void *pvData, uint32_t width, uint32_t height, uint32_t bpp, uint32_t pitch) +{ + dbglPrint("%s, ( !vbvdbg.ms 0x%p 0n%d 0n%d 0n%d 0n%d )\n", + pvData, width, height, bpp, pitch, + pszDesc, + pvData, width, height, bpp, pitch); +} + +void dbglDumpTexImage2D(const struct wined3d_gl_info *gl_info, const char* pszDesc, GLint texTarget, GLint texName, GLint level, GLboolean fBreak) +{ + GLvoid *pvImage; + GLint w, h; + dbglGetTexImage2D(gl_info, texTarget, texName, level, &pvImage, &w, &h, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV); + dbglPrint("%s target(%d), name(%d), width(%d), height(%d)\n", pszDesc, texTarget, texName, w, h); + dbglDumpImage2D("texture data", pvImage, w, h, 32, (32 * w)/8); + if (fBreak) + { + Assert(0); + } + dbglFree(pvImage); +} + +void dbglCmpTexImage2D(const struct wined3d_gl_info *gl_info, const char* pszDesc, GLint texTarget, GLint texName, GLint level, void *pvImage, + GLint width, GLint height, GLenum format, GLenum type) +{ + GLvoid *pvTexImg; + GLint w, h; + GLint bpp = dbglFmtGetBpp(format, type); + GLint pitch, texPitch; + + dbglGetTexImage2D(gl_info, texTarget, texName, level, &pvTexImg, &w, &h, format, type); + + pitch = ((bpp * width + 7) >> 3)/8; + texPitch = ((bpp * w + 7) >> 3)/8; + + if (w != width) + { + dbglPrint("width mismatch was %d, but expected %d\n", w, width); + dbglDumpImage2D("expected texture data:", pvImage, width, height, bpp, pitch); + dbglDumpImage2D("stored texture data:", pvTexImg, w, h, bpp, texPitch); + + Assert(0); + + dbglFree(pvTexImg); + return; + } + if (h != height) + { + dbglPrint("height mismatch was %d, but expected %d\n", h, height); + dbglDumpImage2D("expected texture data:", pvImage, width, height, bpp, pitch); + dbglDumpImage2D("stored texture data:", pvTexImg, w, h, bpp, texPitch); + + Assert(0); + + dbglFree(pvTexImg); + return; + } + + if (memcmp(pvImage, pvTexImg, w * h * 4)) + { + dbglPrint("tex data mismatch\n"); + dbglDumpImage2D("expected texture data:", pvImage, width, height, bpp, pitch); + dbglDumpImage2D("stored texture data:", pvTexImg, w, h, bpp, texPitch); + + Assert(0); + } + + dbglFree(pvTexImg); +} + +void dbglCheckTexUnits(const struct wined3d_gl_info *gl_info, struct wined3d_device *pDevice, BOOL fBreakIfCanNotMatch) +{ + int iStage; + GLint ActiveTexUnit = 0; + GLint CheckTexUnit = 0; + DBGL_OP(GetIntegerv(GL_ACTIVE_TEXTURE, &ActiveTexUnit)); + + Assert(ActiveTexUnit >= GL_TEXTURE0); + Assert(gl_info->limits.combined_samplers <= RT_ELEMENTS(pDevice->stateBlock->state.textures)); + Assert(ActiveTexUnit < GL_TEXTURE0 + gl_info->limits.combined_samplers); + + CheckTexUnit = ActiveTexUnit; + + Assert(ActiveTexUnit == pDevice->contexts[0]->active_texture + GL_TEXTURE0); + + for (iStage = 0; iStage < gl_info->limits.combined_samplers; ++iStage) + { + GLint curTex = 0; + int iLevel; + struct gl_texture *pGlTex; + const struct wined3d_texture *pTexture = (const struct wined3d_texture*)pDevice->stateBlock->state.textures[iStage]; + + if (CheckTexUnit != iStage + GL_TEXTURE0) + { + DBGL_EXT_OP(ActiveTextureARB(iStage + GL_TEXTURE0)); + CheckTexUnit = iStage + GL_TEXTURE0; + } + + DBGL_OP(GetIntegerv(GL_TEXTURE_BINDING_2D, &curTex)); + + if (!pTexture) + { + Assert(curTex == 0 || curTex == pDevice->dummy_texture_2d[iStage]); + continue; + } + + if(pTexture->flags & WINED3D_TEXTURE_IS_SRGB) + { + Assert(0); + pGlTex = &pTexture->texture_srgb; + } + else + pGlTex = &pTexture->texture_rgb; + + /* not implemented */ + Assert(pTexture->target == GL_TEXTURE_2D); + Assert(curTex); + Assert(pGlTex->name); + Assert(pGlTex->name == curTex); + Assert(DBGL_OP(IsEnabled(pTexture->target))); + + /* not implemented */ + Assert(pTexture->layer_count == 1); + + for (iLevel = 0; iLevel < (int)pTexture->level_count; ++iLevel) + { + struct wined3d_surface *surface = (struct wined3d_surface *)pTexture->sub_resources[iLevel]; + Assert(surface); + + Assert(surface->flags & SFLAG_INTEXTURE); + + Assert(surface->texture_target == pTexture->target); + Assert(surface->texture_name == (pTexture->flags & WINED3D_TEXTURE_IS_SRGB) ? pTexture->texture_srgb.name : pTexture->texture_rgb.name); +#if 0 + if (pSurf->flags & SFLAG_INSYSMEM && !pSurf->Flags & SFLAG_PBO) + { + Assert(pSurf->resource.allocatedMemory); + /* we can match GPU & our state */ + dbglCmpTexImage2D(gl_info, "matching tex data state", pSurf->texture_target, pSurf->texture_name, iLevel, pSurf->resource.allocatedMemory, + pSurf->currentDesc.Width, pSurf->currentDesc.Height, pSurf->resource.format_desc->glFormat, pSurf->resource.format_desc->glType); + } + else + { + GLint w,h; + if (fBreakIfCanNotMatch) + { + GLvoid* pvImage; + dbglGetTexImage2D(gl_info, pSurf->texture_target, pSurf->texture_name, iLevel, &pvImage, &w, &h, GL_BGRA, GL_UNSIGNED_BYTE); + Assert(w == pSurf->currentDesc.Width); + Assert(h == pSurf->currentDesc.Height); + dbglDumpImage2D("matching texture data", pvImage, w, h, 32, (32 * w)/8); + Assert(0); + dbglFree(pvImage); + } + else + { + /* just check width & height */ + /* since we already asserted current texture binding, we can just quiry its parameters */ + DBGL_OP(GetTexLevelParameteriv(pSurf->texture_target, iLevel, GL_TEXTURE_WIDTH, &w)); + DBGL_OP(GetTexLevelParameteriv(pSurf->texture_target, iLevel, GL_TEXTURE_HEIGHT, &h)); + Assert(w == pSurf->currentDesc.Width); + Assert(h == pSurf->currentDesc.Height); + } + } +#endif + } + } + + if (CheckTexUnit != ActiveTexUnit) + { + DBGL_EXT_OP(ActiveTextureARB(ActiveTexUnit)); + } +} Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/vbox/VBoxDbgGl.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/vbox/VBoxDbgGl.h (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/vbox/VBoxDbgGl.h (revision 46521) @@ -0,0 +1,43 @@ +/* $Id$ */ + +/** @file + * VBox wine & ogl debugging stuff + */ + +/* + * Copyright (C) 2011 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#ifndef ___VBoxDbgGl_h__ +#define ___VBoxDbgGl_h__ + +//#include +//#include "../wined3d/wined3d_gl.h" + +void dbglGetTexImage2D(const struct wined3d_gl_info *gl_info, GLint texTarget, GLint texName, GLint level, GLvoid **ppvImage, GLint *pw, GLint *ph, GLenum format, GLenum type); +void dbglDumpTexImage2D(const struct wined3d_gl_info *gl_info, const char* pszDesc, GLint texTarget, GLint texName, GLint level, GLboolean fBreak); +void dbglCmpTexImage2D(const struct wined3d_gl_info *gl_info, const char* pszDesc, GLint texTarget, GLint texName, GLint level, void *pvImage, GLint width, GLint height, GLenum format, GLenum type); +void dbglCheckTexUnits(const struct wined3d_gl_info *gl_info, struct wined3d_device *pDevice, BOOL fBreakIfCanNotMatch); + +#ifdef DEBUG_misha +#define DBGL_CHECK_DRAWPRIM(_gl_info, _pDevice) do { \ + if (g_VBoxDbgGlFCheckDrawPrim) { \ + dbglCheckTexUnits((_gl_info), (_pDevice), g_VBoxDbgGlFBreakDrawPrimIfCanNotMatch); \ + } \ + } while (0) +#else +#define DBGL_CHECK_DRAWPRIM(_gl_info, _pDevice) do {} while (0) +#endif + +extern DWORD g_VBoxDbgGlFCheckDrawPrim; +extern DWORD g_VBoxDbgGlFBreakDrawPrimIfCanNotMatch; + +#endif /* #ifndef ___VBoxDbgGl_h__ */ Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/vbox/VBoxWineEx.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/vbox/VBoxWineEx.h (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/vbox/VBoxWineEx.h (revision 46521) @@ -0,0 +1,136 @@ +/** @file + * + * VBox extension to Wine D3D + * + * Copyright (C) 2010 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ +#ifndef ___VBoxWineEx_h__ +#define ___VBoxWineEx_h__ + +typedef enum +{ + VBOXWINEEX_SHRC_STATE_UNDEFINED = 0, + /* the underlying GL resource can not be used because it can be removed concurrently by other SHRC client */ + VBOXWINEEX_SHRC_STATE_GL_DISABLE, + /* the given client is requested to delete the underlying GL resource on SHRC termination */ + VBOXWINEEX_SHRC_STATE_GL_DELETE +} VBOXWINEEX_SHRC_STATE; + + +#ifndef IN_VBOXLIBWINE + +#define VBOXWINEEX_VERSION 1 + +#ifndef IN_VBOXWINEEX +# define VBOXWINEEX_DECL(_type) __declspec(dllimport) _type WINAPI +# else +# define VBOXWINEEX_DECL(_type) __declspec(dllexport) _type WINAPI +#endif + +typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DDEV9_CREATETEXTURE(IDirect3DDevice9Ex *iface, + UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, IDirect3DTexture9 **texture, HANDLE *shared_handle, + void **pavClientMem); +typedef FNVBOXWINEEXD3DDEV9_CREATETEXTURE *PFNVBOXWINEEXD3DDEV9_CREATETEXTURE; + +typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DDEV9_CREATECUBETEXTURE(IDirect3DDevice9Ex *iface, + UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, IDirect3DCubeTexture9 **texture, HANDLE *shared_handle, + void **pavClientMem); +typedef FNVBOXWINEEXD3DDEV9_CREATECUBETEXTURE *PFNVBOXWINEEXD3DDEV9_CREATECUBETEXTURE; + +typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DDEV9_CREATEVOLUMETEXTURE(IDirect3DDevice9Ex *iface, + UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT Format, D3DPOOL Pool, + IDirect3DVolumeTexture9 **ppVolumeTexture, HANDLE *pSharedHandle, + void **pavClientMem); +typedef FNVBOXWINEEXD3DDEV9_CREATEVOLUMETEXTURE *PFNVBOXWINEEXD3DDEV9_CREATEVOLUMETEXTURE; + +typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DDEV9_VOLBLT(IDirect3DDevice9Ex *iface, + IDirect3DVolume9 *pSourceVolume, IDirect3DVolume9 *pDestinationVolume, + const struct VBOXBOX3D *pSrcBoxArg, + const struct VBOXPOINT3D *pDstPoin3D); +typedef FNVBOXWINEEXD3DDEV9_VOLBLT *PFNVBOXWINEEXD3DDEV9_VOLBLT; + +typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DDEV9_VOLTEXBLT(IDirect3DDevice9Ex *iface, + IDirect3DVolumeTexture9 *pSourceTexture, IDirect3DVolumeTexture9 *pDestinationTexture, + const struct VBOXBOX3D *pSrcBoxArg, + const struct VBOXPOINT3D *pDstPoin3D); +typedef FNVBOXWINEEXD3DDEV9_VOLTEXBLT *PFNVBOXWINEEXD3DDEV9_VOLTEXBLT; + +typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DDEV9_FLUSH(IDirect3DDevice9Ex *iface); +typedef FNVBOXWINEEXD3DDEV9_FLUSH *PFNVBOXWINEEXD3DDEV9_FLUSH; + +typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DDEV9_FLUSHTOHOST(IDirect3DDevice9Ex *iface); +typedef FNVBOXWINEEXD3DDEV9_FLUSHTOHOST *PFNVBOXWINEEXD3DDEV9_FLUSHTOHOST; + +typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DDEV9_FINISH(IDirect3DDevice9Ex *iface); +typedef FNVBOXWINEEXD3DDEV9_FINISH *PFNVBOXWINEEXD3DDEV9_FINISH; + +typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DDEV9_TERM(IDirect3DDevice9Ex *iface); +typedef FNVBOXWINEEXD3DDEV9_TERM *PFNVBOXWINEEXD3DDEV9_TERM; + +typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DSWAPCHAIN9_PRESENT(IDirect3DSwapChain9 *iface, IDirect3DSurface9 *surf); +typedef FNVBOXWINEEXD3DSWAPCHAIN9_PRESENT *PFNVBOXWINEEXD3DSWAPCHAIN9_PRESENT; + +#ifdef __cplusplus +extern "C" +{ +#endif +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9CreateTexture(IDirect3DDevice9Ex *iface, + UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, IDirect3DTexture9 **texture, HANDLE *shared_handle, + void **pavClientMem); /* <- extension arg to pass in the client memory buffer, + * applicable ONLY for SYSMEM textures */ + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9CreateCubeTexture(IDirect3DDevice9Ex *iface, + UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format, + D3DPOOL pool, IDirect3DCubeTexture9 **texture, HANDLE *shared_handle, + void **pavClientMem); /* <- extension arg to pass in the client memory buffer, + * applicable ONLY for SYSMEM textures */ + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9CreateVolumeTexture(IDirect3DDevice9Ex *iface, + UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT Format, D3DPOOL Pool, + IDirect3DVolumeTexture9 **ppVolumeTexture, HANDLE *pSharedHandle, + void **pavClientMem); + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9VolBlt(IDirect3DDevice9Ex *iface, + IDirect3DVolume9 *pSourceVolume, IDirect3DVolume9 *pDestinationVolume, + const struct VBOXBOX3D *pSrcBoxArg, + const struct VBOXPOINT3D *pDstPoin3D); + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9VolTexBlt(IDirect3DDevice9Ex *iface, + IDirect3DVolumeTexture9 *pSourceTexture, IDirect3DVolumeTexture9 *pDestinationTexture, + const struct VBOXBOX3D *pSrcBoxArg, + const struct VBOXPOINT3D *pDstPoin3D); + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9Flush(IDirect3DDevice9Ex *iface); /* perform glFlush */ + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9Finish(IDirect3DDevice9Ex *iface); /* perform glFinish */ + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9FlushToHost(IDirect3DDevice9Ex *iface); /* flash data to host */ + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9Term(IDirect3DDevice9Ex *iface); + +VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DSwapchain9Present(IDirect3DSwapChain9 *iface, + IDirect3DSurface9 *surf); /* use the given surface as a frontbuffer content source */ + +typedef struct VBOXWINEEX_D3DPRESENT_PARAMETERS +{ + D3DPRESENT_PARAMETERS Base; + struct VBOXUHGSMI *pHgsmi; +} VBOXWINEEX_D3DPRESENT_PARAMETERS, *PVBOXWINEEX_D3DPRESENT_PARAMETERS; +#ifdef __cplusplus +} +#endif + +#endif /* #ifndef IN_VBOXLIBWINE */ + +#endif Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/vbox/libWineStub/debug.c =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/vbox/libWineStub/debug.c (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/vbox/libWineStub/debug.c (revision 46521) @@ -0,0 +1,498 @@ +/* + * Management of the debugging channels + * + * Copyright 2000 Alexandre Julliard + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +/* + * Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice + * other than GPL or LGPL is available it will apply instead, Oracle elects to use only + * the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where + * a choice of LGPL license versions is made available with the language indicating + * that LGPLv2 or any later version may be used, or where a choice of which version + * of the LGPL is applied is otherwise unspecified. + */ + +#include + +#include "config.h" +#include "wine/port.h" + +#include +#include +#include +#include +#include + +#include "wine/debug.h" +//#include "wine/library.h" + +#ifdef VBOX_WITH_WDDM +#include +#include +#else +#include +#endif + +static const char * const debug_classes[] = { "fixme", "err", "warn", "trace" }; + +#define MAX_DEBUG_OPTIONS 256 + +typedef DECLCALLBACK(void) FNVBOXWINELOGBACKDOOR(char* pcszStr); +typedef FNVBOXWINELOGBACKDOOR *PFNVBOXWINELOGBACKDOOR; +static PFNVBOXWINELOGBACKDOOR vbox_log_backdoor = NULL; +static unsigned char default_flags = (1 << __WINE_DBCL_ERR) | (1 << __WINE_DBCL_FIXME) | (1 << __WINE_DBCL_WARN); +static int nb_debug_options = -1; +static struct __wine_debug_channel debug_options[MAX_DEBUG_OPTIONS]; + +static struct __wine_debug_functions funcs; + +static void debug_init(void); + +static int cmp_name( const void *p1, const void *p2 ) +{ + const char *name = p1; + const struct __wine_debug_channel *chan = p2; + return strcmp( name, chan->name ); +} + +/* get the flags to use for a given channel, possibly setting them too in case of lazy init */ +unsigned char __wine_dbg_get_channel_flags( struct __wine_debug_channel *channel ) +{ + if (nb_debug_options == -1) debug_init(); + + if (nb_debug_options) + { + struct __wine_debug_channel *opt = bsearch( channel->name, debug_options, nb_debug_options, + sizeof(debug_options[0]), cmp_name ); + if (opt) return opt->flags; + } + /* no option for this channel */ + if (channel->flags & (1 << __WINE_DBCL_INIT)) channel->flags = default_flags; + return default_flags; +} + +/* set the flags to use for a given channel; return 0 if the channel is not available to set */ +int __wine_dbg_set_channel_flags( struct __wine_debug_channel *channel, + unsigned char set, unsigned char clear ) +{ + if (nb_debug_options == -1) debug_init(); + + if (nb_debug_options) + { + struct __wine_debug_channel *opt = bsearch( channel->name, debug_options, nb_debug_options, + sizeof(debug_options[0]), cmp_name ); + if (opt) + { + opt->flags = (opt->flags & ~clear) | set; + return 1; + } + } + return 0; +} + +/* add a new debug option at the end of the option list */ +static void add_option( const char *name, unsigned char set, unsigned char clear ) +{ + int min = 0, max = nb_debug_options - 1, pos, res; + + if (!name[0]) /* "all" option */ + { + default_flags = (default_flags & ~clear) | set; + return; + } + if (strlen(name) >= sizeof(debug_options[0].name)) return; + + while (min <= max) + { + pos = (min + max) / 2; + res = strcmp( name, debug_options[pos].name ); + if (!res) + { + debug_options[pos].flags = (debug_options[pos].flags & ~clear) | set; + return; + } + if (res < 0) max = pos - 1; + else min = pos + 1; + } + if (nb_debug_options >= MAX_DEBUG_OPTIONS) return; + + pos = min; + if (pos < nb_debug_options) memmove( &debug_options[pos + 1], &debug_options[pos], + (nb_debug_options - pos) * sizeof(debug_options[0]) ); + strcpy( debug_options[pos].name, name ); + debug_options[pos].flags = (default_flags & ~clear) | set; + nb_debug_options++; +} + +/* parse a set of debugging option specifications and add them to the option list */ +static void parse_options( const char *str ) +{ + char *opt, *next, *options; + unsigned int i; + + if (!(options = strdup(str))) return; + for (opt = options; opt; opt = next) + { + const char *p; + unsigned char set = 0, clear = 0; + + if ((next = strchr( opt, ',' ))) *next++ = 0; + + p = opt + strcspn( opt, "+-" ); + if (!p[0]) p = opt; /* assume it's a debug channel name */ + + if (p > opt) + { + for (i = 0; i < sizeof(debug_classes)/sizeof(debug_classes[0]); i++) + { + int len = strlen(debug_classes[i]); + if (len != (p - opt)) continue; + if (!memcmp( opt, debug_classes[i], len )) /* found it */ + { + if (*p == '+') set |= 1 << i; + else clear |= 1 << i; + break; + } + } + if (i == sizeof(debug_classes)/sizeof(debug_classes[0])) /* bad class name, skip it */ + continue; + } + else + { + if (*p == '-') clear = ~0; + else set = ~0; + } + if (*p == '+' || *p == '-') p++; + if (!p[0]) continue; + + if (!strcmp( p, "all" )) + default_flags = (default_flags & ~clear) | set; + else + add_option( p, set, clear ); + } + free( options ); +} + + +/* print the usage message */ +static void debug_usage(void) +{ + static const char usage[] = + "Syntax of the WINEDEBUG variable:\n" + " WINEDEBUG=[class]+xxx,[class]-yyy,...\n\n" + "Example: WINEDEBUG=+all,warn-heap\n" + " turns on all messages except warning heap messages\n" + "Available message classes: err, warn, fixme, trace\n"; + write( 2, usage, sizeof(usage) - 1 ); + exit(1); +} + +#ifndef VBOX_WITH_WDDM +static DECLCALLBACK(void) vbox_log_backdoor_rt(char* pcszStr) +{ + RTLogBackdoorPrintf("%s", pcszStr); +} +#else +static DECLCALLBACK(void) vbox_log_backdoor_dispmp(char* pcszStr) +{ + VBoxDispMpLoggerLog(pcszStr); +} +#endif +static void vbox_log_v(const char *pszFormat, va_list args) +{ + if (vbox_log_backdoor) + { + static char buf[8092]; + int offset = sprintf(buf, "[0x%lx.0x%lx] Wine Debug: ", GetCurrentProcessId(), GetCurrentThreadId()); + vsprintf(buf + offset, pszFormat, args); + vbox_log_backdoor(buf); + } +} + +/* initialize all options at startup */ +static void debug_init(void) +{ + char *wine_debug; + + if (nb_debug_options != -1) return; /* already initialized */ + nb_debug_options = 0; + if ((wine_debug = getenv("WINEDEBUG"))) + { + Assert(0); + if (!strcmp( wine_debug, "help" )) + debug_usage(); + else if (getenv("WINEDEBUG_BACKDOOR")) + { +#ifdef VBOX_WITH_WDDM + int rc = VBoxDispMpLoggerInit(); + if (RT_SUCCESS(rc)) + vbox_log_backdoor = vbox_log_backdoor_dispmp; +// else +#else + vbox_log_backdoor = vbox_log_backdoor_rt; +#endif + } + parse_options( wine_debug ); + } +} + +/* varargs wrapper for funcs.dbg_vprintf */ +int wine_dbg_printf( const char *format, ... ) +{ + int ret; + va_list valist; + + va_start(valist, format); + ret = funcs.dbg_vprintf( format, valist ); + va_end(valist); + return ret; +} + +/* printf with temp buffer allocation */ +const char *wine_dbg_sprintf( const char *format, ... ) +{ + static const int max_size = 200; + char *ret; + int len; + va_list valist; + + va_start(valist, format); + ret = funcs.get_temp_buffer( max_size ); + len = vsnprintf( ret, max_size, format, valist ); + if (len == -1 || len >= max_size) ret[max_size-1] = 0; + else funcs.release_temp_buffer( ret, len + 1 ); + va_end(valist); + return ret; +} + + +/* varargs wrapper for funcs.dbg_vlog */ +int wine_dbg_log( enum __wine_debug_class cls, struct __wine_debug_channel *channel, + const char *func, const char *format, ... ) +{ + int ret; + va_list valist; + + if (!(__wine_dbg_get_channel_flags( channel ) & (1 << cls))) return -1; + + va_start(valist, format); + ret = funcs.dbg_vlog( cls, channel, func, format, valist ); + va_end(valist); + return ret; +} + +int interlocked_xchg_add( int *dest, int incr ) +{ + return InterlockedExchangeAdd(dest, incr); +} + +/* allocate some tmp string space */ +/* FIXME: this is not 100% thread-safe */ +static char *get_temp_buffer( size_t size ) +{ + static char *list[32]; + static int pos; + char *ret; + int idx; + + idx = interlocked_xchg_add( &pos, 1 ) % (sizeof(list)/sizeof(list[0])); + if ((ret = realloc( list[idx], size ))) list[idx] = ret; + return ret; +} + + +/* release unused part of the buffer */ +static void release_temp_buffer( char *buffer, size_t size ) +{ + /* don't bother doing anything */ +} + + +/* default implementation of wine_dbgstr_an */ +static const char *default_dbgstr_an( const char *str, int n ) +{ + static const char hex[16] = "0123456789abcdef"; + char *dst, *res; + size_t size; + + if (!((ULONG_PTR)str >> 16)) + { + if (!str) return "(null)"; + res = funcs.get_temp_buffer( 6 ); + sprintf( res, "#%04x", LOWORD(str) ); + return res; + } + if (n == -1) n = strlen(str); + if (n < 0) n = 0; + size = 10 + min( 300, n * 4 ); + dst = res = funcs.get_temp_buffer( size ); + *dst++ = '"'; + while (n-- > 0 && dst <= res + size - 9) + { + unsigned char c = *str++; + switch (c) + { + case '\n': *dst++ = '\\'; *dst++ = 'n'; break; + case '\r': *dst++ = '\\'; *dst++ = 'r'; break; + case '\t': *dst++ = '\\'; *dst++ = 't'; break; + case '"': *dst++ = '\\'; *dst++ = '"'; break; + case '\\': *dst++ = '\\'; *dst++ = '\\'; break; + default: + if (c >= ' ' && c <= 126) + *dst++ = c; + else + { + *dst++ = '\\'; + *dst++ = 'x'; + *dst++ = hex[(c >> 4) & 0x0f]; + *dst++ = hex[c & 0x0f]; + } + } + } + *dst++ = '"'; + if (n > 0) + { + *dst++ = '.'; + *dst++ = '.'; + *dst++ = '.'; + } + *dst++ = 0; + funcs.release_temp_buffer( res, dst - res ); + return res; +} + + +/* default implementation of wine_dbgstr_wn */ +static const char *default_dbgstr_wn( const WCHAR *str, int n ) +{ + char *dst, *res; + size_t size; + + if (!((ULONG_PTR)str >> 16)) + { + if (!str) return "(null)"; + res = funcs.get_temp_buffer( 6 ); + sprintf( res, "#%04x", LOWORD(str) ); + return res; + } + if (n == -1) + { + const WCHAR *end = str; + while (*end) end++; + n = end - str; + } + if (n < 0) n = 0; + size = 12 + min( 300, n * 5 ); + dst = res = funcs.get_temp_buffer( size ); + *dst++ = 'L'; + *dst++ = '"'; + while (n-- > 0 && dst <= res + size - 10) + { + WCHAR c = *str++; + switch (c) + { + case '\n': *dst++ = '\\'; *dst++ = 'n'; break; + case '\r': *dst++ = '\\'; *dst++ = 'r'; break; + case '\t': *dst++ = '\\'; *dst++ = 't'; break; + case '"': *dst++ = '\\'; *dst++ = '"'; break; + case '\\': *dst++ = '\\'; *dst++ = '\\'; break; + default: + if (c >= ' ' && c <= 126) + *dst++ = c; + else + { + *dst++ = '\\'; + sprintf(dst,"%04x",c); + dst+=4; + } + } + } + *dst++ = '"'; + if (n > 0) + { + *dst++ = '.'; + *dst++ = '.'; + *dst++ = '.'; + } + *dst++ = 0; + funcs.release_temp_buffer( res, dst - res ); + return res; +} + + +/* default implementation of wine_dbg_vprintf */ +static int default_dbg_vprintf( const char *format, va_list args ) +{ + vbox_log_v(format, args); +#ifdef DEBUG_leo + static FILE *output=NULL; + static int first_time = 1; + + if (first_time) + { + first_time = 0; + output = fopen( "winelog.txt", "w" ); + } + + if (output) vfprintf( output, format, args ); +#endif + return vfprintf( stdout, format, args ); +} + + +/* default implementation of wine_dbg_vlog */ +static int default_dbg_vlog( enum __wine_debug_class cls, struct __wine_debug_channel *channel, + const char *func, const char *format, va_list args ) +{ + int ret = 0; + + if (cls < sizeof(debug_classes)/sizeof(debug_classes[0])) + ret += wine_dbg_printf( "%s:[%#x]:%s:%s ", debug_classes[cls], GetCurrentThreadId(), channel->name, func ); + if (format) + ret += funcs.dbg_vprintf( format, args ); + return ret; +} + +/* wrappers to use the function pointers */ + +const char *wine_dbgstr_an( const char * s, int n ) +{ + return funcs.dbgstr_an(s, n); +} + +const char *wine_dbgstr_wn( const WCHAR *s, int n ) +{ + return funcs.dbgstr_wn(s, n); +} + +void __wine_dbg_set_functions( const struct __wine_debug_functions *new_funcs, + struct __wine_debug_functions *old_funcs, size_t size ) +{ + if (old_funcs) memcpy( old_funcs, &funcs, min(sizeof(funcs),size) ); + if (new_funcs) memcpy( &funcs, new_funcs, min(sizeof(funcs),size) ); +} + +static struct __wine_debug_functions funcs = +{ + get_temp_buffer, + release_temp_buffer, + default_dbgstr_an, + default_dbgstr_wn, + default_dbg_vprintf, + default_dbg_vlog +}; Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/vbox/libWineStub/include/config.h =================================================================== --- /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/vbox/libWineStub/include/config.h (revision 46521) +++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/vbox/libWineStub/include/config.h (revision 46521) @@ -0,0 +1,1275 @@ +/* include/config.h. Generated from config.h.in by configure. */ +/* include/config.h.in. Generated from configure.ac by autoheader. */ + +#include + +#define __WINE_CONFIG_H + +/* Define to a function attribute for Microsoft hotpatch assembly prefix. */ +#define DECLSPEC_HOTPATCH /* */ + +/* Define to the file extension for executables. */ +#define EXEEXT ".exe" + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_ALIAS_H */ + +/* Define if you have ALSA 1.x including devel headers */ +/* #undef HAVE_ALSA */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_ALSA_ASOUNDLIB_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_AL_AL_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_ARPA_INET_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_ARPA_NAMESER_H */ + +/* Define to 1 if you have the `asctime_r' function. */ +#define HAVE_ASCTIME_R 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_ASM_TYPES_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_AUDIOUNIT_AUDIOUNIT_H */ + +/* Define to 1 if you have the