From fc63f9adeeda6909f129d1a8cefea456a0a4b399 Mon Sep 17 00:00:00 2001 From: Magnus Olsen Date: Sun, 25 Nov 2007 12:13:33 +0000 Subject: [PATCH] import wine directx d3d9 version 0.9.49 svn path=/trunk/; revision=30732 --- reactos/dll/directx/wine/d3d9/Makefile.in | 34 + reactos/dll/directx/wine/d3d9/basetexture.c | 172 ++ reactos/dll/directx/wine/d3d9/cubetexture.c | 376 +++++ reactos/dll/directx/wine/d3d9/d3d9.rbuild | 44 + reactos/dll/directx/wine/d3d9/d3d9.spec | 10 + reactos/dll/directx/wine/d3d9/d3d9_main.c | 131 ++ reactos/dll/directx/wine/d3d9/d3d9_private.h | 586 +++++++ reactos/dll/directx/wine/d3d9/device.c | 1493 +++++++++++++++++ reactos/dll/directx/wine/d3d9/directx.c | 566 +++++++ reactos/dll/directx/wine/d3d9/indexbuffer.c | 246 +++ reactos/dll/directx/wine/d3d9/pixelshader.c | 244 +++ reactos/dll/directx/wine/d3d9/query.c | 189 +++ reactos/dll/directx/wine/d3d9/resource.c | 135 ++ reactos/dll/directx/wine/d3d9/stateblock.c | 193 +++ reactos/dll/directx/wine/d3d9/surface.c | 292 ++++ reactos/dll/directx/wine/d3d9/swapchain.c | 291 ++++ reactos/dll/directx/wine/d3d9/texture.c | 366 ++++ reactos/dll/directx/wine/d3d9/version.rc | 26 + reactos/dll/directx/wine/d3d9/vertexbuffer.c | 243 +++ .../dll/directx/wine/d3d9/vertexdeclaration.c | 419 +++++ reactos/dll/directx/wine/d3d9/vertexshader.c | 243 +++ reactos/dll/directx/wine/d3d9/volume.c | 224 +++ reactos/dll/directx/wine/d3d9/volumetexture.c | 279 +++ reactos/dll/directx/wine/wine.rbuild | 3 + 24 files changed, 6805 insertions(+) create mode 100644 reactos/dll/directx/wine/d3d9/Makefile.in create mode 100644 reactos/dll/directx/wine/d3d9/basetexture.c create mode 100644 reactos/dll/directx/wine/d3d9/cubetexture.c create mode 100644 reactos/dll/directx/wine/d3d9/d3d9.rbuild create mode 100644 reactos/dll/directx/wine/d3d9/d3d9.spec create mode 100644 reactos/dll/directx/wine/d3d9/d3d9_main.c create mode 100644 reactos/dll/directx/wine/d3d9/d3d9_private.h create mode 100644 reactos/dll/directx/wine/d3d9/device.c create mode 100644 reactos/dll/directx/wine/d3d9/directx.c create mode 100644 reactos/dll/directx/wine/d3d9/indexbuffer.c create mode 100644 reactos/dll/directx/wine/d3d9/pixelshader.c create mode 100644 reactos/dll/directx/wine/d3d9/query.c create mode 100644 reactos/dll/directx/wine/d3d9/resource.c create mode 100644 reactos/dll/directx/wine/d3d9/stateblock.c create mode 100644 reactos/dll/directx/wine/d3d9/surface.c create mode 100644 reactos/dll/directx/wine/d3d9/swapchain.c create mode 100644 reactos/dll/directx/wine/d3d9/texture.c create mode 100644 reactos/dll/directx/wine/d3d9/version.rc create mode 100644 reactos/dll/directx/wine/d3d9/vertexbuffer.c create mode 100644 reactos/dll/directx/wine/d3d9/vertexdeclaration.c create mode 100644 reactos/dll/directx/wine/d3d9/vertexshader.c create mode 100644 reactos/dll/directx/wine/d3d9/volume.c create mode 100644 reactos/dll/directx/wine/d3d9/volumetexture.c diff --git a/reactos/dll/directx/wine/d3d9/Makefile.in b/reactos/dll/directx/wine/d3d9/Makefile.in new file mode 100644 index 00000000000..904dda9923c --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/Makefile.in @@ -0,0 +1,34 @@ +TOPSRCDIR = @top_srcdir@ +TOPOBJDIR = ../.. +SRCDIR = @srcdir@ +VPATH = @srcdir@ +MODULE = d3d9.dll +IMPORTLIB = libd3d9.$(IMPLIBEXT) +IMPORTS = wined3d user32 gdi32 kernel32 +EXTRALIBS = -ldxguid -luuid + +C_SRCS = \ + basetexture.c \ + cubetexture.c \ + d3d9_main.c \ + device.c \ + directx.c \ + indexbuffer.c \ + pixelshader.c \ + query.c \ + resource.c \ + stateblock.c \ + surface.c \ + swapchain.c \ + texture.c \ + vertexbuffer.c \ + vertexdeclaration.c \ + vertexshader.c \ + volume.c \ + volumetexture.c + +RC_SRCS = version.rc + +@MAKE_DLL_RULES@ + +@DEPENDENCIES@ # everything below this line is overwritten by make depend diff --git a/reactos/dll/directx/wine/d3d9/basetexture.c b/reactos/dll/directx/wine/d3d9/basetexture.c new file mode 100644 index 00000000000..f80eb78ae74 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/basetexture.c @@ -0,0 +1,172 @@ +/* + * IDirect3DBaseTexture9 implementation + * + * Copyright 2002-2004 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); + +/* IDirect3DBaseTexture9 IUnknown parts follow: */ +static HRESULT WINAPI IDirect3DBaseTexture9Impl_QueryInterface(LPDIRECT3DBASETEXTURE9 iface, REFIID riid, LPVOID* ppobj) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + TRACE("(%p) Relay\n" , This); + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3DBaseTexture9Impl_AddRef(LPDIRECT3DBASETEXTURE9 iface) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + + return ref; +} + +static ULONG WINAPI IDirect3DBaseTexture9Impl_Release(LPDIRECT3DBASETEXTURE9 iface) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + ULONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + IWineD3DBaseTexture_Release(This->wineD3DBaseTexture); + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DBaseTexture9 IDirect3DResource9 Interface follow: */ +static HRESULT WINAPI IDirect3DBaseTexture9Impl_GetDevice(LPDIRECT3DBASETEXTURE9 iface, IDirect3DDevice9** ppDevice) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + TRACE("(%p) Relay\n" , This); + return IDirect3DResource9Impl_GetDevice((LPDIRECT3DRESOURCE9) This, ppDevice); +} + +static HRESULT WINAPI IDirect3DBaseTexture9Impl_SetPrivateData(LPDIRECT3DBASETEXTURE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + TRACE("(%p) Relay\n" , This); + return IWineD3DBaseTexture_SetPrivateData(This->wineD3DBaseTexture, refguid, pData, SizeOfData, Flags); +} + +static HRESULT WINAPI IDirect3DBaseTexture9Impl_GetPrivateData(LPDIRECT3DBASETEXTURE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + TRACE("(%p) Relay\n" , This); + return IWineD3DBaseTexture_GetPrivateData(This->wineD3DBaseTexture, refguid, pData, pSizeOfData); +} + +static HRESULT WINAPI IDirect3DBaseTexture9Impl_FreePrivateData(LPDIRECT3DBASETEXTURE9 iface, REFGUID refguid) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + TRACE("(%p) Relay\n" , This); + return IWineD3DBaseTexture_FreePrivateData(This->wineD3DBaseTexture, refguid); +} + +static DWORD WINAPI IDirect3DBaseTexture9Impl_SetPriority(LPDIRECT3DBASETEXTURE9 iface, DWORD PriorityNew) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + TRACE("(%p) Relay\n" , This); + return IWineD3DBaseTexture_SetPriority(This->wineD3DBaseTexture, PriorityNew); +} + +static DWORD WINAPI IDirect3DBaseTexture9Impl_GetPriority(LPDIRECT3DBASETEXTURE9 iface) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + TRACE("(%p) Relay\n" , This); + return IWineD3DBaseTexture_GetPriority(This->wineD3DBaseTexture); +} + +static void WINAPI IDirect3DBaseTexture9Impl_PreLoad(LPDIRECT3DBASETEXTURE9 iface) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + TRACE("(%p) Relay\n" , This); + IWineD3DBaseTexture_PreLoad(This->wineD3DBaseTexture); + return ; +} + +static D3DRESOURCETYPE WINAPI IDirect3DBaseTexture9Impl_GetType(LPDIRECT3DBASETEXTURE9 iface) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + TRACE("(%p) Relay\n" , This); + return IWineD3DBaseTexture_GetType(This->wineD3DBaseTexture); +} + +/* IDirect3DBaseTexture9 Interface follow: */ +static DWORD WINAPI IDirect3DBaseTexture9Impl_SetLOD(LPDIRECT3DBASETEXTURE9 iface, DWORD LODNew) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + TRACE("(%p) Relay\n" , This); + return IWineD3DBaseTexture_SetLOD(This->wineD3DBaseTexture, LODNew); +} + +DWORD WINAPI IDirect3DBaseTexture9Impl_GetLOD(LPDIRECT3DBASETEXTURE9 iface) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + TRACE("(%p) Relay\n" , This); + return IWineD3DBaseTexture_GetLOD(This->wineD3DBaseTexture); +} + +static DWORD WINAPI IDirect3DBaseTexture9Impl_GetLevelCount(LPDIRECT3DBASETEXTURE9 iface) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + TRACE("(%p) Relay\n" , This); + return IWineD3DBaseTexture_GetLevelCount(This->wineD3DBaseTexture); +} + +static HRESULT WINAPI IDirect3DBaseTexture9Impl_SetAutoGenFilterType(LPDIRECT3DBASETEXTURE9 iface, D3DTEXTUREFILTERTYPE FilterType) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + TRACE("(%p) Relay\n" , This); + return IWineD3DBaseTexture_SetAutoGenFilterType(This->wineD3DBaseTexture, (WINED3DTEXTUREFILTERTYPE) FilterType); +} + +static D3DTEXTUREFILTERTYPE WINAPI IDirect3DBaseTexture9Impl_GetAutoGenFilterType(LPDIRECT3DBASETEXTURE9 iface) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + TRACE("(%p) Relay\n" , This); + return (D3DTEXTUREFILTERTYPE) IWineD3DBaseTexture_GetAutoGenFilterType(This->wineD3DBaseTexture); +} + +static void WINAPI IDirect3DBaseTexture9Impl_GenerateMipSubLevels(LPDIRECT3DBASETEXTURE9 iface) { + IDirect3DBaseTexture9Impl *This = (IDirect3DBaseTexture9Impl *)iface; + TRACE("(%p) Relay\n" , This); + IWineD3DBaseTexture_GenerateMipSubLevels(This->wineD3DBaseTexture); +} + +const IDirect3DBaseTexture9Vtbl Direct3DBaseTexture9_Vtbl = +{ + IDirect3DBaseTexture9Impl_QueryInterface, + IDirect3DBaseTexture9Impl_AddRef, + IDirect3DBaseTexture9Impl_Release, + IDirect3DBaseTexture9Impl_GetDevice, + IDirect3DBaseTexture9Impl_SetPrivateData, + IDirect3DBaseTexture9Impl_GetPrivateData, + IDirect3DBaseTexture9Impl_FreePrivateData, + IDirect3DBaseTexture9Impl_SetPriority, + IDirect3DBaseTexture9Impl_GetPriority, + IDirect3DBaseTexture9Impl_PreLoad, + IDirect3DBaseTexture9Impl_GetType, + IDirect3DBaseTexture9Impl_SetLOD, + IDirect3DBaseTexture9Impl_GetLOD, + IDirect3DBaseTexture9Impl_GetLevelCount, + IDirect3DBaseTexture9Impl_SetAutoGenFilterType, + IDirect3DBaseTexture9Impl_GetAutoGenFilterType, + IDirect3DBaseTexture9Impl_GenerateMipSubLevels +}; diff --git a/reactos/dll/directx/wine/d3d9/cubetexture.c b/reactos/dll/directx/wine/d3d9/cubetexture.c new file mode 100644 index 00000000000..0ea378bc29d --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/cubetexture.c @@ -0,0 +1,376 @@ +/* + * IDirect3DCubeTexture9 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" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d9); + + +/* IDirect3DCubeTexture9 IUnknown parts follow: */ +static HRESULT WINAPI IDirect3DCubeTexture9Impl_QueryInterface(LPDIRECT3DCUBETEXTURE9 iface, REFIID riid, LPVOID* ppobj) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9) + || IsEqualGUID(riid, &IID_IDirect3DCubeTexture9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3DCubeTexture9Impl_AddRef(LPDIRECT3DCUBETEXTURE9 iface) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + + return ref; +} + +static ULONG WINAPI IDirect3DCubeTexture9Impl_Release(LPDIRECT3DCUBETEXTURE9 iface) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + ULONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + TRACE("Releasing child %p\n", This->wineD3DCubeTexture); + + EnterCriticalSection(&d3d9_cs); + IWineD3DCubeTexture_Destroy(This->wineD3DCubeTexture, D3D9CB_DestroySurface); + IUnknown_Release(This->parentDevice); + LeaveCriticalSection(&d3d9_cs); + + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DCubeTexture9 IDirect3DResource9 Interface follow: */ +static HRESULT WINAPI IDirect3DCubeTexture9Impl_GetDevice(LPDIRECT3DCUBETEXTURE9 iface, IDirect3DDevice9** ppDevice) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IDirect3DResource9Impl_GetDevice((LPDIRECT3DRESOURCE9) This, ppDevice); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DCubeTexture9Impl_SetPrivateData(LPDIRECT3DCUBETEXTURE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DCubeTexture_SetPrivateData(This->wineD3DCubeTexture,refguid,pData,SizeOfData,Flags); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DCubeTexture9Impl_GetPrivateData(LPDIRECT3DCUBETEXTURE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DCubeTexture_GetPrivateData(This->wineD3DCubeTexture,refguid,pData,pSizeOfData); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DCubeTexture9Impl_FreePrivateData(LPDIRECT3DCUBETEXTURE9 iface, REFGUID refguid) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DCubeTexture_FreePrivateData(This->wineD3DCubeTexture,refguid); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static DWORD WINAPI IDirect3DCubeTexture9Impl_SetPriority(LPDIRECT3DCUBETEXTURE9 iface, DWORD PriorityNew) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + DWORD ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DCubeTexture_SetPriority(This->wineD3DCubeTexture, PriorityNew); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +static DWORD WINAPI IDirect3DCubeTexture9Impl_GetPriority(LPDIRECT3DCUBETEXTURE9 iface) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + DWORD ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DCubeTexture_GetPriority(This->wineD3DCubeTexture); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +static void WINAPI IDirect3DCubeTexture9Impl_PreLoad(LPDIRECT3DCUBETEXTURE9 iface) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + IWineD3DCubeTexture_PreLoad(This->wineD3DCubeTexture); + LeaveCriticalSection(&d3d9_cs); +} + +static D3DRESOURCETYPE WINAPI IDirect3DCubeTexture9Impl_GetType(LPDIRECT3DCUBETEXTURE9 iface) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + D3DRESOURCETYPE ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DCubeTexture_GetType(This->wineD3DCubeTexture); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +/* IDirect3DCubeTexture9 IDirect3DBaseTexture9 Interface follow: */ +static DWORD WINAPI IDirect3DCubeTexture9Impl_SetLOD(LPDIRECT3DCUBETEXTURE9 iface, DWORD LODNew) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + DWORD ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DCubeTexture_SetLOD(This->wineD3DCubeTexture, LODNew); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +static DWORD WINAPI IDirect3DCubeTexture9Impl_GetLOD(LPDIRECT3DCUBETEXTURE9 iface) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + DWORD ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IDirect3DBaseTexture9Impl_GetLOD((LPDIRECT3DBASETEXTURE9) This); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +static DWORD WINAPI IDirect3DCubeTexture9Impl_GetLevelCount(LPDIRECT3DCUBETEXTURE9 iface) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + DWORD ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DCubeTexture_GetLevelCount(This->wineD3DCubeTexture); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +static HRESULT WINAPI IDirect3DCubeTexture9Impl_SetAutoGenFilterType(LPDIRECT3DCUBETEXTURE9 iface, D3DTEXTUREFILTERTYPE FilterType) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DCubeTexture_SetAutoGenFilterType(This->wineD3DCubeTexture, (WINED3DTEXTUREFILTERTYPE) FilterType); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static D3DTEXTUREFILTERTYPE WINAPI IDirect3DCubeTexture9Impl_GetAutoGenFilterType(LPDIRECT3DCUBETEXTURE9 iface) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + D3DTEXTUREFILTERTYPE ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = (D3DTEXTUREFILTERTYPE) IWineD3DCubeTexture_GetAutoGenFilterType(This->wineD3DCubeTexture); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +static void WINAPI IDirect3DCubeTexture9Impl_GenerateMipSubLevels(LPDIRECT3DCUBETEXTURE9 iface) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + IWineD3DCubeTexture_GenerateMipSubLevels(This->wineD3DCubeTexture); + LeaveCriticalSection(&d3d9_cs); +} + +/* IDirect3DCubeTexture9 Interface follow: */ +static HRESULT WINAPI IDirect3DCubeTexture9Impl_GetLevelDesc(LPDIRECT3DCUBETEXTURE9 iface, UINT Level, D3DSURFACE_DESC* pDesc) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + WINED3DSURFACE_DESC wined3ddesc; + UINT tmpInt = -1; + HRESULT hr; + + TRACE("(%p) Relay\n", This); + + /* As d3d8 and d3d9 structures differ, pass in ptrs to where data needs to go */ + wined3ddesc.Format = (WINED3DFORMAT *)&pDesc->Format; + wined3ddesc.Type = (WINED3DRESOURCETYPE *) &pDesc->Type; + wined3ddesc.Usage = &pDesc->Usage; + wined3ddesc.Pool = (WINED3DPOOL *) &pDesc->Pool; + wined3ddesc.Size = &tmpInt; + wined3ddesc.MultiSampleType = (WINED3DMULTISAMPLE_TYPE *) &pDesc->MultiSampleType; + wined3ddesc.MultiSampleQuality = &pDesc->MultiSampleQuality; + wined3ddesc.Width = &pDesc->Width; + wined3ddesc.Height = &pDesc->Height; + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DCubeTexture_GetLevelDesc(This->wineD3DCubeTexture, Level, &wined3ddesc); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DCubeTexture9Impl_GetCubeMapSurface(LPDIRECT3DCUBETEXTURE9 iface, D3DCUBEMAP_FACES FaceType, UINT Level, IDirect3DSurface9** ppCubeMapSurface) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + HRESULT hrc = D3D_OK; + IWineD3DSurface *mySurface = NULL; + + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hrc = IWineD3DCubeTexture_GetCubeMapSurface(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES) FaceType, Level, &mySurface); + if (hrc == D3D_OK && NULL != ppCubeMapSurface) { + IWineD3DCubeTexture_GetParent(mySurface, (IUnknown **)ppCubeMapSurface); + IWineD3DCubeTexture_Release(mySurface); + } + LeaveCriticalSection(&d3d9_cs); + return hrc; +} + +static HRESULT WINAPI IDirect3DCubeTexture9Impl_LockRect(LPDIRECT3DCUBETEXTURE9 iface, D3DCUBEMAP_FACES FaceType, UINT Level, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DCubeTexture_LockRect(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES) FaceType, Level, (WINED3DLOCKED_RECT *) pLockedRect, pRect, Flags); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DCubeTexture9Impl_UnlockRect(LPDIRECT3DCUBETEXTURE9 iface, D3DCUBEMAP_FACES FaceType, UINT Level) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DCubeTexture_UnlockRect(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES) FaceType, Level); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DCubeTexture9Impl_AddDirtyRect(LPDIRECT3DCUBETEXTURE9 iface, D3DCUBEMAP_FACES FaceType, CONST RECT* pDirtyRect) { + IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DCubeTexture_AddDirtyRect(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES) FaceType, pDirtyRect); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + + +static const IDirect3DCubeTexture9Vtbl Direct3DCubeTexture9_Vtbl = +{ + /* IUnknown */ + IDirect3DCubeTexture9Impl_QueryInterface, + IDirect3DCubeTexture9Impl_AddRef, + IDirect3DCubeTexture9Impl_Release, + /* IDirect3DResource9 */ + IDirect3DCubeTexture9Impl_GetDevice, + IDirect3DCubeTexture9Impl_SetPrivateData, + IDirect3DCubeTexture9Impl_GetPrivateData, + IDirect3DCubeTexture9Impl_FreePrivateData, + IDirect3DCubeTexture9Impl_SetPriority, + IDirect3DCubeTexture9Impl_GetPriority, + IDirect3DCubeTexture9Impl_PreLoad, + IDirect3DCubeTexture9Impl_GetType, + /* IDirect3DBaseTexture9 */ + IDirect3DCubeTexture9Impl_SetLOD, + IDirect3DCubeTexture9Impl_GetLOD, + IDirect3DCubeTexture9Impl_GetLevelCount, + IDirect3DCubeTexture9Impl_SetAutoGenFilterType, + IDirect3DCubeTexture9Impl_GetAutoGenFilterType, + IDirect3DCubeTexture9Impl_GenerateMipSubLevels, + IDirect3DCubeTexture9Impl_GetLevelDesc, + IDirect3DCubeTexture9Impl_GetCubeMapSurface, + IDirect3DCubeTexture9Impl_LockRect, + IDirect3DCubeTexture9Impl_UnlockRect, + IDirect3DCubeTexture9Impl_AddDirtyRect +}; + + + + +/* IDirect3DDevice9 IDirect3DCubeTexture9 Methods follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_CreateCubeTexture(LPDIRECT3DDEVICE9 iface, + UINT EdgeLength, UINT Levels, DWORD Usage, + D3DFORMAT Format, D3DPOOL Pool, + IDirect3DCubeTexture9** ppCubeTexture, HANDLE* pSharedHandle) { + + IDirect3DCubeTexture9Impl *object; + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr = D3D_OK; + + TRACE("(%p) : ELen(%d) Lvl(%d) Usage(%d) fmt(%u), Pool(%d) Shared(%p)\n", This, EdgeLength, Levels, Usage, Format, Pool, pSharedHandle); + + /* Allocate the storage for the device */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + + if (NULL == object) { + FIXME("(%p) allocation of CubeTexture failed\n", This); + return D3DERR_OUTOFVIDEOMEMORY; + } + object->lpVtbl = &Direct3DCubeTexture9_Vtbl; + object->ref = 1; + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_CreateCubeTexture(This->WineD3DDevice, EdgeLength, Levels, Usage, + (WINED3DFORMAT)Format, (WINED3DPOOL) Pool, &object->wineD3DCubeTexture, pSharedHandle, (IUnknown*)object, + D3D9CB_CreateSurface); + LeaveCriticalSection(&d3d9_cs); + + if (hr != D3D_OK){ + + /* free up object */ + FIXME("(%p) call to IWineD3DDevice_CreateCubeTexture failed\n", This); + HeapFree(GetProcessHeap(), 0, object); + } else { + IUnknown_AddRef(iface); + object->parentDevice = iface; + *ppCubeTexture = (LPDIRECT3DCUBETEXTURE9) object; + TRACE("(%p) : Created cube texture %p\n", This, object); + } + + TRACE("(%p) returning %p\n",This, *ppCubeTexture); + return hr; +} diff --git a/reactos/dll/directx/wine/d3d9/d3d9.rbuild b/reactos/dll/directx/wine/d3d9/d3d9.rbuild new file mode 100644 index 00000000000..60325e3a5ff --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/d3d9.rbuild @@ -0,0 +1,44 @@ + + + + + . + include/reactos/wine + + + 0x600 + 0x501 + 0x501 + + + + uuid + wine + user32 + opengl32 + gdi32 + advapi32 + kernel32 + wined3d + + basetexture.c + cubetexture.c + d3d9_main.c + device.c + directx.c + indexbuffer.c + pixelshader.c + query.c + resource.c + stateblock.c + surface.c + swapchain.c + texture.c + vertexbuffer.c + vertexdeclaration.c + vertexshader.c + volume.c + volumetexture.c + version.rc + d3d9.spec + diff --git a/reactos/dll/directx/wine/d3d9/d3d9.spec b/reactos/dll/directx/wine/d3d9/d3d9.spec new file mode 100644 index 00000000000..949f03fb09b --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/d3d9.spec @@ -0,0 +1,10 @@ +@ stdcall D3D9GetSWInfo() +@ stdcall DebugSetMute() +@ stdcall Direct3DCreate9(long) +@ stdcall D3DPERF_BeginEvent(long wstr) +@ stdcall D3DPERF_EndEvent() +@ stdcall D3DPERF_GetStatus() +@ stdcall D3DPERF_SetOptions(long) +@ stdcall D3DPERF_QueryRepeatFrame() +@ stdcall D3DPERF_SetMarker(long wstr) +@ stdcall D3DPERF_SetRegion(long wstr) diff --git a/reactos/dll/directx/wine/d3d9/d3d9_main.c b/reactos/dll/directx/wine/d3d9/d3d9_main.c new file mode 100644 index 00000000000..ba4da662aa4 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/d3d9_main.c @@ -0,0 +1,131 @@ +/* + * 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" + +static CRITICAL_SECTION_DEBUG d3d9_cs_debug = +{ + 0, 0, &d3d9_cs, + { &d3d9_cs_debug.ProcessLocksList, + &d3d9_cs_debug.ProcessLocksList }, + 0, 0, { (DWORD_PTR)(__FILE__ ": d3d9_cs") } +}; +CRITICAL_SECTION d3d9_cs = { &d3d9_cs_debug, -1, 0, 0, 0, 0 }; + +WINE_DEFAULT_DEBUG_CHANNEL(d3d9); + +static int D3DPERF_event_level = 0; + +HRESULT WINAPI D3D9GetSWInfo(void) { + FIXME("(void): stub\n"); + return 0; +} + +void WINAPI DebugSetMute(void) { + /* nothing to do */ +} + +IDirect3D9* WINAPI Direct3DCreate9(UINT SDKVersion) { + IDirect3D9Impl* object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3D9Impl)); + + object->lpVtbl = &Direct3D9_Vtbl; + object->ref = 1; + EnterCriticalSection(&d3d9_cs); + object->WineD3D = WineDirect3DCreate(SDKVersion, 9, (IUnknown *)object); + LeaveCriticalSection(&d3d9_cs); + + TRACE("SDKVersion = %x, Created Direct3D object @ %p, WineObj @ %p\n", SDKVersion, object, object->WineD3D); + + return (IDirect3D9*) object; +} + +/* 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; +} + +/*********************************************************************** + * D3DPERF_BeginEvent (D3D9.@) + */ +int WINAPI D3DPERF_BeginEvent(D3DCOLOR color, LPCWSTR name) { + FIXME("(color %#x, name %s) : stub\n", color, debugstr_w(name)); + + return D3DPERF_event_level++; +} + +/*********************************************************************** + * D3DPERF_EndEvent (D3D9.@) + */ +int WINAPI D3DPERF_EndEvent(void) { + FIXME("(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)); +} diff --git a/reactos/dll/directx/wine/d3d9/d3d9_private.h b/reactos/dll/directx/wine/d3d9/d3d9_private.h new file mode 100644 index 00000000000..160cb673999 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/d3d9_private.h @@ -0,0 +1,586 @@ +/* + * 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 + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#define COBJMACROS +#include "windef.h" +#include "winbase.h" +#include "wingdi.h" +#include "winuser.h" +#include "wine/debug.h" +#include "wine/unicode.h" + +#include "d3d9.h" +#include "wine/wined3d_interface.h" + +/* =========================================================================== + Internal use + =========================================================================== */ +extern HRESULT vdecl_convert_fvf( + DWORD FVF, + D3DVERTEXELEMENT9** ppVertexElements); +extern CRITICAL_SECTION d3d9_cs; + +/* =========================================================================== + Macros + =========================================================================== */ +/* Not nice, but it lets wined3d support different versions of directx */ +#define D3D9CAPSTOWINECAPS(_pD3D9Caps, _pWineCaps) \ + _pWineCaps->DeviceType = (WINED3DDEVTYPE *) &_pD3D9Caps->DeviceType; \ + _pWineCaps->AdapterOrdinal = &_pD3D9Caps->AdapterOrdinal; \ + _pWineCaps->Caps = &_pD3D9Caps->Caps; \ + _pWineCaps->Caps2 = &_pD3D9Caps->Caps2; \ + _pWineCaps->Caps3 = &_pD3D9Caps->Caps3; \ + _pWineCaps->PresentationIntervals = &_pD3D9Caps->PresentationIntervals; \ + _pWineCaps->CursorCaps = &_pD3D9Caps->CursorCaps; \ + _pWineCaps->DevCaps = &_pD3D9Caps->DevCaps; \ + _pWineCaps->PrimitiveMiscCaps = &_pD3D9Caps->PrimitiveMiscCaps; \ + _pWineCaps->RasterCaps = &_pD3D9Caps->RasterCaps; \ + _pWineCaps->ZCmpCaps = &_pD3D9Caps->ZCmpCaps; \ + _pWineCaps->SrcBlendCaps = &_pD3D9Caps->SrcBlendCaps; \ + _pWineCaps->DestBlendCaps = &_pD3D9Caps->DestBlendCaps; \ + _pWineCaps->AlphaCmpCaps = &_pD3D9Caps->AlphaCmpCaps; \ + _pWineCaps->ShadeCaps = &_pD3D9Caps->ShadeCaps; \ + _pWineCaps->TextureCaps = &_pD3D9Caps->TextureCaps; \ + _pWineCaps->TextureFilterCaps = &_pD3D9Caps->TextureFilterCaps; \ + _pWineCaps->CubeTextureFilterCaps = &_pD3D9Caps->CubeTextureFilterCaps; \ + _pWineCaps->VolumeTextureFilterCaps = &_pD3D9Caps->VolumeTextureFilterCaps; \ + _pWineCaps->TextureAddressCaps = &_pD3D9Caps->TextureAddressCaps; \ + _pWineCaps->VolumeTextureAddressCaps = &_pD3D9Caps->VolumeTextureAddressCaps; \ + _pWineCaps->LineCaps = &_pD3D9Caps->LineCaps; \ + _pWineCaps->MaxTextureWidth = &_pD3D9Caps->MaxTextureWidth; \ + _pWineCaps->MaxTextureHeight = &_pD3D9Caps->MaxTextureHeight; \ + _pWineCaps->MaxVolumeExtent = &_pD3D9Caps->MaxVolumeExtent; \ + _pWineCaps->MaxTextureRepeat = &_pD3D9Caps->MaxTextureRepeat; \ + _pWineCaps->MaxTextureAspectRatio = &_pD3D9Caps->MaxTextureAspectRatio; \ + _pWineCaps->MaxAnisotropy = &_pD3D9Caps->MaxAnisotropy; \ + _pWineCaps->MaxVertexW = &_pD3D9Caps->MaxVertexW; \ + _pWineCaps->GuardBandLeft = &_pD3D9Caps->GuardBandLeft; \ + _pWineCaps->GuardBandTop = &_pD3D9Caps->GuardBandTop; \ + _pWineCaps->GuardBandRight = &_pD3D9Caps->GuardBandRight; \ + _pWineCaps->GuardBandBottom = &_pD3D9Caps->GuardBandBottom; \ + _pWineCaps->ExtentsAdjust = &_pD3D9Caps->ExtentsAdjust; \ + _pWineCaps->StencilCaps = &_pD3D9Caps->StencilCaps; \ + _pWineCaps->FVFCaps = &_pD3D9Caps->FVFCaps; \ + _pWineCaps->TextureOpCaps = &_pD3D9Caps->TextureOpCaps; \ + _pWineCaps->MaxTextureBlendStages = &_pD3D9Caps->MaxTextureBlendStages; \ + _pWineCaps->MaxSimultaneousTextures = &_pD3D9Caps->MaxSimultaneousTextures; \ + _pWineCaps->VertexProcessingCaps = &_pD3D9Caps->VertexProcessingCaps; \ + _pWineCaps->MaxActiveLights = &_pD3D9Caps->MaxActiveLights; \ + _pWineCaps->MaxUserClipPlanes = &_pD3D9Caps->MaxUserClipPlanes; \ + _pWineCaps->MaxVertexBlendMatrices = &_pD3D9Caps->MaxVertexBlendMatrices; \ + _pWineCaps->MaxVertexBlendMatrixIndex = &_pD3D9Caps->MaxVertexBlendMatrixIndex; \ + _pWineCaps->MaxPointSize = &_pD3D9Caps->MaxPointSize; \ + _pWineCaps->MaxPrimitiveCount = &_pD3D9Caps->MaxPrimitiveCount; \ + _pWineCaps->MaxVertexIndex = &_pD3D9Caps->MaxVertexIndex; \ + _pWineCaps->MaxStreams = &_pD3D9Caps->MaxStreams; \ + _pWineCaps->MaxStreamStride = &_pD3D9Caps->MaxStreamStride; \ + _pWineCaps->VertexShaderVersion = &_pD3D9Caps->VertexShaderVersion; \ + _pWineCaps->MaxVertexShaderConst = &_pD3D9Caps->MaxVertexShaderConst; \ + _pWineCaps->PixelShaderVersion = &_pD3D9Caps->PixelShaderVersion; \ + _pWineCaps->PixelShader1xMaxValue = &_pD3D9Caps->PixelShader1xMaxValue; \ + _pWineCaps->DevCaps2 = &_pD3D9Caps->DevCaps2; \ + _pWineCaps->MaxNpatchTessellationLevel = &_pD3D9Caps->MaxNpatchTessellationLevel; \ + _pWineCaps->MasterAdapterOrdinal = &_pD3D9Caps->MasterAdapterOrdinal; \ + _pWineCaps->AdapterOrdinalInGroup = &_pD3D9Caps->AdapterOrdinalInGroup; \ + _pWineCaps->NumberOfAdaptersInGroup = &_pD3D9Caps->NumberOfAdaptersInGroup; \ + _pWineCaps->DeclTypes = &_pD3D9Caps->DeclTypes; \ + _pWineCaps->NumSimultaneousRTs = &_pD3D9Caps->NumSimultaneousRTs; \ + _pWineCaps->StretchRectFilterCaps = &_pD3D9Caps->StretchRectFilterCaps; \ + _pWineCaps->VS20Caps.Caps = &_pD3D9Caps->VS20Caps.Caps; \ + _pWineCaps->VS20Caps.DynamicFlowControlDepth = &_pD3D9Caps->VS20Caps.DynamicFlowControlDepth; \ + _pWineCaps->VS20Caps.NumTemps = &_pD3D9Caps->VS20Caps.NumTemps; \ + _pWineCaps->VS20Caps.NumTemps = &_pD3D9Caps->VS20Caps.NumTemps; \ + _pWineCaps->VS20Caps.StaticFlowControlDepth = &_pD3D9Caps->VS20Caps.StaticFlowControlDepth; \ + _pWineCaps->PS20Caps.Caps = &_pD3D9Caps->PS20Caps.Caps; \ + _pWineCaps->PS20Caps.DynamicFlowControlDepth = &_pD3D9Caps->PS20Caps.DynamicFlowControlDepth; \ + _pWineCaps->PS20Caps.NumTemps = &_pD3D9Caps->PS20Caps.NumTemps; \ + _pWineCaps->PS20Caps.StaticFlowControlDepth = &_pD3D9Caps->PS20Caps.StaticFlowControlDepth; \ + _pWineCaps->PS20Caps.NumInstructionSlots = &_pD3D9Caps->PS20Caps.NumInstructionSlots; \ + _pWineCaps->VertexTextureFilterCaps = &_pD3D9Caps->VertexTextureFilterCaps; \ + _pWineCaps->MaxVShaderInstructionsExecuted = &_pD3D9Caps->MaxVShaderInstructionsExecuted; \ + _pWineCaps->MaxPShaderInstructionsExecuted = &_pD3D9Caps->MaxPShaderInstructionsExecuted; \ + _pWineCaps->MaxVertexShader30InstructionSlots = &_pD3D9Caps->MaxVertexShader30InstructionSlots; \ + _pWineCaps->MaxPixelShader30InstructionSlots = &_pD3D9Caps->MaxPixelShader30InstructionSlots; + +/* =========================================================================== + D3D9 interfactes + =========================================================================== */ + +/* ---------- */ +/* IDirect3D9 */ +/* ---------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern const IDirect3D9Vtbl Direct3D9_Vtbl; + +/***************************************************************************** + * IDirect3D implementation structure + */ +typedef struct IDirect3D9Impl +{ + /* IUnknown fields */ + const IDirect3D9Vtbl *lpVtbl; + LONG ref; + + /* The WineD3D device */ + IWineD3D *WineD3D; + +} IDirect3D9Impl; + +void filter_caps(D3DCAPS9* pCaps); + +/* ---------------- */ +/* IDirect3DDevice9 */ +/* ---------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern const IDirect3DDevice9Vtbl Direct3DDevice9_Vtbl; + +/***************************************************************************** + * IDirect3DDevice9 implementation structure + */ +typedef struct IDirect3DDevice9Impl +{ + /* IUnknown fields */ + const IDirect3DDevice9Vtbl *lpVtbl; + LONG ref; + + /* IDirect3DDevice9 fields */ + IWineD3DDevice *WineD3DDevice; + + /* Avoids recursion with nested ReleaseRef to 0 */ + BOOL inDestruction; + + IDirect3DVertexDeclaration9 **convertedDecls; + unsigned int numConvertedDecls, declArraySize; + +} IDirect3DDevice9Impl; + + +/* IDirect3DDevice9: */ +extern HRESULT WINAPI IDirect3DDevice9Impl_GetDirect3D(LPDIRECT3DDEVICE9 iface, IDirect3D9** ppD3D9); +extern HRESULT WINAPI IDirect3DDevice9Impl_CreateAdditionalSwapChain(LPDIRECT3DDEVICE9 iface, D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain9** pSwapChain); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetSwapChain(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, IDirect3DSwapChain9** pSwapChain); +extern UINT WINAPI IDirect3DDevice9Impl_GetNumberOfSwapChains(LPDIRECT3DDEVICE9 iface); +extern HRESULT WINAPI IDirect3DDevice9Impl_CreateTexture(LPDIRECT3DDEVICE9 iface, UINT Width, UINT Height, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DTexture9** ppTexture, HANDLE* pSharedHandle); +extern HRESULT WINAPI IDirect3DDevice9Impl_CreateVolumeTexture(LPDIRECT3DDEVICE9 iface, UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DVolumeTexture9** ppVolumeTexture, HANDLE* pSharedHandle); +extern HRESULT WINAPI IDirect3DDevice9Impl_CreateCubeTexture(LPDIRECT3DDEVICE9 iface, UINT EdgeLength, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DCubeTexture9** ppCubeTexture, HANDLE* pSharedHandle); +extern HRESULT WINAPI IDirect3DDevice9Impl_CreateVertexBuffer(LPDIRECT3DDEVICE9 iface, UINT Length, DWORD Usage, DWORD FVF, D3DPOOL Pool, IDirect3DVertexBuffer9** ppVertexBuffer, HANDLE* pSharedHandle); +extern HRESULT WINAPI IDirect3DDevice9Impl_CreateIndexBuffer(LPDIRECT3DDEVICE9 iface, UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DIndexBuffer9** ppIndexBuffer, HANDLE* pSharedHandle); +extern HRESULT WINAPI IDirect3DDevice9Impl_CreateStateBlock(LPDIRECT3DDEVICE9 iface, D3DSTATEBLOCKTYPE Type, IDirect3DStateBlock9** ppSB); +extern HRESULT WINAPI IDirect3DDevice9Impl_BeginStateBlock(LPDIRECT3DDEVICE9 iface); +extern HRESULT WINAPI IDirect3DDevice9Impl_EndStateBlock(LPDIRECT3DDEVICE9 iface, IDirect3DStateBlock9** ppSB); +extern HRESULT WINAPI IDirect3DDevice9Impl_CreateVertexDeclaration(LPDIRECT3DDEVICE9 iface, CONST D3DVERTEXELEMENT9* pVertexElements, IDirect3DVertexDeclaration9** ppDecl); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetVertexDeclaration(LPDIRECT3DDEVICE9 iface, IDirect3DVertexDeclaration9* pDecl); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetVertexDeclaration(LPDIRECT3DDEVICE9 iface, IDirect3DVertexDeclaration9** ppDecl); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetFVF(LPDIRECT3DDEVICE9 iface, DWORD FVF); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetFVF(LPDIRECT3DDEVICE9 iface, DWORD* pFVF); +extern HRESULT WINAPI IDirect3DDevice9Impl_CreateVertexShader(LPDIRECT3DDEVICE9 iface, CONST DWORD* pFunction, IDirect3DVertexShader9** ppShader); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetVertexShader(LPDIRECT3DDEVICE9 iface, IDirect3DVertexShader9* pShader); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetVertexShader(LPDIRECT3DDEVICE9 iface, IDirect3DVertexShader9** ppShader); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetVertexShaderConstantF(LPDIRECT3DDEVICE9 iface, UINT StartRegister, CONST float* pConstantData, UINT Vector4fCount); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetVertexShaderConstantF(LPDIRECT3DDEVICE9 iface, UINT StartRegister, float* pConstantData, UINT Vector4fCount); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetVertexShaderConstantI(LPDIRECT3DDEVICE9 iface, UINT StartRegister, CONST int* pConstantData, UINT Vector4iCount); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetVertexShaderConstantI(LPDIRECT3DDEVICE9 iface, UINT StartRegister, int* pConstantData, UINT Vector4iCount); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetVertexShaderConstantB(LPDIRECT3DDEVICE9 iface, UINT StartRegister, CONST BOOL* pConstantData, UINT BoolCount); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetVertexShaderConstantB(LPDIRECT3DDEVICE9 iface, UINT StartRegister, BOOL* pConstantData, UINT BoolCount); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetStreamSource(LPDIRECT3DDEVICE9 iface, UINT StreamNumber, IDirect3DVertexBuffer9* pStreamData, UINT OffsetInBytes, UINT Stride); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetStreamSource(LPDIRECT3DDEVICE9 iface, UINT StreamNumber, IDirect3DVertexBuffer9** ppStreamData, UINT* OffsetInBytes, UINT* pStride); +extern HRESULT WINAPI IDirect3DDevice9Impl_CreatePixelShader(LPDIRECT3DDEVICE9 iface, CONST DWORD* pFunction, IDirect3DPixelShader9** ppShader); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetPixelShader(LPDIRECT3DDEVICE9 iface, IDirect3DPixelShader9* pShader); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetPixelShader(LPDIRECT3DDEVICE9 iface, IDirect3DPixelShader9** ppShader); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetPixelShaderConstantF(LPDIRECT3DDEVICE9 iface, UINT StartRegister, CONST float* pConstantData, UINT Vector4fCount); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetPixelShaderConstantF(LPDIRECT3DDEVICE9 iface, UINT StartRegister, float* pConstantData, UINT Vector4fCount); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetPixelShaderConstantI(LPDIRECT3DDEVICE9 iface, UINT StartRegister, CONST int* pConstantData, UINT Vector4iCount); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetPixelShaderConstantI(LPDIRECT3DDEVICE9 iface, UINT StartRegister, int* pConstantData, UINT Vector4iCount); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetPixelShaderConstantB(LPDIRECT3DDEVICE9 iface, UINT StartRegister, CONST BOOL* pConstantData, UINT BoolCount); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetPixelShaderConstantB(LPDIRECT3DDEVICE9 iface, UINT StartRegister, BOOL* pConstantData, UINT BoolCount); +extern HRESULT WINAPI IDirect3DDevice9Impl_CreateQuery(LPDIRECT3DDEVICE9 iface, D3DQUERYTYPE Type, IDirect3DQuery9** ppQuery); + + +/* ---------------- */ +/* IDirect3DVolume9 */ +/* ---------------- */ + +/***************************************************************************** + * IDirect3DVolume9 implementation structure + */ +typedef struct IDirect3DVolume9Impl +{ + /* IUnknown fields */ + const IDirect3DVolume9Vtbl *lpVtbl; + LONG ref; + + /* IDirect3DVolume9 fields */ + IWineD3DVolume *wineD3DVolume; + + /* The volume container */ + IUnknown *container; + + /* If set forward refcounting to this object */ + IUnknown *forwardReference; +} IDirect3DVolume9Impl; + +/* ------------------- */ +/* IDirect3DSwapChain9 */ +/* ------------------- */ + +/***************************************************************************** + * IDirect3DSwapChain9 implementation structure + */ +typedef struct IDirect3DSwapChain9Impl +{ + /* IUnknown fields */ + const IDirect3DSwapChain9Vtbl *lpVtbl; + LONG ref; + + /* IDirect3DSwapChain9 fields */ + IWineD3DSwapChain *wineD3DSwapChain; + + /* Parent reference */ + LPDIRECT3DDEVICE9 parentDevice; + + /* Flags an implicit swap chain */ + BOOL isImplicit; +} IDirect3DSwapChain9Impl; + +/* ------------------ */ +/* IDirect3DResource9 */ +/* ------------------ */ + +/***************************************************************************** + * IDirect3DResource9 implementation structure + */ +typedef struct IDirect3DResource9Impl +{ + /* IUnknown fields */ + const IDirect3DResource9Vtbl *lpVtbl; + LONG ref; + + /* IDirect3DResource9 fields */ + IWineD3DResource *wineD3DResource; +} IDirect3DResource9Impl; + +extern HRESULT WINAPI IDirect3DResource9Impl_GetDevice(LPDIRECT3DRESOURCE9 iface, IDirect3DDevice9** ppDevice); + + +/* ----------------- */ +/* IDirect3DSurface9 */ +/* ----------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern const IDirect3DSurface9Vtbl Direct3DSurface9_Vtbl; + +/***************************************************************************** + * IDirect3DSurface9 implementation structure + */ +typedef struct IDirect3DSurface9Impl +{ + /* IUnknown fields */ + const IDirect3DSurface9Vtbl *lpVtbl; + LONG ref; + + /* IDirect3DResource9 fields */ + IWineD3DSurface *wineD3DSurface; + + /* Parent reference */ + LPDIRECT3DDEVICE9 parentDevice; + + /* The surface container */ + IUnknown *container; + + /* If set forward refcounting to this object */ + IUnknown *forwardReference; + + /* Flags an implicit surface */ + BOOL isImplicit; +} IDirect3DSurface9Impl; + +/* ---------------------- */ +/* IDirect3DVertexBuffer9 */ +/* ---------------------- */ + +/***************************************************************************** + * IDirect3DVertexBuffer9 implementation structure + */ +typedef struct IDirect3DVertexBuffer9Impl +{ + /* IUnknown fields */ + const IDirect3DVertexBuffer9Vtbl *lpVtbl; + LONG ref; + + /* IDirect3DResource9 fields */ + IWineD3DVertexBuffer *wineD3DVertexBuffer; + + /* Parent reference */ + LPDIRECT3DDEVICE9 parentDevice; +} IDirect3DVertexBuffer9Impl; + +/* --------------------- */ +/* IDirect3DIndexBuffer9 */ +/* --------------------- */ + +/***************************************************************************** + * IDirect3DIndexBuffer9 implementation structure + */ +typedef struct IDirect3DIndexBuffer9Impl +{ + /* IUnknown fields */ + const IDirect3DIndexBuffer9Vtbl *lpVtbl; + LONG ref; + + /* IDirect3DResource9 fields */ + IWineD3DIndexBuffer *wineD3DIndexBuffer; + + /* Parent reference */ + LPDIRECT3DDEVICE9 parentDevice; +} IDirect3DIndexBuffer9Impl; + +/* --------------------- */ +/* IDirect3DBaseTexture9 */ +/* --------------------- */ + +/***************************************************************************** + * IDirect3DBaseTexture9 implementation structure + */ +typedef struct IDirect3DBaseTexture9Impl +{ + /* IUnknown fields */ + const IDirect3DBaseTexture9Vtbl *lpVtbl; + LONG ref; + + /* IDirect3DResource9 fields */ + IWineD3DBaseTexture *wineD3DBaseTexture; + +} IDirect3DBaseTexture9Impl; + +extern DWORD WINAPI IDirect3DBaseTexture9Impl_GetLOD(LPDIRECT3DBASETEXTURE9 iface); + +/* --------------------- */ +/* IDirect3DCubeTexture9 */ +/* --------------------- */ + +/***************************************************************************** + * IDirect3DCubeTexture9 implementation structure + */ +typedef struct IDirect3DCubeTexture9Impl +{ + /* IUnknown fields */ + const IDirect3DCubeTexture9Vtbl *lpVtbl; + LONG ref; + + /* IDirect3DResource9 fields */ + IWineD3DCubeTexture *wineD3DCubeTexture; + + /* Parent reference */ + LPDIRECT3DDEVICE9 parentDevice; +} IDirect3DCubeTexture9Impl; + + +/* ----------------- */ +/* IDirect3DTexture9 */ +/* ----------------- */ + +/***************************************************************************** + * IDirect3DTexture9 implementation structure + */ +typedef struct IDirect3DTexture9Impl +{ + /* IUnknown fields */ + const IDirect3DTexture9Vtbl *lpVtbl; + LONG ref; + + /* IDirect3DResource9 fields */ + IWineD3DTexture *wineD3DTexture; + + /* Parent reference */ + LPDIRECT3DDEVICE9 parentDevice; +} IDirect3DTexture9Impl; + +/* ----------------------- */ +/* IDirect3DVolumeTexture9 */ +/* ----------------------- */ + +/***************************************************************************** + * IDirect3DVolumeTexture9 implementation structure + */ +typedef struct IDirect3DVolumeTexture9Impl +{ + /* IUnknown fields */ + const IDirect3DVolumeTexture9Vtbl *lpVtbl; + LONG ref; + + /* IDirect3DResource9 fields */ + IWineD3DVolumeTexture *wineD3DVolumeTexture; + + /* Parent reference */ + LPDIRECT3DDEVICE9 parentDevice; +} IDirect3DVolumeTexture9Impl; + +/* ----------------------- */ +/* IDirect3DStateBlock9 */ +/* ----------------------- */ + +/***************************************************************************** + * IDirect3DStateBlock9 implementation structure + */ +typedef struct IDirect3DStateBlock9Impl { + /* IUnknown fields */ + const IDirect3DStateBlock9Vtbl *lpVtbl; + LONG ref; + + /* IDirect3DStateBlock9 fields */ + IWineD3DStateBlock *wineD3DStateBlock; + + /* Parent reference */ + LPDIRECT3DDEVICE9 parentDevice; +} IDirect3DStateBlock9Impl; + + +/* --------------------------- */ +/* IDirect3DVertexDeclaration9 */ +/* --------------------------- */ + +/***************************************************************************** + * IDirect3DVertexDeclaration implementation structure + */ +typedef struct IDirect3DVertexDeclaration9Impl { + /* IUnknown fields */ + const IDirect3DVertexDeclaration9Vtbl *lpVtbl; + LONG ref; + + D3DVERTEXELEMENT9 *elements; + size_t element_count; + + /* IDirect3DVertexDeclaration9 fields */ + IWineD3DVertexDeclaration *wineD3DVertexDeclaration; + DWORD convFVF; + + /* Parent reference */ + LPDIRECT3DDEVICE9 parentDevice; +} IDirect3DVertexDeclaration9Impl; + +void IDirect3DVertexDeclaration9Impl_Destroy(LPDIRECT3DVERTEXDECLARATION9 iface); + +/* ---------------------- */ +/* IDirect3DVertexShader9 */ +/* ---------------------- */ + +/***************************************************************************** + * IDirect3DVertexShader implementation structure + */ +typedef struct IDirect3DVertexShader9Impl { + /* IUnknown fields */ + const IDirect3DVertexShader9Vtbl *lpVtbl; + LONG ref; + + /* IDirect3DVertexShader9 fields */ + IWineD3DVertexShader *wineD3DVertexShader; + + /* Parent reference */ + LPDIRECT3DDEVICE9 parentDevice; +} IDirect3DVertexShader9Impl; + +/* --------------------- */ +/* IDirect3DPixelShader9 */ +/* --------------------- */ + +/***************************************************************************** + * IDirect3DPixelShader implementation structure + */ +typedef struct IDirect3DPixelShader9Impl { + /* IUnknown fields */ + const IDirect3DPixelShader9Vtbl *lpVtbl; + LONG ref; + + /* IDirect3DPixelShader9 fields */ + IWineD3DPixelShader *wineD3DPixelShader; + + /* Parent reference */ + LPDIRECT3DDEVICE9 parentDevice; +} IDirect3DPixelShader9Impl; + +/* --------------- */ +/* IDirect3DQuery9 */ +/* --------------- */ + +/***************************************************************************** + * IDirect3DPixelShader implementation structure + */ +typedef struct IDirect3DQuery9Impl { + /* IUnknown fields */ + const IDirect3DQuery9Vtbl *lpVtbl; + LONG ref; + + /* IDirect3DQuery9 fields */ + IWineD3DQuery *wineD3DQuery; + + /* Parent reference */ + LPDIRECT3DDEVICE9 parentDevice; +} IDirect3DQuery9Impl; + + +/* Callbacks */ +extern HRESULT WINAPI D3D9CB_CreateSurface(IUnknown *device, IUnknown *pSuperior, UINT Width, UINT Height, + WINED3DFORMAT Format, DWORD Usage, WINED3DPOOL Pool, UINT Level, + WINED3DCUBEMAP_FACES Face, IWineD3DSurface** ppSurface, + HANDLE* pSharedHandle); + +extern HRESULT WINAPI D3D9CB_CreateVolume(IUnknown *pDevice, IUnknown *pSuperior, UINT Width, UINT Height, UINT Depth, + WINED3DFORMAT Format, WINED3DPOOL Pool, DWORD Usage, + IWineD3DVolume **ppVolume, + HANDLE * pSharedHandle); + +extern HRESULT WINAPI D3D9CB_CreateDepthStencilSurface(IUnknown *device, IUnknown *pSuperior, UINT Width, UINT Height, + WINED3DFORMAT Format, WINED3DMULTISAMPLE_TYPE MultiSample, + DWORD MultisampleQuality, BOOL Discard, + IWineD3DSurface** ppSurface, HANDLE* pSharedHandle); + +extern HRESULT WINAPI D3D9CB_CreateRenderTarget(IUnknown *device, IUnknown *pSuperior, UINT Width, UINT Height, + WINED3DFORMAT Format, WINED3DMULTISAMPLE_TYPE MultiSample, + DWORD MultisampleQuality, BOOL Lockable, + IWineD3DSurface** ppSurface, HANDLE* pSharedHandle); + +extern ULONG WINAPI D3D9CB_DestroySwapChain (IWineD3DSwapChain *pSwapChain); + +extern ULONG WINAPI D3D9CB_DestroyDepthStencilSurface (IWineD3DSurface *pSurface); + +extern ULONG WINAPI D3D9CB_DestroyRenderTarget (IWineD3DSurface *pSurface); + +extern ULONG WINAPI D3D9CB_DestroySurface(IWineD3DSurface *pSurface); + +extern ULONG WINAPI D3D9CB_DestroyVolume(IWineD3DVolume *pVolume); + +#endif /* __WINE_D3D9_PRIVATE_H */ diff --git a/reactos/dll/directx/wine/d3d9/device.c b/reactos/dll/directx/wine/d3d9/device.c new file mode 100644 index 00000000000..d48587fba00 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/device.c @@ -0,0 +1,1493 @@ +/* + * 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" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d9); + + +/* IDirect3D IUnknown parts follow: */ +static HRESULT WINAPI IDirect3DDevice9Impl_QueryInterface(LPDIRECT3DDEVICE9 iface, REFIID riid, LPVOID* ppobj) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DDevice9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3DDevice9Impl_AddRef(LPDIRECT3DDEVICE9 iface) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + + return ref; +} + +static ULONG WINAPI IDirect3DDevice9Impl_Release(LPDIRECT3DDEVICE9 iface) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + ULONG ref; + + if (This->inDestruction) return 0; + ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + int i; + This->inDestruction = TRUE; + + EnterCriticalSection(&d3d9_cs); + for(i = 0; i < This->numConvertedDecls; i++) { + /* Unless Wine is buggy or the app has a bug the refcount will be 0, because decls hold a reference to the + * device + */ + IDirect3DVertexDeclaration9Impl_Destroy(This->convertedDecls[i]); + } + HeapFree(GetProcessHeap(), 0, This->convertedDecls); + + IWineD3DDevice_Uninit3D(This->WineD3DDevice, D3D9CB_DestroyDepthStencilSurface, D3D9CB_DestroySwapChain); + IWineD3DDevice_Release(This->WineD3DDevice); + LeaveCriticalSection(&d3d9_cs); + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DDevice Interface follow: */ +static HRESULT WINAPI IDirect3DDevice9Impl_TestCooperativeLevel(LPDIRECT3DDEVICE9 iface) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) : Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_TestCooperativeLevel(This->WineD3DDevice); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static UINT WINAPI IDirect3DDevice9Impl_GetAvailableTextureMem(LPDIRECT3DDEVICE9 iface) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetAvailableTextureMem(This->WineD3DDevice); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_EvictManagedResources(LPDIRECT3DDEVICE9 iface) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) : Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_EvictManagedResources(This->WineD3DDevice); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetDirect3D(LPDIRECT3DDEVICE9 iface, IDirect3D9** ppD3D9) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr = D3D_OK; + IWineD3D* pWineD3D; + + TRACE("(%p) Relay\n", This); + + if (NULL == ppD3D9) { + return D3DERR_INVALIDCALL; + } + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetDirect3D(This->WineD3DDevice, &pWineD3D); + if (hr == D3D_OK && pWineD3D != NULL) + { + IWineD3D_GetParent(pWineD3D,(IUnknown **)ppD3D9); + IWineD3D_Release(pWineD3D); + } else { + FIXME("Call to IWineD3DDevice_GetDirect3D failed\n"); + *ppD3D9 = NULL; + } + TRACE("(%p) returning %p\n", This, *ppD3D9); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetDeviceCaps(LPDIRECT3DDEVICE9 iface, D3DCAPS9* pCaps) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hrc = D3D_OK; + WINED3DCAPS *pWineCaps; + + TRACE("(%p) : Relay pCaps %p\n", This, pCaps); + if(NULL == pCaps){ + return D3DERR_INVALIDCALL; + } + pWineCaps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINED3DCAPS)); + if(pWineCaps == NULL){ + return D3DERR_INVALIDCALL; /* well this is what MSDN says to return */ + } + + memset(pCaps, 0, sizeof(*pCaps)); + D3D9CAPSTOWINECAPS(pCaps, pWineCaps) + EnterCriticalSection(&d3d9_cs); + hrc = IWineD3DDevice_GetDeviceCaps(This->WineD3DDevice, pWineCaps); + LeaveCriticalSection(&d3d9_cs); + HeapFree(GetProcessHeap(), 0, pWineCaps); + + /* Some functionality is implemented in d3d9.dll, not wined3d.dll. Add the needed caps */ + pCaps->DevCaps2 |= D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES; + + filter_caps(pCaps); + + TRACE("Returning %p %p\n", This, pCaps); + return hrc; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetDisplayMode(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, D3DDISPLAYMODE* pMode) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetDisplayMode(This->WineD3DDevice, iSwapChain, (WINED3DDISPLAYMODE *) pMode); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetCreationParameters(LPDIRECT3DDEVICE9 iface, D3DDEVICE_CREATION_PARAMETERS *pParameters) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetCreationParameters(This->WineD3DDevice, (WINED3DDEVICE_CREATION_PARAMETERS *) pParameters); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetCursorProperties(LPDIRECT3DDEVICE9 iface, UINT XHotSpot, UINT YHotSpot, IDirect3DSurface9* pCursorBitmap) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IDirect3DSurface9Impl *pSurface = (IDirect3DSurface9Impl*)pCursorBitmap; + HRESULT hr; + + TRACE("(%p) Relay\n", This); + if(!pCursorBitmap) { + WARN("No cursor bitmap, returning WINED3DERR_INVALIDCALL\n"); + return WINED3DERR_INVALIDCALL; + } + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetCursorProperties(This->WineD3DDevice, XHotSpot, YHotSpot, (IWineD3DSurface*)pSurface->wineD3DSurface); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static void WINAPI IDirect3DDevice9Impl_SetCursorPosition(LPDIRECT3DDEVICE9 iface, int XScreenSpace, int YScreenSpace, DWORD Flags) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + IWineD3DDevice_SetCursorPosition(This->WineD3DDevice, XScreenSpace, YScreenSpace, Flags); + LeaveCriticalSection(&d3d9_cs); +} + +static BOOL WINAPI IDirect3DDevice9Impl_ShowCursor(LPDIRECT3DDEVICE9 iface, BOOL bShow) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + BOOL ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DDevice_ShowCursor(This->WineD3DDevice, bShow); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_Reset(LPDIRECT3DDEVICE9 iface, D3DPRESENT_PARAMETERS* pPresentationParameters) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + WINED3DPRESENT_PARAMETERS localParameters; + HRESULT hr; + + TRACE("(%p) Relay pPresentationParameters(%p)\n", This, pPresentationParameters); + + localParameters.BackBufferWidth = pPresentationParameters->BackBufferWidth; + localParameters.BackBufferHeight = pPresentationParameters->BackBufferHeight; + localParameters.BackBufferFormat = pPresentationParameters->BackBufferFormat; + localParameters.BackBufferCount = pPresentationParameters->BackBufferCount; + localParameters.MultiSampleType = pPresentationParameters->MultiSampleType; + localParameters.MultiSampleQuality = pPresentationParameters->MultiSampleQuality; + localParameters.SwapEffect = pPresentationParameters->SwapEffect; + localParameters.hDeviceWindow = pPresentationParameters->hDeviceWindow; + localParameters.Windowed = pPresentationParameters->Windowed; + localParameters.EnableAutoDepthStencil = pPresentationParameters->EnableAutoDepthStencil; + localParameters.AutoDepthStencilFormat = pPresentationParameters->AutoDepthStencilFormat; + localParameters.Flags = pPresentationParameters->Flags; + localParameters.FullScreen_RefreshRateInHz = pPresentationParameters->FullScreen_RefreshRateInHz; + localParameters.PresentationInterval = pPresentationParameters->PresentationInterval; + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_Reset(This->WineD3DDevice, &localParameters); + LeaveCriticalSection(&d3d9_cs); + + pPresentationParameters->BackBufferWidth = localParameters.BackBufferWidth; + pPresentationParameters->BackBufferHeight = localParameters.BackBufferHeight; + pPresentationParameters->BackBufferFormat = localParameters.BackBufferFormat; + pPresentationParameters->BackBufferCount = localParameters.BackBufferCount; + pPresentationParameters->MultiSampleType = localParameters.MultiSampleType; + pPresentationParameters->MultiSampleQuality = localParameters.MultiSampleQuality; + pPresentationParameters->SwapEffect = localParameters.SwapEffect; + pPresentationParameters->hDeviceWindow = localParameters.hDeviceWindow; + pPresentationParameters->Windowed = localParameters.Windowed; + pPresentationParameters->EnableAutoDepthStencil = localParameters.EnableAutoDepthStencil; + pPresentationParameters->AutoDepthStencilFormat = localParameters.AutoDepthStencilFormat; + pPresentationParameters->Flags = localParameters.Flags; + pPresentationParameters->FullScreen_RefreshRateInHz = localParameters.FullScreen_RefreshRateInHz; + pPresentationParameters->PresentationInterval = localParameters.PresentationInterval; + + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_Present(LPDIRECT3DDEVICE9 iface, CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* + pDirtyRegion) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_Present(This->WineD3DDevice, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion); + LeaveCriticalSection(&d3d9_cs); + return hr; + } + +static HRESULT WINAPI IDirect3DDevice9Impl_GetBackBuffer(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, UINT BackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface9 ** ppBackBuffer) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IWineD3DSurface *retSurface = NULL; + HRESULT rc = D3D_OK; + + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + rc = IWineD3DDevice_GetBackBuffer(This->WineD3DDevice, iSwapChain, BackBuffer, (WINED3DBACKBUFFER_TYPE) Type, (IWineD3DSurface **)&retSurface); + if (rc == D3D_OK && NULL != retSurface && NULL != ppBackBuffer) { + IWineD3DSurface_GetParent(retSurface, (IUnknown **)ppBackBuffer); + IWineD3DSurface_Release(retSurface); + } + LeaveCriticalSection(&d3d9_cs); + return rc; +} +static HRESULT WINAPI IDirect3DDevice9Impl_GetRasterStatus(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, D3DRASTER_STATUS* pRasterStatus) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetRasterStatus(This->WineD3DDevice, iSwapChain, (WINED3DRASTER_STATUS *) pRasterStatus); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetDialogBoxMode(LPDIRECT3DDEVICE9 iface, BOOL bEnableDialogs) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetDialogBoxMode(This->WineD3DDevice, bEnableDialogs); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static void WINAPI IDirect3DDevice9Impl_SetGammaRamp(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, DWORD Flags, CONST D3DGAMMARAMP* pRamp) { + + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + /* Note: D3DGAMMARAMP is compatible with WINED3DGAMMARAMP */ + IWineD3DDevice_SetGammaRamp(This->WineD3DDevice, iSwapChain, Flags, (CONST WINED3DGAMMARAMP *)pRamp); + LeaveCriticalSection(&d3d9_cs); +} + +static void WINAPI IDirect3DDevice9Impl_GetGammaRamp(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, D3DGAMMARAMP* pRamp) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + /* Note: D3DGAMMARAMP is compatible with WINED3DGAMMARAMP */ + IWineD3DDevice_GetGammaRamp(This->WineD3DDevice, iSwapChain, (WINED3DGAMMARAMP *) pRamp); + LeaveCriticalSection(&d3d9_cs); +} + + +static HRESULT WINAPI IDirect3DDevice9Impl_CreateSurface(LPDIRECT3DDEVICE9 iface, UINT Width, UINT Height, D3DFORMAT Format, BOOL Lockable, BOOL Discard, UINT Level, IDirect3DSurface9 **ppSurface,D3DRESOURCETYPE Type, UINT Usage, D3DPOOL Pool, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality,HANDLE* pSharedHandle ) { + HRESULT hrc; + IDirect3DSurface9Impl *object; + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + TRACE("(%p) Relay\n", This); + if(MultisampleQuality < 0) { + FIXME("MultisampleQuality out of range %d, substituting 0\n", MultisampleQuality); + /*FIXME: Find out what windows does with a MultisampleQuality < 0 */ + MultisampleQuality=0; + } + + if(MultisampleQuality > 0){ + FIXME("MultisampleQuality set to %d, bstituting 0\n", MultisampleQuality); + /* + MultisampleQuality + [in] Quality level. The valid range is between zero and one less than the level returned by pQualityLevels used by IDirect3D9::CheckDeviceMultiSampleType. Passing a larger value returns the error D3DERR_INVALIDCALL. The MultisampleQuality values of paired render targets, depth stencil surfaces, and the MultiSample type must all match. + */ + + MultisampleQuality=0; + } + /*FIXME: Check MAX bounds of MultisampleQuality*/ + + /* Allocate the storage for the device */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DSurface9Impl)); + if (NULL == object) { + FIXME("Allocation of memory failed\n"); + return D3DERR_OUTOFVIDEOMEMORY; + } + + object->lpVtbl = &Direct3DSurface9_Vtbl; + object->ref = 1; + + TRACE("(%p) : w(%d) h(%d) fmt(%d) surf@%p\n", This, Width, Height, Format, *ppSurface); + + hrc = IWineD3DDevice_CreateSurface(This->WineD3DDevice, Width, Height, Format, Lockable, Discard, Level, &object->wineD3DSurface, Type, Usage & WINED3DUSAGE_MASK, (WINED3DPOOL) Pool,MultiSample,MultisampleQuality,pSharedHandle,SURFACE_OPENGL,(IUnknown *)object); + + if (hrc != D3D_OK || NULL == object->wineD3DSurface) { + + /* free up object */ + FIXME("(%p) call to IWineD3DDevice_CreateSurface failed\n", This); + HeapFree(GetProcessHeap(), 0, object); + } else { + IUnknown_AddRef(iface); + object->parentDevice = iface; + TRACE("(%p) : Created surface %p\n", This, object); + *ppSurface = (LPDIRECT3DSURFACE9) object; + } + return hrc; +} + + + +static HRESULT WINAPI IDirect3DDevice9Impl_CreateRenderTarget(LPDIRECT3DDEVICE9 iface, UINT Width, UINT Height, + D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, + DWORD MultisampleQuality, BOOL Lockable, + IDirect3DSurface9 **ppSurface, HANDLE* pSharedHandle) { + HRESULT hr; + TRACE("Relay\n"); + + /* Is this correct? */ + EnterCriticalSection(&d3d9_cs); + hr = IDirect3DDevice9Impl_CreateSurface(iface,Width,Height,Format,Lockable,FALSE/*Discard*/, 0/*Level*/, ppSurface,D3DRTYPE_SURFACE,D3DUSAGE_RENDERTARGET,D3DPOOL_DEFAULT,MultiSample,MultisampleQuality,pSharedHandle); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_CreateDepthStencilSurface(LPDIRECT3DDEVICE9 iface, UINT Width, UINT Height, + D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, + DWORD MultisampleQuality, BOOL Discard, + IDirect3DSurface9 **ppSurface, HANDLE* pSharedHandle) { + HRESULT hr; + TRACE("Relay\n"); + + EnterCriticalSection(&d3d9_cs); + hr = IDirect3DDevice9Impl_CreateSurface(iface,Width,Height,Format,TRUE/* Lockable */,Discard, 0/* Level */ + ,ppSurface,D3DRTYPE_SURFACE,D3DUSAGE_DEPTHSTENCIL, + D3DPOOL_DEFAULT,MultiSample,MultisampleQuality,pSharedHandle); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + + +static HRESULT WINAPI IDirect3DDevice9Impl_UpdateSurface(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pSourceSurface, CONST RECT* pSourceRect, IDirect3DSurface9* pDestinationSurface, CONST POINT* pDestPoint) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_UpdateSurface(This->WineD3DDevice, ((IDirect3DSurface9Impl *)pSourceSurface)->wineD3DSurface, pSourceRect, ((IDirect3DSurface9Impl *)pDestinationSurface)->wineD3DSurface, pDestPoint); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_UpdateTexture(LPDIRECT3DDEVICE9 iface, IDirect3DBaseTexture9* pSourceTexture, IDirect3DBaseTexture9* pDestinationTexture) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_UpdateTexture(This->WineD3DDevice, ((IDirect3DBaseTexture9Impl *)pSourceTexture)->wineD3DBaseTexture, ((IDirect3DBaseTexture9Impl *)pDestinationTexture)->wineD3DBaseTexture); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +/* This isn't in MSDN! +static HRESULT WINAPI IDirect3DDevice9Impl_GetFrontBuffer(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pDestSurface) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + FIXME("(%p) : stub\n", This); + return D3D_OK; +} +*/ + +static HRESULT WINAPI IDirect3DDevice9Impl_GetRenderTargetData(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pRenderTarget, IDirect3DSurface9* pDestSurface) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IDirect3DSurface9Impl *renderTarget = (IDirect3DSurface9Impl *)pRenderTarget; + IDirect3DSurface9Impl *destSurface = (IDirect3DSurface9Impl *)pDestSurface; + HRESULT hr; + TRACE("(%p)->(%p,%p)\n" , This, renderTarget, destSurface); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DSurface_BltFast(destSurface->wineD3DSurface, 0, 0, renderTarget->wineD3DSurface, NULL, WINEDDBLTFAST_NOCOLORKEY); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetFrontBufferData(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, IDirect3DSurface9* pDestSurface) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IDirect3DSurface9Impl *destSurface = (IDirect3DSurface9Impl *)pDestSurface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetFrontBufferData(This->WineD3DDevice, iSwapChain, destSurface->wineD3DSurface); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_StretchRect(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pSourceSurface, CONST RECT* pSourceRect, IDirect3DSurface9* pDestSurface, CONST RECT* pDestRect, D3DTEXTUREFILTERTYPE Filter) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IDirect3DSurface9Impl *src = (IDirect3DSurface9Impl *) pSourceSurface; + IDirect3DSurface9Impl *dst = (IDirect3DSurface9Impl *) pDestSurface; + HRESULT hr; + + TRACE("(%p)->(%p,%p,%p,%p,%d)\n" , This, src, pSourceRect, dst, pDestRect, Filter); + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DSurface_Blt(dst->wineD3DSurface, (RECT *) pDestRect, src->wineD3DSurface, (RECT *) pSourceRect, 0, NULL, Filter); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_ColorFill(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pSurface, CONST RECT* pRect, D3DCOLOR color) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IDirect3DSurface9Impl *surface = (IDirect3DSurface9Impl *)pSurface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + /* Note: D3DRECT is compatible with WINED3DRECT */ + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_ColorFill(This->WineD3DDevice, surface->wineD3DSurface, (CONST WINED3DRECT*)pRect, color); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_CreateOffscreenPlainSurface(LPDIRECT3DDEVICE9 iface, UINT Width, UINT Height, D3DFORMAT Format, D3DPOOL Pool, IDirect3DSurface9 **ppSurface, HANDLE* pSharedHandle) { + HRESULT hr; + TRACE("Relay\n"); + if(Pool == D3DPOOL_MANAGED ){ + FIXME("Attempting to create a managed offscreen plain surface\n"); + return D3DERR_INVALIDCALL; + } + /*MSDN: D3DPOOL_SCRATCH will return a surface that has identical characteristics to a surface created by the Microsoft DirectX 8.x method CreateImageSurface. + + 'Off-screen plain surfaces are always lockable, regardless of their pool types.' + but then... + D3DPOOL_DEFAULT is the appropriate pool for use with the IDirect3DDevice9::StretchRect and IDirect3DDevice9::ColorFill. + Why, their always lockable? + should I change the usage to dynamic? + */ + EnterCriticalSection(&d3d9_cs); + hr = IDirect3DDevice9Impl_CreateSurface(iface,Width,Height,Format,TRUE/*Loackable*/,FALSE/*Discard*/,0/*Level*/ , ppSurface,D3DRTYPE_SURFACE, 0/*Usage (undefined/none)*/,(WINED3DPOOL) Pool,D3DMULTISAMPLE_NONE,0/*MultisampleQuality*/,pSharedHandle); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +/* TODO: move to wineD3D */ +static HRESULT WINAPI IDirect3DDevice9Impl_SetRenderTarget(LPDIRECT3DDEVICE9 iface, DWORD RenderTargetIndex, IDirect3DSurface9* pRenderTarget) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IDirect3DSurface9Impl *pSurface = (IDirect3DSurface9Impl*)pRenderTarget; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetRenderTarget(This->WineD3DDevice, RenderTargetIndex, pSurface ? (IWineD3DSurface*)pSurface->wineD3DSurface : NULL); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetRenderTarget(LPDIRECT3DDEVICE9 iface, DWORD RenderTargetIndex, IDirect3DSurface9 **ppRenderTarget) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr = D3D_OK; + IWineD3DSurface *pRenderTarget; + + TRACE("(%p) Relay\n" , This); + + if (ppRenderTarget == NULL) { + return D3DERR_INVALIDCALL; + } + + EnterCriticalSection(&d3d9_cs); + hr=IWineD3DDevice_GetRenderTarget(This->WineD3DDevice,RenderTargetIndex,&pRenderTarget); + + if (hr == D3D_OK && pRenderTarget != NULL) { + IWineD3DSurface_GetParent(pRenderTarget,(IUnknown**)ppRenderTarget); + IWineD3DSurface_Release(pRenderTarget); + } else { + FIXME("Call to IWineD3DDevice_GetRenderTarget failed\n"); + *ppRenderTarget = NULL; + } + LeaveCriticalSection(&d3d9_cs); + + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetDepthStencilSurface(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pZStencilSurface) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IDirect3DSurface9Impl *pSurface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + pSurface = (IDirect3DSurface9Impl*)pZStencilSurface; + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetDepthStencilSurface(This->WineD3DDevice, NULL==pSurface ? NULL : pSurface->wineD3DSurface); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetDepthStencilSurface(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9 **ppZStencilSurface) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr = D3D_OK; + IWineD3DSurface *pZStencilSurface; + + TRACE("(%p) Relay\n" , This); + if(ppZStencilSurface == NULL){ + return D3DERR_INVALIDCALL; + } + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetDepthStencilSurface(This->WineD3DDevice,&pZStencilSurface); + if(hr == D3D_OK) { + if(pZStencilSurface != NULL){ + IWineD3DSurface_GetParent(pZStencilSurface,(IUnknown**)ppZStencilSurface); + IWineD3DSurface_Release(pZStencilSurface); + } else { + *ppZStencilSurface = NULL; + } + } else { + WARN("Call to IWineD3DDevice_GetDepthStencilSurface failed\n"); + } + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_BeginScene(LPDIRECT3DDEVICE9 iface) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_BeginScene(This->WineD3DDevice); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_EndScene(LPDIRECT3DDEVICE9 iface) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_EndScene(This->WineD3DDevice); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_Clear(LPDIRECT3DDEVICE9 iface, DWORD Count, CONST D3DRECT* pRects, DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + /* Note: D3DRECT is compatible with WINED3DRECT */ + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_Clear(This->WineD3DDevice, Count, (CONST WINED3DRECT*) pRects, Flags, Color, Z, Stencil); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetTransform(LPDIRECT3DDEVICE9 iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* lpMatrix) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + /* Note: D3DMATRIX is compatible with WINED3DMATRIX */ + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetTransform(This->WineD3DDevice, State, (CONST WINED3DMATRIX*) lpMatrix); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetTransform(LPDIRECT3DDEVICE9 iface, D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + TRACE("(%p) Relay\n" , This); + + /* Note: D3DMATRIX is compatible with WINED3DMATRIX */ + return IWineD3DDevice_GetTransform(This->WineD3DDevice, State, (WINED3DMATRIX*) pMatrix); +} + +static HRESULT WINAPI IDirect3DDevice9Impl_MultiplyTransform(LPDIRECT3DDEVICE9 iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + /* Note: D3DMATRIX is compatible with WINED3DMATRIX */ + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_MultiplyTransform(This->WineD3DDevice, State, (CONST WINED3DMATRIX*) pMatrix); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetViewport(LPDIRECT3DDEVICE9 iface, CONST D3DVIEWPORT9* pViewport) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + /* Note: D3DVIEWPORT9 is compatible with WINED3DVIEWPORT */ + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetViewport(This->WineD3DDevice, (const WINED3DVIEWPORT *)pViewport); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetViewport(LPDIRECT3DDEVICE9 iface, D3DVIEWPORT9* pViewport) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + /* Note: D3DVIEWPORT9 is compatible with WINED3DVIEWPORT */ + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetViewport(This->WineD3DDevice, (WINED3DVIEWPORT *)pViewport); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetMaterial(LPDIRECT3DDEVICE9 iface, CONST D3DMATERIAL9* pMaterial) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + /* Note: D3DMATERIAL9 is compatible with WINED3DMATERIAL */ + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetMaterial(This->WineD3DDevice, (const WINED3DMATERIAL *)pMaterial); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetMaterial(LPDIRECT3DDEVICE9 iface, D3DMATERIAL9* pMaterial) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + /* Note: D3DMATERIAL9 is compatible with WINED3DMATERIAL */ + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetMaterial(This->WineD3DDevice, (WINED3DMATERIAL *)pMaterial); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetLight(LPDIRECT3DDEVICE9 iface, DWORD Index, CONST D3DLIGHT9* pLight) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + /* Note: D3DLIGHT9 is compatible with WINED3DLIGHT */ + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetLight(This->WineD3DDevice, Index, (const WINED3DLIGHT *)pLight); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetLight(LPDIRECT3DDEVICE9 iface, DWORD Index, D3DLIGHT9* pLight) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + /* Note: D3DLIGHT9 is compatible with WINED3DLIGHT */ + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetLight(This->WineD3DDevice, Index, (WINED3DLIGHT *)pLight); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_LightEnable(LPDIRECT3DDEVICE9 iface, DWORD Index, BOOL Enable) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetLightEnable(This->WineD3DDevice, Index, Enable); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetLightEnable(LPDIRECT3DDEVICE9 iface, DWORD Index, BOOL* pEnable) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetLightEnable(This->WineD3DDevice, Index, pEnable); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetClipPlane(LPDIRECT3DDEVICE9 iface, DWORD Index, CONST float* pPlane) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetClipPlane(This->WineD3DDevice, Index, pPlane); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetClipPlane(LPDIRECT3DDEVICE9 iface, DWORD Index, float* pPlane) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetClipPlane(This->WineD3DDevice, Index, pPlane); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetRenderState(LPDIRECT3DDEVICE9 iface, D3DRENDERSTATETYPE State, DWORD Value) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetRenderState(This->WineD3DDevice, State, Value); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetRenderState(LPDIRECT3DDEVICE9 iface, D3DRENDERSTATETYPE State, DWORD* pValue) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetRenderState(This->WineD3DDevice, State, pValue); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetClipStatus(LPDIRECT3DDEVICE9 iface, CONST D3DCLIPSTATUS9* pClipStatus) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetClipStatus(This->WineD3DDevice, (const WINED3DCLIPSTATUS *)pClipStatus); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetClipStatus(LPDIRECT3DDEVICE9 iface, D3DCLIPSTATUS9* pClipStatus) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetClipStatus(This->WineD3DDevice, (WINED3DCLIPSTATUS *)pClipStatus); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetTexture(LPDIRECT3DDEVICE9 iface, DWORD Stage, IDirect3DBaseTexture9 **ppTexture) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IWineD3DBaseTexture *retTexture = NULL; + HRESULT rc = D3D_OK; + + TRACE("(%p) Relay\n" , This); + + if(ppTexture == NULL){ + return D3DERR_INVALIDCALL; + } + + EnterCriticalSection(&d3d9_cs); + rc = IWineD3DDevice_GetTexture(This->WineD3DDevice, Stage, (IWineD3DBaseTexture **)&retTexture); + if (rc == D3D_OK && NULL != retTexture) { + IWineD3DBaseTexture_GetParent(retTexture, (IUnknown **)ppTexture); + IWineD3DBaseTexture_Release(retTexture); + }else{ + FIXME("Call to get texture (%d) failed (%p)\n", Stage, retTexture); + *ppTexture = NULL; + } + LeaveCriticalSection(&d3d9_cs); + + return rc; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetTexture(LPDIRECT3DDEVICE9 iface, DWORD Stage, IDirect3DBaseTexture9* pTexture) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay %d %p\n" , This, Stage, pTexture); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetTexture(This->WineD3DDevice, Stage, + pTexture==NULL ? NULL:((IDirect3DBaseTexture9Impl *)pTexture)->wineD3DBaseTexture); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetTextureStageState(LPDIRECT3DDEVICE9 iface, DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD* pValue) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetTextureStageState(This->WineD3DDevice, Stage, Type, pValue); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetTextureStageState(LPDIRECT3DDEVICE9 iface, DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetTextureStageState(This->WineD3DDevice, Stage, Type, Value); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetSamplerState(LPDIRECT3DDEVICE9 iface, DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD* pValue) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetSamplerState(This->WineD3DDevice, Sampler, Type, pValue); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetSamplerState(LPDIRECT3DDEVICE9 iface, DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetSamplerState(This->WineD3DDevice, Sampler, Type, Value); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_ValidateDevice(LPDIRECT3DDEVICE9 iface, DWORD* pNumPasses) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_ValidateDevice(This->WineD3DDevice, pNumPasses); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetPaletteEntries(LPDIRECT3DDEVICE9 iface, UINT PaletteNumber, CONST PALETTEENTRY* pEntries) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetPaletteEntries(This->WineD3DDevice, PaletteNumber, pEntries); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetPaletteEntries(LPDIRECT3DDEVICE9 iface, UINT PaletteNumber, PALETTEENTRY* pEntries) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetPaletteEntries(This->WineD3DDevice, PaletteNumber, pEntries); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetCurrentTexturePalette(LPDIRECT3DDEVICE9 iface, UINT PaletteNumber) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetCurrentTexturePalette(This->WineD3DDevice, PaletteNumber); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetCurrentTexturePalette(LPDIRECT3DDEVICE9 iface, UINT* PaletteNumber) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetCurrentTexturePalette(This->WineD3DDevice, PaletteNumber); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetScissorRect(LPDIRECT3DDEVICE9 iface, CONST RECT* pRect) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetScissorRect(This->WineD3DDevice, pRect); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetScissorRect(LPDIRECT3DDEVICE9 iface, RECT* pRect) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetScissorRect(This->WineD3DDevice, pRect); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetSoftwareVertexProcessing(LPDIRECT3DDEVICE9 iface, BOOL bSoftware) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetSoftwareVertexProcessing(This->WineD3DDevice, bSoftware); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static BOOL WINAPI IDirect3DDevice9Impl_GetSoftwareVertexProcessing(LPDIRECT3DDEVICE9 iface) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetSoftwareVertexProcessing(This->WineD3DDevice); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetNPatchMode(LPDIRECT3DDEVICE9 iface, float nSegments) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetNPatchMode(This->WineD3DDevice, nSegments); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static float WINAPI IDirect3DDevice9Impl_GetNPatchMode(LPDIRECT3DDEVICE9 iface) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetNPatchMode(This->WineD3DDevice); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_DrawPrimitive(LPDIRECT3DDEVICE9 iface, D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_DrawPrimitive(This->WineD3DDevice, PrimitiveType, StartVertex, PrimitiveCount); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_DrawIndexedPrimitive(LPDIRECT3DDEVICE9 iface, D3DPRIMITIVETYPE PrimitiveType, + INT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + /* D3D8 passes the baseVertexIndex in SetIndices, and due to the stateblock functions wined3d has to work that way */ + EnterCriticalSection(&d3d9_cs); + IWineD3DDevice_SetBaseVertexIndex(This->WineD3DDevice, BaseVertexIndex); + hr = IWineD3DDevice_DrawIndexedPrimitive(This->WineD3DDevice, PrimitiveType, MinVertexIndex, NumVertices, startIndex, primCount); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_DrawPrimitiveUP(LPDIRECT3DDEVICE9 iface, D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_DrawPrimitiveUP(This->WineD3DDevice, PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_DrawIndexedPrimitiveUP(LPDIRECT3DDEVICE9 iface, D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex, + UINT NumVertexIndices, UINT PrimitiveCount, CONST void* pIndexData, + D3DFORMAT IndexDataFormat, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_DrawIndexedPrimitiveUP(This->WineD3DDevice, PrimitiveType, MinVertexIndex, NumVertexIndices, PrimitiveCount, + pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_ProcessVertices(LPDIRECT3DDEVICE9 iface, UINT SrcStartIndex, UINT DestIndex, UINT VertexCount, IDirect3DVertexBuffer9* pDestBuffer, IDirect3DVertexDeclaration9* pVertexDecl, DWORD Flags) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IDirect3DVertexDeclaration9Impl *Decl = (IDirect3DVertexDeclaration9Impl *) pVertexDecl; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_ProcessVertices(This->WineD3DDevice,SrcStartIndex, DestIndex, VertexCount, ((IDirect3DVertexBuffer9Impl *)pDestBuffer)->wineD3DVertexBuffer, Decl ? Decl->wineD3DVertexDeclaration : NULL, Flags); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +IDirect3DVertexDeclaration9 *getConvertedDecl(IDirect3DDevice9Impl *This, DWORD fvf) { + HRESULT hr; + D3DVERTEXELEMENT9* elements = NULL; + IDirect3DVertexDeclaration9* pDecl = NULL; + int p, low, high; /* deliberately signed */ + IDirect3DVertexDeclaration9 **convertedDecls = This->convertedDecls; + + TRACE("Searching for declaration for fvf %08x... ", fvf); + + low = 0; + high = This->numConvertedDecls - 1; + while(low <= high) { + p = (low + high) >> 1; + TRACE("%d ", p); + if(((IDirect3DVertexDeclaration9Impl *) convertedDecls[p])->convFVF == fvf) { + TRACE("found %p\n", convertedDecls[p]); + return convertedDecls[p]; + } else if(((IDirect3DVertexDeclaration9Impl *) convertedDecls[p])->convFVF < fvf) { + low = p + 1; + } else { + high = p - 1; + } + } + TRACE("not found. Creating and inserting at position %d.\n", low); + + hr = vdecl_convert_fvf(fvf, &elements); + if (hr != S_OK) return NULL; + + hr = IDirect3DDevice9Impl_CreateVertexDeclaration((IDirect3DDevice9 *) This, elements, &pDecl); + if (hr != S_OK) return NULL; + + if(This->declArraySize == This->numConvertedDecls) { + int grow = max(This->declArraySize / 2, 8); + convertedDecls = HeapReAlloc(GetProcessHeap(), 0, convertedDecls, + sizeof(convertedDecls[0]) * (This->numConvertedDecls + grow)); + if(!convertedDecls) { + /* This will destroy it */ + IDirect3DVertexDeclaration9_Release(pDecl); + return NULL; + } + This->convertedDecls = convertedDecls; + This->declArraySize += grow; + } + + memmove(convertedDecls + low + 1, convertedDecls + low, sizeof(IDirect3DVertexDeclaration9Impl *) * (This->numConvertedDecls - low)); + convertedDecls[low] = pDecl; + This->numConvertedDecls++; + + /* Will prevent the decl from being destroyed */ + ((IDirect3DVertexDeclaration9Impl *) pDecl)->convFVF = fvf; + IDirect3DVertexDeclaration9_Release(pDecl); /* Does not destroy now */ + + TRACE("Returning %p. %d decls in array\n", pDecl, This->numConvertedDecls); + return pDecl; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetFVF(LPDIRECT3DDEVICE9 iface, DWORD FVF) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + if (0 != FVF) { + HRESULT hr; + IDirect3DVertexDeclaration9* pDecl = getConvertedDecl(This, FVF); + + if(!pDecl) { + /* Any situation when this should happen, except out of memory? */ + ERR("Failed to create a converted vertex declaration\n"); + LeaveCriticalSection(&d3d9_cs); + return D3DERR_DRIVERINTERNALERROR; + } + + hr = IDirect3DDevice9Impl_SetVertexDeclaration(iface, pDecl); + if (hr != S_OK) { + LeaveCriticalSection(&d3d9_cs); + return hr; + } + } + hr = IWineD3DDevice_SetFVF(This->WineD3DDevice, FVF); + LeaveCriticalSection(&d3d9_cs); + + return hr; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetFVF(LPDIRECT3DDEVICE9 iface, DWORD* pFVF) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetFVF(This->WineD3DDevice, pFVF); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetStreamSource(LPDIRECT3DDEVICE9 iface, UINT StreamNumber, IDirect3DVertexBuffer9* pStreamData, UINT OffsetInBytes, UINT Stride) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetStreamSource(This->WineD3DDevice, StreamNumber, + pStreamData==NULL ? NULL:((IDirect3DVertexBuffer9Impl *)pStreamData)->wineD3DVertexBuffer, + OffsetInBytes, Stride); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetStreamSource(LPDIRECT3DDEVICE9 iface, UINT StreamNumber, IDirect3DVertexBuffer9 **pStream, UINT* OffsetInBytes, UINT* pStride) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IWineD3DVertexBuffer *retStream = NULL; + HRESULT rc = D3D_OK; + + TRACE("(%p) Relay\n" , This); + + if(pStream == NULL){ + return D3DERR_INVALIDCALL; + } + + EnterCriticalSection(&d3d9_cs); + rc = IWineD3DDevice_GetStreamSource(This->WineD3DDevice, StreamNumber, (IWineD3DVertexBuffer **)&retStream, OffsetInBytes, pStride); + if (rc == D3D_OK && NULL != retStream) { + IWineD3DVertexBuffer_GetParent(retStream, (IUnknown **)pStream); + IWineD3DVertexBuffer_Release(retStream); + }else{ + if (rc != D3D_OK){ + FIXME("Call to GetStreamSource failed %p %p\n", OffsetInBytes, pStride); + } + *pStream = NULL; + } + LeaveCriticalSection(&d3d9_cs); + + return rc; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetStreamSourceFreq(LPDIRECT3DDEVICE9 iface, UINT StreamNumber, UINT Divider) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetStreamSourceFreq(This->WineD3DDevice, StreamNumber, Divider); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetStreamSourceFreq(LPDIRECT3DDEVICE9 iface, UINT StreamNumber, UINT* Divider) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n" , This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetStreamSourceFreq(This->WineD3DDevice, StreamNumber, Divider); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_SetIndices(LPDIRECT3DDEVICE9 iface, IDirect3DIndexBuffer9* pIndexData) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetIndices(This->WineD3DDevice, + pIndexData ? ((IDirect3DIndexBuffer9Impl *)pIndexData)->wineD3DIndexBuffer : NULL); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_GetIndices(LPDIRECT3DDEVICE9 iface, IDirect3DIndexBuffer9 **ppIndexData) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IWineD3DIndexBuffer *retIndexData = NULL; + HRESULT rc = D3D_OK; + + TRACE("(%p) Relay\n", This); + + if(ppIndexData == NULL){ + return D3DERR_INVALIDCALL; + } + + EnterCriticalSection(&d3d9_cs); + rc = IWineD3DDevice_GetIndices(This->WineD3DDevice, &retIndexData); + if (SUCCEEDED(rc) && retIndexData) { + IWineD3DIndexBuffer_GetParent(retIndexData, (IUnknown **)ppIndexData); + IWineD3DIndexBuffer_Release(retIndexData); + } else { + if (FAILED(rc)) FIXME("Call to GetIndices failed\n"); + *ppIndexData = NULL; + } + LeaveCriticalSection(&d3d9_cs); + return rc; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_DrawRectPatch(LPDIRECT3DDEVICE9 iface, UINT Handle, CONST float* pNumSegs, CONST D3DRECTPATCH_INFO* pRectPatchInfo) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_DrawRectPatch(This->WineD3DDevice, Handle, pNumSegs, (CONST WINED3DRECTPATCH_INFO *)pRectPatchInfo); + LeaveCriticalSection(&d3d9_cs); + return hr; +} +/*http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/d3d/interfaces/idirect3ddevice9/DrawTriPatch.asp*/ +static HRESULT WINAPI IDirect3DDevice9Impl_DrawTriPatch(LPDIRECT3DDEVICE9 iface, UINT Handle, CONST float* pNumSegs, CONST D3DTRIPATCH_INFO* pTriPatchInfo) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_DrawTriPatch(This->WineD3DDevice, Handle, pNumSegs, (CONST WINED3DTRIPATCH_INFO *)pTriPatchInfo); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DDevice9Impl_DeletePatch(LPDIRECT3DDEVICE9 iface, UINT Handle) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_DeletePatch(This->WineD3DDevice, Handle); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +const IDirect3DDevice9Vtbl Direct3DDevice9_Vtbl = +{ + /* IUnknown */ + IDirect3DDevice9Impl_QueryInterface, + IDirect3DDevice9Impl_AddRef, + IDirect3DDevice9Impl_Release, + /* IDirect3DDevice9 */ + IDirect3DDevice9Impl_TestCooperativeLevel, + IDirect3DDevice9Impl_GetAvailableTextureMem, + IDirect3DDevice9Impl_EvictManagedResources, + IDirect3DDevice9Impl_GetDirect3D, + IDirect3DDevice9Impl_GetDeviceCaps, + IDirect3DDevice9Impl_GetDisplayMode, + IDirect3DDevice9Impl_GetCreationParameters, + IDirect3DDevice9Impl_SetCursorProperties, + IDirect3DDevice9Impl_SetCursorPosition, + IDirect3DDevice9Impl_ShowCursor, + IDirect3DDevice9Impl_CreateAdditionalSwapChain, + IDirect3DDevice9Impl_GetSwapChain, + IDirect3DDevice9Impl_GetNumberOfSwapChains, + IDirect3DDevice9Impl_Reset, + IDirect3DDevice9Impl_Present, + IDirect3DDevice9Impl_GetBackBuffer, + IDirect3DDevice9Impl_GetRasterStatus, + IDirect3DDevice9Impl_SetDialogBoxMode, + IDirect3DDevice9Impl_SetGammaRamp, + IDirect3DDevice9Impl_GetGammaRamp, + IDirect3DDevice9Impl_CreateTexture, + IDirect3DDevice9Impl_CreateVolumeTexture, + IDirect3DDevice9Impl_CreateCubeTexture, + IDirect3DDevice9Impl_CreateVertexBuffer, + IDirect3DDevice9Impl_CreateIndexBuffer, + IDirect3DDevice9Impl_CreateRenderTarget, + IDirect3DDevice9Impl_CreateDepthStencilSurface, + IDirect3DDevice9Impl_UpdateSurface, + IDirect3DDevice9Impl_UpdateTexture, + IDirect3DDevice9Impl_GetRenderTargetData, + IDirect3DDevice9Impl_GetFrontBufferData, + IDirect3DDevice9Impl_StretchRect, + IDirect3DDevice9Impl_ColorFill, + IDirect3DDevice9Impl_CreateOffscreenPlainSurface, + IDirect3DDevice9Impl_SetRenderTarget, + IDirect3DDevice9Impl_GetRenderTarget, + IDirect3DDevice9Impl_SetDepthStencilSurface, + IDirect3DDevice9Impl_GetDepthStencilSurface, + IDirect3DDevice9Impl_BeginScene, + IDirect3DDevice9Impl_EndScene, + IDirect3DDevice9Impl_Clear, + IDirect3DDevice9Impl_SetTransform, + IDirect3DDevice9Impl_GetTransform, + IDirect3DDevice9Impl_MultiplyTransform, + IDirect3DDevice9Impl_SetViewport, + IDirect3DDevice9Impl_GetViewport, + IDirect3DDevice9Impl_SetMaterial, + IDirect3DDevice9Impl_GetMaterial, + IDirect3DDevice9Impl_SetLight, + IDirect3DDevice9Impl_GetLight, + IDirect3DDevice9Impl_LightEnable, + IDirect3DDevice9Impl_GetLightEnable, + IDirect3DDevice9Impl_SetClipPlane, + IDirect3DDevice9Impl_GetClipPlane, + IDirect3DDevice9Impl_SetRenderState, + IDirect3DDevice9Impl_GetRenderState, + IDirect3DDevice9Impl_CreateStateBlock, + IDirect3DDevice9Impl_BeginStateBlock, + IDirect3DDevice9Impl_EndStateBlock, + IDirect3DDevice9Impl_SetClipStatus, + IDirect3DDevice9Impl_GetClipStatus, + IDirect3DDevice9Impl_GetTexture, + IDirect3DDevice9Impl_SetTexture, + IDirect3DDevice9Impl_GetTextureStageState, + IDirect3DDevice9Impl_SetTextureStageState, + IDirect3DDevice9Impl_GetSamplerState, + IDirect3DDevice9Impl_SetSamplerState, + IDirect3DDevice9Impl_ValidateDevice, + IDirect3DDevice9Impl_SetPaletteEntries, + IDirect3DDevice9Impl_GetPaletteEntries, + IDirect3DDevice9Impl_SetCurrentTexturePalette, + IDirect3DDevice9Impl_GetCurrentTexturePalette, + IDirect3DDevice9Impl_SetScissorRect, + IDirect3DDevice9Impl_GetScissorRect, + IDirect3DDevice9Impl_SetSoftwareVertexProcessing, + IDirect3DDevice9Impl_GetSoftwareVertexProcessing, + IDirect3DDevice9Impl_SetNPatchMode, + IDirect3DDevice9Impl_GetNPatchMode, + IDirect3DDevice9Impl_DrawPrimitive, + IDirect3DDevice9Impl_DrawIndexedPrimitive, + IDirect3DDevice9Impl_DrawPrimitiveUP, + IDirect3DDevice9Impl_DrawIndexedPrimitiveUP, + IDirect3DDevice9Impl_ProcessVertices, + IDirect3DDevice9Impl_CreateVertexDeclaration, + IDirect3DDevice9Impl_SetVertexDeclaration, + IDirect3DDevice9Impl_GetVertexDeclaration, + IDirect3DDevice9Impl_SetFVF, + IDirect3DDevice9Impl_GetFVF, + IDirect3DDevice9Impl_CreateVertexShader, + IDirect3DDevice9Impl_SetVertexShader, + IDirect3DDevice9Impl_GetVertexShader, + IDirect3DDevice9Impl_SetVertexShaderConstantF, + IDirect3DDevice9Impl_GetVertexShaderConstantF, + IDirect3DDevice9Impl_SetVertexShaderConstantI, + IDirect3DDevice9Impl_GetVertexShaderConstantI, + IDirect3DDevice9Impl_SetVertexShaderConstantB, + IDirect3DDevice9Impl_GetVertexShaderConstantB, + IDirect3DDevice9Impl_SetStreamSource, + IDirect3DDevice9Impl_GetStreamSource, + IDirect3DDevice9Impl_SetStreamSourceFreq, + IDirect3DDevice9Impl_GetStreamSourceFreq, + IDirect3DDevice9Impl_SetIndices, + IDirect3DDevice9Impl_GetIndices, + IDirect3DDevice9Impl_CreatePixelShader, + IDirect3DDevice9Impl_SetPixelShader, + IDirect3DDevice9Impl_GetPixelShader, + IDirect3DDevice9Impl_SetPixelShaderConstantF, + IDirect3DDevice9Impl_GetPixelShaderConstantF, + IDirect3DDevice9Impl_SetPixelShaderConstantI, + IDirect3DDevice9Impl_GetPixelShaderConstantI, + IDirect3DDevice9Impl_SetPixelShaderConstantB, + IDirect3DDevice9Impl_GetPixelShaderConstantB, + IDirect3DDevice9Impl_DrawRectPatch, + IDirect3DDevice9Impl_DrawTriPatch, + IDirect3DDevice9Impl_DeletePatch, + IDirect3DDevice9Impl_CreateQuery +}; + + +/* Internal function called back during the CreateDevice to create a render target */ +HRESULT WINAPI D3D9CB_CreateSurface(IUnknown *device, IUnknown *pSuperior, UINT Width, UINT Height, + WINED3DFORMAT Format, DWORD Usage, WINED3DPOOL Pool, UINT Level, + WINED3DCUBEMAP_FACES Face,IWineD3DSurface** ppSurface, + HANDLE* pSharedHandle) { + + HRESULT res = D3D_OK; + IDirect3DSurface9Impl *d3dSurface = NULL; + BOOL Lockable = TRUE; + + if((Pool == D3DPOOL_DEFAULT && Usage != D3DUSAGE_DYNAMIC)) + Lockable = FALSE; + + TRACE("relay\n"); + res = IDirect3DDevice9Impl_CreateSurface((IDirect3DDevice9 *)device, Width, Height, (D3DFORMAT)Format, + Lockable, FALSE/*Discard*/, Level, (IDirect3DSurface9 **)&d3dSurface, D3DRTYPE_SURFACE, + Usage, (D3DPOOL) Pool, D3DMULTISAMPLE_NONE, 0 /* MultisampleQuality */, pSharedHandle); + + if (SUCCEEDED(res)) { + *ppSurface = d3dSurface->wineD3DSurface; + d3dSurface->container = pSuperior; + IUnknown_Release(d3dSurface->parentDevice); + d3dSurface->parentDevice = NULL; + d3dSurface->forwardReference = pSuperior; + } else { + FIXME("(%p) IDirect3DDevice9_CreateSurface failed\n", device); + } + return res; +} + +ULONG WINAPI D3D9CB_DestroySurface(IWineD3DSurface *pSurface) { + IDirect3DSurface9Impl* surfaceParent; + TRACE("(%p) call back\n", pSurface); + + IWineD3DSurface_GetParent(pSurface, (IUnknown **) &surfaceParent); + /* GetParent's AddRef was forwarded to an object in destruction. + * Releasing it here again would cause an endless recursion. */ + surfaceParent->forwardReference = NULL; + return IDirect3DSurface9_Release((IDirect3DSurface9*) surfaceParent); +} diff --git a/reactos/dll/directx/wine/d3d9/directx.c b/reactos/dll/directx/wine/d3d9/directx.c new file mode 100644 index 00000000000..28268f81684 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/directx.c @@ -0,0 +1,566 @@ +/* + * 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); + +/* IDirect3D9 IUnknown parts follow: */ +static HRESULT WINAPI IDirect3D9Impl_QueryInterface(LPDIRECT3D9 iface, REFIID riid, LPVOID* ppobj) +{ + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3D9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3D9Impl_AddRef(LPDIRECT3D9 iface) { + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + + return ref; +} + +static ULONG WINAPI IDirect3D9Impl_Release(LPDIRECT3D9 iface) { + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + ULONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + EnterCriticalSection(&d3d9_cs); + IWineD3D_Release(This->WineD3D); + LeaveCriticalSection(&d3d9_cs); + HeapFree(GetProcessHeap(), 0, This); + } + + return ref; +} + +/* IDirect3D9 Interface follow: */ +static HRESULT WINAPI IDirect3D9Impl_RegisterSoftwareDevice(LPDIRECT3D9 iface, void* pInitializeFunction) { + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + HRESULT hr; + TRACE("(%p)->(%p)\n", This, pInitializeFunction); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3D_RegisterSoftwareDevice(This->WineD3D, pInitializeFunction); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static UINT WINAPI IDirect3D9Impl_GetAdapterCount(LPDIRECT3D9 iface) { + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + HRESULT hr; + TRACE("%p\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3D_GetAdapterCount(This->WineD3D); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3D9Impl_GetAdapterIdentifier(LPDIRECT3D9 iface, UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER9* pIdentifier) { + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + WINED3DADAPTER_IDENTIFIER adapter_id; + HRESULT hr; + + /* dx8 and dx9 have different structures to be filled in, with incompatible + layouts so pass in pointers to the places to be filled via an internal + structure */ + adapter_id.Driver = pIdentifier->Driver; + adapter_id.Description = pIdentifier->Description; + adapter_id.DeviceName = pIdentifier->DeviceName; + adapter_id.DriverVersion = &pIdentifier->DriverVersion; + adapter_id.VendorId = &pIdentifier->VendorId; + adapter_id.DeviceId = &pIdentifier->DeviceId; + adapter_id.SubSysId = &pIdentifier->SubSysId; + adapter_id.Revision = &pIdentifier->Revision; + adapter_id.DeviceIdentifier = &pIdentifier->DeviceIdentifier; + adapter_id.WHQLLevel = &pIdentifier->WHQLLevel; + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3D_GetAdapterIdentifier(This->WineD3D, Adapter, Flags, &adapter_id); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static UINT WINAPI IDirect3D9Impl_GetAdapterModeCount(LPDIRECT3D9 iface, UINT Adapter, D3DFORMAT Format) { + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + HRESULT hr; + TRACE("(%p)->(%d, %d\n", This, 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; + } + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3D_GetAdapterModeCount(This->WineD3D, Adapter, Format); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3D9Impl_EnumAdapterModes(LPDIRECT3D9 iface, UINT Adapter, D3DFORMAT Format, UINT Mode, D3DDISPLAYMODE* pMode) { + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + HRESULT hr; + TRACE("(%p)->(%d, %d, %d, %p)\n", This, Adapter, Format, Mode, pMode); + /* We can't pass this to WineD3D, otherwise it'll think it came from D3D8 or DDraw. + It's supposed to fail anyway, so no harm returning failure. */ + if(Format != WINED3DFMT_X8R8G8B8 && Format != WINED3DFMT_R5G6B5) + return D3DERR_INVALIDCALL; + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3D_EnumAdapterModes(This->WineD3D, Adapter, Format, Mode, (WINED3DDISPLAYMODE *) pMode); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3D9Impl_GetAdapterDisplayMode(LPDIRECT3D9 iface, UINT Adapter, D3DDISPLAYMODE* pMode) { + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + return IWineD3D_GetAdapterDisplayMode(This->WineD3D, Adapter, (WINED3DDISPLAYMODE *) pMode); +} + +static HRESULT WINAPI IDirect3D9Impl_CheckDeviceType(LPDIRECT3D9 iface, + UINT Adapter, D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat, + D3DFORMAT BackBufferFormat, BOOL Windowed) { + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + HRESULT hr; + TRACE("(%p)->(%d, %d, %d, %d, %s\n", This, Adapter, CheckType, DisplayFormat, + BackBufferFormat, Windowed ? "true" : "false"); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3D_CheckDeviceType(This->WineD3D, Adapter, CheckType, DisplayFormat, + BackBufferFormat, Windowed); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3D9Impl_CheckDeviceFormat(LPDIRECT3D9 iface, + UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, + DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat) { + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + HRESULT hr; + TRACE("%p\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3D_CheckDeviceFormat(This->WineD3D, Adapter, DeviceType, AdapterFormat, + Usage, RType, CheckFormat); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3D9Impl_CheckDeviceMultiSampleType(LPDIRECT3D9 iface, + UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, + BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType, DWORD* pQualityLevels) { + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + HRESULT hr; + TRACE("%p\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3D_CheckDeviceMultiSampleType(This->WineD3D, Adapter, DeviceType, SurfaceFormat, + Windowed, MultiSampleType, pQualityLevels); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3D9Impl_CheckDepthStencilMatch(LPDIRECT3D9 iface, + UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, + D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat) { + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + HRESULT hr; + TRACE("%p\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3D_CheckDepthStencilMatch(This->WineD3D, Adapter, DeviceType, AdapterFormat, + RenderTargetFormat, DepthStencilFormat); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3D9Impl_CheckDeviceFormatConversion(LPDIRECT3D9 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SourceFormat, D3DFORMAT TargetFormat) { + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + HRESULT hr; + TRACE("%p\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3D_CheckDeviceFormatConversion(This->WineD3D, Adapter, DeviceType, SourceFormat, + TargetFormat); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +void filter_caps(D3DCAPS9* pCaps) +{ + + 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; +} + +static HRESULT WINAPI IDirect3D9Impl_GetDeviceCaps(LPDIRECT3D9 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS9* pCaps) { + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + HRESULT hrc = D3D_OK; + WINED3DCAPS *pWineCaps; + + TRACE("(%p) Relay %d %u %p\n", This, Adapter, DeviceType, pCaps); + + if(NULL == pCaps){ + return D3DERR_INVALIDCALL; + } + pWineCaps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINED3DCAPS)); + if(pWineCaps == NULL){ + return D3DERR_INVALIDCALL; /*well this is what MSDN says to return*/ + } + memset(pCaps, 0, sizeof(*pCaps)); + D3D9CAPSTOWINECAPS(pCaps, pWineCaps) + EnterCriticalSection(&d3d9_cs); + hrc = IWineD3D_GetDeviceCaps(This->WineD3D, Adapter, DeviceType, pWineCaps); + LeaveCriticalSection(&d3d9_cs); + HeapFree(GetProcessHeap(), 0, pWineCaps); + + /* Some functionality is implemented in d3d9.dll, not wined3d.dll. Add the needed caps */ + pCaps->DevCaps2 |= D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES; + + filter_caps(pCaps); + + TRACE("(%p) returning %p\n", This, pCaps); + return hrc; +} + +static HMONITOR WINAPI IDirect3D9Impl_GetAdapterMonitor(LPDIRECT3D9 iface, UINT Adapter) { + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + HMONITOR ret; + TRACE("%p\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3D_GetAdapterMonitor(This->WineD3D, Adapter); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +/* Internal function called back during the CreateDevice to create a render target */ +HRESULT WINAPI D3D9CB_CreateRenderTarget(IUnknown *device, IUnknown *pSuperior, UINT Width, UINT Height, + WINED3DFORMAT Format, WINED3DMULTISAMPLE_TYPE MultiSample, + DWORD MultisampleQuality, BOOL Lockable, + IWineD3DSurface** ppSurface, HANDLE* pSharedHandle) { + HRESULT res = D3D_OK; + IDirect3DSurface9Impl *d3dSurface = NULL; + TRACE("(%p) call back\n", device); + res = IDirect3DDevice9_CreateRenderTarget((IDirect3DDevice9 *)device, Width, Height, + (D3DFORMAT)Format, MultiSample, MultisampleQuality, Lockable, + (IDirect3DSurface9 **)&d3dSurface, pSharedHandle); + + if (SUCCEEDED(res)) { + *ppSurface = d3dSurface->wineD3DSurface; + d3dSurface->container = pSuperior; + d3dSurface->isImplicit = TRUE; + /* Implicit surfaces are created with an refcount of 0 */ + IUnknown_Release((IUnknown *)d3dSurface); + } else { + *ppSurface = NULL; + } + return res; +} + +ULONG WINAPI D3D9CB_DestroyRenderTarget(IWineD3DSurface *pSurface) { + IDirect3DSurface9Impl* surfaceParent; + TRACE("(%p) call back\n", pSurface); + + IWineD3DSurface_GetParent(pSurface, (IUnknown **) &surfaceParent); + surfaceParent->isImplicit = FALSE; + /* Surface had refcount of 0 GetParent addrefed to 1, so 1 Release is enough */ + return IDirect3DSurface9_Release((IDirect3DSurface9*) surfaceParent); +} + +static HRESULT WINAPI D3D9CB_CreateAdditionalSwapChain(IUnknown *device, + WINED3DPRESENT_PARAMETERS* pPresentationParameters, + IWineD3DSwapChain ** ppSwapChain) { + HRESULT res = D3D_OK; + IDirect3DSwapChain9Impl *d3dSwapChain = NULL; + D3DPRESENT_PARAMETERS localParameters; + TRACE("(%p) call back\n", device); + + /* Copy the presentation parameters */ + localParameters.BackBufferWidth = pPresentationParameters->BackBufferWidth; + localParameters.BackBufferHeight = pPresentationParameters->BackBufferHeight; + localParameters.BackBufferFormat = pPresentationParameters->BackBufferFormat; + localParameters.BackBufferCount = pPresentationParameters->BackBufferCount; + localParameters.MultiSampleType = pPresentationParameters->MultiSampleType; + localParameters.MultiSampleQuality = pPresentationParameters->MultiSampleQuality; + localParameters.SwapEffect = pPresentationParameters->SwapEffect; + localParameters.hDeviceWindow = pPresentationParameters->hDeviceWindow; + localParameters.Windowed = pPresentationParameters->Windowed; + localParameters.EnableAutoDepthStencil = pPresentationParameters->EnableAutoDepthStencil; + localParameters.AutoDepthStencilFormat = pPresentationParameters->AutoDepthStencilFormat; + localParameters.Flags = pPresentationParameters->Flags; + localParameters.FullScreen_RefreshRateInHz = pPresentationParameters->FullScreen_RefreshRateInHz; + localParameters.PresentationInterval = pPresentationParameters->PresentationInterval; + + res = IDirect3DDevice9_CreateAdditionalSwapChain((IDirect3DDevice9 *)device, &localParameters, (IDirect3DSwapChain9 **)&d3dSwapChain); + + if (SUCCEEDED(res)) { + *ppSwapChain = d3dSwapChain->wineD3DSwapChain; + d3dSwapChain->isImplicit = TRUE; + /* Implicit swap chains are created with an refcount of 0 */ + IUnknown_Release((IUnknown *)d3dSwapChain); + } else { + *ppSwapChain = NULL; + } + + /* Copy back the presentation parameters */ + pPresentationParameters->BackBufferWidth = localParameters.BackBufferWidth; + pPresentationParameters->BackBufferHeight = localParameters.BackBufferHeight; + pPresentationParameters->BackBufferFormat = localParameters.BackBufferFormat; + pPresentationParameters->BackBufferCount = localParameters.BackBufferCount; + pPresentationParameters->MultiSampleType = localParameters.MultiSampleType; + pPresentationParameters->MultiSampleQuality = localParameters.MultiSampleQuality; + pPresentationParameters->SwapEffect = localParameters.SwapEffect; + pPresentationParameters->hDeviceWindow = localParameters.hDeviceWindow; + pPresentationParameters->Windowed = localParameters.Windowed; + pPresentationParameters->EnableAutoDepthStencil = localParameters.EnableAutoDepthStencil; + pPresentationParameters->AutoDepthStencilFormat = localParameters.AutoDepthStencilFormat; + pPresentationParameters->Flags = localParameters.Flags; + pPresentationParameters->FullScreen_RefreshRateInHz = localParameters.FullScreen_RefreshRateInHz; + pPresentationParameters->PresentationInterval = localParameters.PresentationInterval; + + return res; +} + +ULONG WINAPI D3D9CB_DestroySwapChain(IWineD3DSwapChain *pSwapChain) { + IDirect3DSwapChain9Impl* swapChainParent; + TRACE("(%p) call back\n", pSwapChain); + + IWineD3DSwapChain_GetParent(pSwapChain,(IUnknown **) &swapChainParent); + swapChainParent->isImplicit = FALSE; + /* Swap chain had refcount of 0 GetParent addrefed to 1, so 1 Release is enough */ + return IDirect3DSwapChain9_Release((IDirect3DSwapChain9*) swapChainParent); +} + +/* Internal function called back during the CreateDevice to create a render target */ +HRESULT WINAPI D3D9CB_CreateDepthStencilSurface(IUnknown *device, IUnknown *pSuperior, UINT Width, UINT Height, + WINED3DFORMAT Format, WINED3DMULTISAMPLE_TYPE MultiSample, + DWORD MultisampleQuality, BOOL Discard, + IWineD3DSurface** ppSurface, HANDLE* pSharedHandle) { + HRESULT res = D3D_OK; + IDirect3DSurface9Impl *d3dSurface = NULL; + TRACE("(%p) call back\n", device); + + res = IDirect3DDevice9_CreateDepthStencilSurface((IDirect3DDevice9 *)device, Width, Height, + (D3DFORMAT)Format, MultiSample, MultisampleQuality, Discard, + (IDirect3DSurface9 **)&d3dSurface, pSharedHandle); + if (SUCCEEDED(res)) { + *ppSurface = d3dSurface->wineD3DSurface; + d3dSurface->container = device; + d3dSurface->isImplicit = TRUE; + /* Implicit surfaces are created with an refcount of 0 */ + IUnknown_Release((IUnknown *)d3dSurface); + } + return res; +} + +ULONG WINAPI D3D9CB_DestroyDepthStencilSurface(IWineD3DSurface *pSurface) { + IDirect3DSurface9Impl* surfaceParent; + TRACE("(%p) call back\n", pSurface); + + IWineD3DSurface_GetParent(pSurface, (IUnknown **) &surfaceParent); + surfaceParent->isImplicit = FALSE; + /* Surface had refcount of 0 GetParent addrefed to 1, so 1 Release is enough */ + return IDirect3DSurface9_Release((IDirect3DSurface9*) surfaceParent); +} + +static HRESULT WINAPI IDirect3D9Impl_CreateDevice(LPDIRECT3D9 iface, UINT Adapter, D3DDEVTYPE DeviceType, + HWND hFocusWindow, DWORD BehaviourFlags, + D3DPRESENT_PARAMETERS* pPresentationParameters, + IDirect3DDevice9** ppReturnedDeviceInterface) { + + IDirect3D9Impl *This = (IDirect3D9Impl *)iface; + IDirect3DDevice9Impl *object = NULL; + WINED3DPRESENT_PARAMETERS localParameters; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + /* Check the validity range of the adapter parameter */ + if (Adapter >= IDirect3D9Impl_GetAdapterCount(iface)) { + *ppReturnedDeviceInterface = NULL; + return D3DERR_INVALIDCALL; + } + + /* Allocate the storage for the device object */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DDevice9Impl)); + if (NULL == object) { + FIXME("Allocation of memory failed\n"); + *ppReturnedDeviceInterface = NULL; + return D3DERR_OUTOFVIDEOMEMORY; + } + + object->lpVtbl = &Direct3DDevice9_Vtbl; + object->ref = 1; + *ppReturnedDeviceInterface = (IDirect3DDevice9 *)object; + + /* Allocate an associated WineD3DDevice object */ + EnterCriticalSection(&d3d9_cs); + hr =IWineD3D_CreateDevice(This->WineD3D, Adapter, DeviceType, hFocusWindow, BehaviourFlags, &object->WineD3DDevice, (IUnknown *)object); + + if (hr != D3D_OK) { + HeapFree(GetProcessHeap(), 0, object); + *ppReturnedDeviceInterface = NULL; + LeaveCriticalSection(&d3d9_cs); + return hr; + } + + TRACE("(%p) : Created Device %p\n", This, object); + + localParameters.BackBufferWidth = pPresentationParameters->BackBufferWidth; + localParameters.BackBufferHeight = pPresentationParameters->BackBufferHeight; + localParameters.BackBufferFormat = pPresentationParameters->BackBufferFormat; + localParameters.BackBufferCount = pPresentationParameters->BackBufferCount; + localParameters.MultiSampleType = pPresentationParameters->MultiSampleType; + localParameters.MultiSampleQuality = pPresentationParameters->MultiSampleQuality; + localParameters.SwapEffect = pPresentationParameters->SwapEffect; + localParameters.hDeviceWindow = pPresentationParameters->hDeviceWindow; + localParameters.Windowed = pPresentationParameters->Windowed; + localParameters.EnableAutoDepthStencil = pPresentationParameters->EnableAutoDepthStencil; + localParameters.AutoDepthStencilFormat = pPresentationParameters->AutoDepthStencilFormat; + localParameters.Flags = pPresentationParameters->Flags; + localParameters.FullScreen_RefreshRateInHz = pPresentationParameters->FullScreen_RefreshRateInHz; + localParameters.PresentationInterval = pPresentationParameters->PresentationInterval; + + if(BehaviourFlags & D3DCREATE_MULTITHREADED) { + IWineD3DDevice_SetMultithreaded(object->WineD3DDevice); + } + + hr = IWineD3DDevice_Init3D(object->WineD3DDevice, &localParameters, D3D9CB_CreateAdditionalSwapChain); + + pPresentationParameters->BackBufferWidth = localParameters.BackBufferWidth; + pPresentationParameters->BackBufferHeight = localParameters.BackBufferHeight; + pPresentationParameters->BackBufferFormat = localParameters.BackBufferFormat; + pPresentationParameters->BackBufferCount = localParameters.BackBufferCount; + pPresentationParameters->MultiSampleType = localParameters.MultiSampleType; + pPresentationParameters->MultiSampleQuality = localParameters.MultiSampleQuality; + pPresentationParameters->SwapEffect = localParameters.SwapEffect; + pPresentationParameters->hDeviceWindow = localParameters.hDeviceWindow; + pPresentationParameters->Windowed = localParameters.Windowed; + pPresentationParameters->EnableAutoDepthStencil = localParameters.EnableAutoDepthStencil; + pPresentationParameters->AutoDepthStencilFormat = localParameters.AutoDepthStencilFormat; + pPresentationParameters->Flags = localParameters.Flags; + pPresentationParameters->FullScreen_RefreshRateInHz = localParameters.FullScreen_RefreshRateInHz; + pPresentationParameters->PresentationInterval = localParameters.PresentationInterval; + + if (hr != D3D_OK) { + FIXME("(%p) D3D Initialization failed for WineD3DDevice %p\n", This, object->WineD3DDevice); + HeapFree(GetProcessHeap(), 0, object); + *ppReturnedDeviceInterface = NULL; + } + + /* Initialize the converted declaration array. This creates a valid pointer and when adding decls HeapReAlloc + * can be used without further checking + */ + object->convertedDecls = HeapAlloc(GetProcessHeap(), 0, 0); + LeaveCriticalSection(&d3d9_cs); + + return hr; +} + + + +const IDirect3D9Vtbl Direct3D9_Vtbl = +{ + /* IUnknown */ + IDirect3D9Impl_QueryInterface, + IDirect3D9Impl_AddRef, + IDirect3D9Impl_Release, + /* IDirect3D9 */ + IDirect3D9Impl_RegisterSoftwareDevice, + IDirect3D9Impl_GetAdapterCount, + IDirect3D9Impl_GetAdapterIdentifier, + IDirect3D9Impl_GetAdapterModeCount, + IDirect3D9Impl_EnumAdapterModes, + IDirect3D9Impl_GetAdapterDisplayMode, + IDirect3D9Impl_CheckDeviceType, + IDirect3D9Impl_CheckDeviceFormat, + IDirect3D9Impl_CheckDeviceMultiSampleType, + IDirect3D9Impl_CheckDepthStencilMatch, + IDirect3D9Impl_CheckDeviceFormatConversion, + IDirect3D9Impl_GetDeviceCaps, + IDirect3D9Impl_GetAdapterMonitor, + IDirect3D9Impl_CreateDevice +}; diff --git a/reactos/dll/directx/wine/d3d9/indexbuffer.c b/reactos/dll/directx/wine/d3d9/indexbuffer.c new file mode 100644 index 00000000000..d886bd7db89 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/indexbuffer.c @@ -0,0 +1,246 @@ +/* + * IDirect3DIndexBuffer9 implementation + * + * Copyright 2002-2004 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); + +/* IDirect3DIndexBuffer9 IUnknown parts follow: */ +static HRESULT WINAPI IDirect3DIndexBuffer9Impl_QueryInterface(LPDIRECT3DINDEXBUFFER9 iface, REFIID riid, LPVOID* ppobj) { + IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface; + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IDirect3DIndexBuffer9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3DIndexBuffer9Impl_AddRef(LPDIRECT3DINDEXBUFFER9 iface) { + IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface; + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + + return ref; +} + +static ULONG WINAPI IDirect3DIndexBuffer9Impl_Release(LPDIRECT3DINDEXBUFFER9 iface) { + IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface; + ULONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + EnterCriticalSection(&d3d9_cs); + IWineD3DIndexBuffer_Release(This->wineD3DIndexBuffer); + LeaveCriticalSection(&d3d9_cs); + IUnknown_Release(This->parentDevice); + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DIndexBuffer9 IDirect3DResource9 Interface follow: */ +static HRESULT WINAPI IDirect3DIndexBuffer9Impl_GetDevice(LPDIRECT3DINDEXBUFFER9 iface, IDirect3DDevice9** ppDevice) { + IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IDirect3DResource9Impl_GetDevice((LPDIRECT3DRESOURCE9) This, ppDevice); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DIndexBuffer9Impl_SetPrivateData(LPDIRECT3DINDEXBUFFER9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DIndexBuffer_SetPrivateData(This->wineD3DIndexBuffer, refguid, pData, SizeOfData, Flags); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DIndexBuffer9Impl_GetPrivateData(LPDIRECT3DINDEXBUFFER9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DIndexBuffer_GetPrivateData(This->wineD3DIndexBuffer, refguid, pData, pSizeOfData); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DIndexBuffer9Impl_FreePrivateData(LPDIRECT3DINDEXBUFFER9 iface, REFGUID refguid) { + IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DIndexBuffer_FreePrivateData(This->wineD3DIndexBuffer, refguid); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static DWORD WINAPI IDirect3DIndexBuffer9Impl_SetPriority(LPDIRECT3DINDEXBUFFER9 iface, DWORD PriorityNew) { + IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface; + DWORD ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DIndexBuffer_SetPriority(This->wineD3DIndexBuffer, PriorityNew); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +static DWORD WINAPI IDirect3DIndexBuffer9Impl_GetPriority(LPDIRECT3DINDEXBUFFER9 iface) { + IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface; + DWORD ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DIndexBuffer_GetPriority(This->wineD3DIndexBuffer); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +static void WINAPI IDirect3DIndexBuffer9Impl_PreLoad(LPDIRECT3DINDEXBUFFER9 iface) { + IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + IWineD3DIndexBuffer_PreLoad(This->wineD3DIndexBuffer); + LeaveCriticalSection(&d3d9_cs); +} + +static D3DRESOURCETYPE WINAPI IDirect3DIndexBuffer9Impl_GetType(LPDIRECT3DINDEXBUFFER9 iface) { + IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface; + D3DRESOURCETYPE ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DIndexBuffer_GetType(This->wineD3DIndexBuffer); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +/* IDirect3DIndexBuffer9 Interface follow: */ +static HRESULT WINAPI IDirect3DIndexBuffer9Impl_Lock(LPDIRECT3DINDEXBUFFER9 iface, UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags) { + IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DIndexBuffer_Lock(This->wineD3DIndexBuffer, OffsetToLock, SizeToLock, (BYTE **)ppbData, Flags); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DIndexBuffer9Impl_Unlock(LPDIRECT3DINDEXBUFFER9 iface) { + IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DIndexBuffer_Unlock(This->wineD3DIndexBuffer); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DIndexBuffer9Impl_GetDesc(LPDIRECT3DINDEXBUFFER9 iface, D3DINDEXBUFFER_DESC *pDesc) { + IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DIndexBuffer_GetDesc(This->wineD3DIndexBuffer, (WINED3DINDEXBUFFER_DESC *) pDesc); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + + +static const IDirect3DIndexBuffer9Vtbl Direct3DIndexBuffer9_Vtbl = +{ + /* IUnknown */ + IDirect3DIndexBuffer9Impl_QueryInterface, + IDirect3DIndexBuffer9Impl_AddRef, + IDirect3DIndexBuffer9Impl_Release, + /* IDirect3DResource9 */ + IDirect3DIndexBuffer9Impl_GetDevice, + IDirect3DIndexBuffer9Impl_SetPrivateData, + IDirect3DIndexBuffer9Impl_GetPrivateData, + IDirect3DIndexBuffer9Impl_FreePrivateData, + IDirect3DIndexBuffer9Impl_SetPriority, + IDirect3DIndexBuffer9Impl_GetPriority, + IDirect3DIndexBuffer9Impl_PreLoad, + IDirect3DIndexBuffer9Impl_GetType, + /* IDirect3DIndexBuffer9 */ + IDirect3DIndexBuffer9Impl_Lock, + IDirect3DIndexBuffer9Impl_Unlock, + IDirect3DIndexBuffer9Impl_GetDesc +}; + + +/* IDirect3DDevice9 IDirect3DIndexBuffer9 Methods follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_CreateIndexBuffer(LPDIRECT3DDEVICE9 iface, + UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, + IDirect3DIndexBuffer9** ppIndexBuffer, HANDLE* pSharedHandle) { + + IDirect3DIndexBuffer9Impl *object; + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hrc = D3D_OK; + + TRACE("(%p) Relay\n", This); + /* Allocate the storage for the device */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (NULL == object) { + FIXME("Allocation of memory failed, returning D3DERR_OUTOFVIDEOMEMORY\n"); + return D3DERR_OUTOFVIDEOMEMORY; + } + + object->lpVtbl = &Direct3DIndexBuffer9_Vtbl; + object->ref = 1; + TRACE("Calling wined3d create index buffer\n"); + hrc = IWineD3DDevice_CreateIndexBuffer(This->WineD3DDevice, Length, Usage & WINED3DUSAGE_MASK, Format, (WINED3DPOOL) Pool, &object->wineD3DIndexBuffer, pSharedHandle, (IUnknown *)object); + if (hrc != D3D_OK) { + + /* free up object */ + FIXME("(%p) call to IWineD3DDevice_CreateIndexBuffer failed\n", This); + HeapFree(GetProcessHeap(), 0, object); + } else { + IUnknown_AddRef(iface); + object->parentDevice = iface; + *ppIndexBuffer = (LPDIRECT3DINDEXBUFFER9) object; + TRACE("(%p) : Created index buffer %p\n", This, object); + } + return hrc; +} diff --git a/reactos/dll/directx/wine/d3d9/pixelshader.c b/reactos/dll/directx/wine/d3d9/pixelshader.c new file mode 100644 index 00000000000..8eeb3d60bf6 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/pixelshader.c @@ -0,0 +1,244 @@ +/* + * IDirect3DPixelShader9 implementation + * + * 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); + +/* IDirect3DPixelShader9 IUnknown parts follow: */ +static HRESULT WINAPI IDirect3DPixelShader9Impl_QueryInterface(LPDIRECT3DPIXELSHADER9 iface, REFIID riid, LPVOID* ppobj) { + IDirect3DPixelShader9Impl *This = (IDirect3DPixelShader9Impl *)iface; + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DPixelShader9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3DPixelShader9Impl_AddRef(LPDIRECT3DPIXELSHADER9 iface) { + IDirect3DPixelShader9Impl *This = (IDirect3DPixelShader9Impl *)iface; + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + + return ref; +} + +static ULONG WINAPI IDirect3DPixelShader9Impl_Release(LPDIRECT3DPIXELSHADER9 iface) { + IDirect3DPixelShader9Impl *This = (IDirect3DPixelShader9Impl *)iface; + ULONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + EnterCriticalSection(&d3d9_cs); + IWineD3DPixelShader_Release(This->wineD3DPixelShader); + LeaveCriticalSection(&d3d9_cs); + IUnknown_Release(This->parentDevice); + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DPixelShader9 Interface follow: */ +static HRESULT WINAPI IDirect3DPixelShader9Impl_GetDevice(LPDIRECT3DPIXELSHADER9 iface, IDirect3DDevice9** ppDevice) { + IDirect3DPixelShader9Impl *This = (IDirect3DPixelShader9Impl *)iface; + IWineD3DDevice *myDevice = NULL; + + TRACE("(%p) : Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + IWineD3DPixelShader_GetDevice(This->wineD3DPixelShader, &myDevice); + IWineD3DDevice_GetParent(myDevice, (IUnknown **)ppDevice); + IWineD3DDevice_Release(myDevice); + LeaveCriticalSection(&d3d9_cs); + TRACE("(%p) returning (%p)\n", This, *ppDevice); + return D3D_OK; +} + +static HRESULT WINAPI IDirect3DPixelShader9Impl_GetFunction(LPDIRECT3DPIXELSHADER9 iface, VOID* pData, UINT* pSizeOfData) { + IDirect3DPixelShader9Impl *This = (IDirect3DPixelShader9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DPixelShader_GetFunction(This->wineD3DPixelShader, pData, pSizeOfData); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + + +static const IDirect3DPixelShader9Vtbl Direct3DPixelShader9_Vtbl = +{ + /* IUnknown */ + IDirect3DPixelShader9Impl_QueryInterface, + IDirect3DPixelShader9Impl_AddRef, + IDirect3DPixelShader9Impl_Release, + /* IDirect3DPixelShader9 */ + IDirect3DPixelShader9Impl_GetDevice, + IDirect3DPixelShader9Impl_GetFunction +}; + + +/* IDirect3DDevice9 IDirect3DPixelShader9 Methods follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_CreatePixelShader(LPDIRECT3DDEVICE9 iface, CONST DWORD* pFunction, IDirect3DPixelShader9** ppShader) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IDirect3DPixelShader9Impl *object; + HRESULT hrc = D3D_OK; + + TRACE("(%p) Relay\n", This); + + if (ppShader == NULL) { + TRACE("(%p) Invalid call\n", This); + return D3DERR_INVALIDCALL; + } + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + + if (NULL == object) { + FIXME("Allocation of memory failed, returning D3DERR_OUTOFVIDEOMEMORY\n"); + return E_OUTOFMEMORY; + } + + object->ref = 1; + object->lpVtbl = &Direct3DPixelShader9_Vtbl; + EnterCriticalSection(&d3d9_cs); + hrc = IWineD3DDevice_CreatePixelShader(This->WineD3DDevice, pFunction, &object->wineD3DPixelShader , (IUnknown *)object); + LeaveCriticalSection(&d3d9_cs); + if (hrc != D3D_OK) { + + /* free up object */ + FIXME("(%p) call to IWineD3DDevice_CreatePixelShader failed\n", This); + HeapFree(GetProcessHeap(), 0 , object); + } else { + IUnknown_AddRef(iface); + object->parentDevice = iface; + *ppShader = (IDirect3DPixelShader9*) object; + TRACE("(%p) : Created pixel shader %p\n", This, object); + } + + TRACE("(%p) : returning %p\n", This, *ppShader); + return hrc; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetPixelShader(LPDIRECT3DDEVICE9 iface, IDirect3DPixelShader9* pShader) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IDirect3DPixelShader9Impl *shader = (IDirect3DPixelShader9Impl *)pShader; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + IWineD3DDevice_SetPixelShader(This->WineD3DDevice, shader == NULL ? NULL :shader->wineD3DPixelShader); + LeaveCriticalSection(&d3d9_cs); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetPixelShader(LPDIRECT3DDEVICE9 iface, IDirect3DPixelShader9** ppShader) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IWineD3DPixelShader *object; + + HRESULT hrc = D3D_OK; + TRACE("(%p) Relay\n", This); + if (ppShader == NULL) { + TRACE("(%p) Invalid call\n", This); + return D3DERR_INVALIDCALL; + } + + EnterCriticalSection(&d3d9_cs); + hrc = IWineD3DDevice_GetPixelShader(This->WineD3DDevice, &object); + if (hrc == D3D_OK && object != NULL) { + hrc = IWineD3DPixelShader_GetParent(object, (IUnknown **)ppShader); + IWineD3DPixelShader_Release(object); + } else { + *ppShader = NULL; + } + LeaveCriticalSection(&d3d9_cs); + + TRACE("(%p) : returning %p\n", This, *ppShader); + return hrc; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetPixelShaderConstantF(LPDIRECT3DDEVICE9 iface, UINT Register, CONST float* pConstantData, UINT Vector4fCount) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetPixelShaderConstantF(This->WineD3DDevice, Register, pConstantData, Vector4fCount); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetPixelShaderConstantF(LPDIRECT3DDEVICE9 iface, UINT Register, float* pConstantData, UINT Vector4fCount) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DDevice_GetPixelShaderConstantF(This->WineD3DDevice, Register, pConstantData, Vector4fCount); +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetPixelShaderConstantI(LPDIRECT3DDEVICE9 iface, UINT Register, CONST int* pConstantData, UINT Vector4iCount) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetPixelShaderConstantI(This->WineD3DDevice, Register, pConstantData, Vector4iCount); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetPixelShaderConstantI(LPDIRECT3DDEVICE9 iface, UINT Register, int* pConstantData, UINT Vector4iCount) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetPixelShaderConstantI(This->WineD3DDevice, Register, pConstantData, Vector4iCount); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetPixelShaderConstantB(LPDIRECT3DDEVICE9 iface, UINT Register, CONST BOOL* pConstantData, UINT BoolCount) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetPixelShaderConstantB(This->WineD3DDevice, Register, pConstantData, BoolCount); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetPixelShaderConstantB(LPDIRECT3DDEVICE9 iface, UINT Register, BOOL* pConstantData, UINT BoolCount) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetPixelShaderConstantB(This->WineD3DDevice, Register, pConstantData, BoolCount); + LeaveCriticalSection(&d3d9_cs); + return hr; +} diff --git a/reactos/dll/directx/wine/d3d9/query.c b/reactos/dll/directx/wine/d3d9/query.c new file mode 100644 index 00000000000..94cd7ec7273 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/query.c @@ -0,0 +1,189 @@ +/* + * 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); + +/* IDirect3DQuery9 IUnknown parts follow: */ +static HRESULT WINAPI IDirect3DQuery9Impl_QueryInterface(LPDIRECT3DQUERY9 iface, REFIID riid, LPVOID* ppobj) { + IDirect3DQuery9Impl *This = (IDirect3DQuery9Impl *)iface; + TRACE("(%p) Relay\n", This); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DQuery9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3DQuery9Impl_AddRef(LPDIRECT3DQUERY9 iface) { + IDirect3DQuery9Impl *This = (IDirect3DQuery9Impl *)iface; + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + return ref; +} + +static ULONG WINAPI IDirect3DQuery9Impl_Release(LPDIRECT3DQUERY9 iface) { + IDirect3DQuery9Impl *This = (IDirect3DQuery9Impl *)iface; + ULONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + EnterCriticalSection(&d3d9_cs); + IWineD3DQuery_Release(This->wineD3DQuery); + LeaveCriticalSection(&d3d9_cs); + IUnknown_Release(This->parentDevice); + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DQuery9 Interface follow: */ +static HRESULT WINAPI IDirect3DQuery9Impl_GetDevice(LPDIRECT3DQUERY9 iface, IDirect3DDevice9** ppDevice) { + IDirect3DQuery9Impl *This = (IDirect3DQuery9Impl *)iface; + IWineD3DDevice* pDevice; + HRESULT hr; + + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DQuery_GetDevice(This->wineD3DQuery, &pDevice); + if(hr != D3D_OK){ + *ppDevice = NULL; + }else{ + hr = IWineD3DDevice_GetParent(pDevice, (IUnknown **)ppDevice); + IWineD3DDevice_Release(pDevice); + } + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static D3DQUERYTYPE WINAPI IDirect3DQuery9Impl_GetType(LPDIRECT3DQUERY9 iface) { + IDirect3DQuery9Impl *This = (IDirect3DQuery9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DQuery_GetType(This->wineD3DQuery); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static DWORD WINAPI IDirect3DQuery9Impl_GetDataSize(LPDIRECT3DQUERY9 iface) { + IDirect3DQuery9Impl *This = (IDirect3DQuery9Impl *)iface; + DWORD ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DQuery_GetDataSize(This->wineD3DQuery); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +static HRESULT WINAPI IDirect3DQuery9Impl_Issue(LPDIRECT3DQUERY9 iface, DWORD dwIssueFlags) { + IDirect3DQuery9Impl *This = (IDirect3DQuery9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DQuery_Issue(This->wineD3DQuery, dwIssueFlags); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DQuery9Impl_GetData(LPDIRECT3DQUERY9 iface, void* pData, DWORD dwSize, DWORD dwGetDataFlags) { + IDirect3DQuery9Impl *This = (IDirect3DQuery9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DQuery_GetData(This->wineD3DQuery, pData, dwSize, dwGetDataFlags); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + + +static const IDirect3DQuery9Vtbl Direct3DQuery9_Vtbl = +{ + IDirect3DQuery9Impl_QueryInterface, + IDirect3DQuery9Impl_AddRef, + IDirect3DQuery9Impl_Release, + IDirect3DQuery9Impl_GetDevice, + IDirect3DQuery9Impl_GetType, + IDirect3DQuery9Impl_GetDataSize, + IDirect3DQuery9Impl_Issue, + IDirect3DQuery9Impl_GetData +}; + + +/* IDirect3DDevice9 IDirect3DQuery9 Methods follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_CreateQuery(LPDIRECT3DDEVICE9 iface, D3DQUERYTYPE Type, IDirect3DQuery9** ppQuery) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IDirect3DQuery9Impl *object = NULL; + HRESULT hr = D3D_OK; + + TRACE("(%p) Relay\n", This); + + if (!ppQuery) + { + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_CreateQuery(This->WineD3DDevice, Type, NULL, NULL); + LeaveCriticalSection(&d3d9_cs); + return hr; + } + + /* Allocate the storage for the device */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DQuery9Impl)); + if (NULL == object) { + FIXME("Allocation of memory failed, returning D3DERR_OUTOFVIDEOMEMORY\n"); + return D3DERR_OUTOFVIDEOMEMORY; + } + + object->lpVtbl = &Direct3DQuery9_Vtbl; + object->ref = 1; + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_CreateQuery(This->WineD3DDevice, Type, &object->wineD3DQuery, (IUnknown *)object); + LeaveCriticalSection(&d3d9_cs); + + if (FAILED(hr)) { + + /* free up object */ + FIXME("(%p) call to IWineD3DDevice_CreateQuery failed\n", This); + HeapFree(GetProcessHeap(), 0, object); + } else { + IUnknown_AddRef(iface); + object->parentDevice = iface; + *ppQuery = (LPDIRECT3DQUERY9) object; + TRACE("(%p) : Created query %p\n", This , object); + } + TRACE("(%p) : returning %x\n", This, hr); + return hr; +} diff --git a/reactos/dll/directx/wine/d3d9/resource.c b/reactos/dll/directx/wine/d3d9/resource.c new file mode 100644 index 00000000000..d07d1da3921 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/resource.c @@ -0,0 +1,135 @@ +/* + * IDirect3DResource9 implementation + * + * Copyright 2002-2004 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); + +/* IDirect3DResource9 IUnknown parts follow: */ +static HRESULT WINAPI IDirect3DResource9Impl_QueryInterface(LPDIRECT3DRESOURCE9 iface, REFIID riid, LPVOID* ppobj) { + IDirect3DResource9Impl *This = (IDirect3DResource9Impl *)iface; + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DResource9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3DResource9Impl_AddRef(LPDIRECT3DRESOURCE9 iface) { + IDirect3DResource9Impl *This = (IDirect3DResource9Impl *)iface; + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + + return ref; +} + +static ULONG WINAPI IDirect3DResource9Impl_Release(LPDIRECT3DRESOURCE9 iface) { + IDirect3DResource9Impl *This = (IDirect3DResource9Impl *)iface; + ULONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + IWineD3DResource_Release(This->wineD3DResource); + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DResource9 Interface follow: */ +HRESULT WINAPI IDirect3DResource9Impl_GetDevice(LPDIRECT3DRESOURCE9 iface, IDirect3DDevice9** ppDevice) { + IDirect3DResource9Impl *This = (IDirect3DResource9Impl *)iface; + IWineD3DDevice *myDevice = NULL; + + TRACE("(%p) Relay\n", This); + + IWineD3DResource_GetDevice(This->wineD3DResource, &myDevice); + IWineD3DDevice_GetParent(myDevice, (IUnknown **)ppDevice); + IWineD3DDevice_Release(myDevice); + return D3D_OK; +} + +static HRESULT WINAPI IDirect3DResource9Impl_SetPrivateData(LPDIRECT3DRESOURCE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + IDirect3DResource9Impl *This = (IDirect3DResource9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DResource_SetPrivateData(This->wineD3DResource, refguid, pData, SizeOfData, Flags); +} + +static HRESULT WINAPI IDirect3DResource9Impl_GetPrivateData(LPDIRECT3DRESOURCE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + IDirect3DResource9Impl *This = (IDirect3DResource9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DResource_GetPrivateData(This->wineD3DResource, refguid, pData, pSizeOfData); +} + +static HRESULT WINAPI IDirect3DResource9Impl_FreePrivateData(LPDIRECT3DRESOURCE9 iface, REFGUID refguid) { + IDirect3DResource9Impl *This = (IDirect3DResource9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DResource_FreePrivateData(This->wineD3DResource, refguid); +} + +static DWORD WINAPI IDirect3DResource9Impl_SetPriority(LPDIRECT3DRESOURCE9 iface, DWORD PriorityNew) { + IDirect3DResource9Impl *This = (IDirect3DResource9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DResource_SetPriority(This->wineD3DResource, PriorityNew); +} + +static DWORD WINAPI IDirect3DResource9Impl_GetPriority(LPDIRECT3DRESOURCE9 iface) { + IDirect3DResource9Impl *This = (IDirect3DResource9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DResource_GetPriority(This->wineD3DResource); +} + +static void WINAPI IDirect3DResource9Impl_PreLoad(LPDIRECT3DRESOURCE9 iface) { + IDirect3DResource9Impl *This = (IDirect3DResource9Impl *)iface; + TRACE("(%p) Relay\n", This); + IWineD3DResource_PreLoad(This->wineD3DResource); + return; +} + +static D3DRESOURCETYPE WINAPI IDirect3DResource9Impl_GetType(LPDIRECT3DRESOURCE9 iface) { + IDirect3DResource9Impl *This = (IDirect3DResource9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DResource_GetType(This->wineD3DResource); +} + + +const IDirect3DResource9Vtbl Direct3DResource9_Vtbl = +{ + IDirect3DResource9Impl_QueryInterface, + IDirect3DResource9Impl_AddRef, + IDirect3DResource9Impl_Release, + IDirect3DResource9Impl_GetDevice, + IDirect3DResource9Impl_SetPrivateData, + IDirect3DResource9Impl_GetPrivateData, + IDirect3DResource9Impl_FreePrivateData, + IDirect3DResource9Impl_SetPriority, + IDirect3DResource9Impl_GetPriority, + IDirect3DResource9Impl_PreLoad, + IDirect3DResource9Impl_GetType +}; diff --git a/reactos/dll/directx/wine/d3d9/stateblock.c b/reactos/dll/directx/wine/d3d9/stateblock.c new file mode 100644 index 00000000000..33eda64b0f1 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/stateblock.c @@ -0,0 +1,193 @@ +/* + * 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); + +/* IDirect3DStateBlock9 IUnknown parts follow: */ +static HRESULT WINAPI IDirect3DStateBlock9Impl_QueryInterface(LPDIRECT3DSTATEBLOCK9 iface, REFIID riid, LPVOID* ppobj) { + IDirect3DStateBlock9Impl *This = (IDirect3DStateBlock9Impl *)iface; + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DStateBlock9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3DStateBlock9Impl_AddRef(LPDIRECT3DSTATEBLOCK9 iface) { + IDirect3DStateBlock9Impl *This = (IDirect3DStateBlock9Impl *)iface; + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + + return ref; +} + +static ULONG WINAPI IDirect3DStateBlock9Impl_Release(LPDIRECT3DSTATEBLOCK9 iface) { + IDirect3DStateBlock9Impl *This = (IDirect3DStateBlock9Impl *)iface; + ULONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + EnterCriticalSection(&d3d9_cs); + IWineD3DStateBlock_Release(This->wineD3DStateBlock); + LeaveCriticalSection(&d3d9_cs); + IUnknown_Release(This->parentDevice); + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DStateBlock9 Interface follow: */ +static HRESULT WINAPI IDirect3DStateBlock9Impl_GetDevice(LPDIRECT3DSTATEBLOCK9 iface, IDirect3DDevice9** ppDevice) { + IDirect3DStateBlock9Impl *This = (IDirect3DStateBlock9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IDirect3DResource9Impl_GetDevice((LPDIRECT3DRESOURCE9) This, ppDevice); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DStateBlock9Impl_Capture(LPDIRECT3DSTATEBLOCK9 iface) { + IDirect3DStateBlock9Impl *This = (IDirect3DStateBlock9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DStateBlock_Capture(This->wineD3DStateBlock); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DStateBlock9Impl_Apply(LPDIRECT3DSTATEBLOCK9 iface) { + IDirect3DStateBlock9Impl *This = (IDirect3DStateBlock9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DStateBlock_Apply(This->wineD3DStateBlock); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + + +static const IDirect3DStateBlock9Vtbl Direct3DStateBlock9_Vtbl = +{ + /* IUnknown */ + IDirect3DStateBlock9Impl_QueryInterface, + IDirect3DStateBlock9Impl_AddRef, + IDirect3DStateBlock9Impl_Release, + /* IDirect3DStateBlock9 */ + IDirect3DStateBlock9Impl_GetDevice, + IDirect3DStateBlock9Impl_Capture, + IDirect3DStateBlock9Impl_Apply +}; + + +/* IDirect3DDevice9 IDirect3DStateBlock9 Methods follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_CreateStateBlock(LPDIRECT3DDEVICE9 iface, D3DSTATEBLOCKTYPE Type, IDirect3DStateBlock9** ppStateBlock) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IDirect3DStateBlock9Impl* object; + HRESULT hrc = D3D_OK; + + TRACE("(%p) Relay\n", This); + + 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(IDirect3DStateBlock9Impl)); + if (NULL == object) return E_OUTOFMEMORY; + object->lpVtbl = &Direct3DStateBlock9_Vtbl; + object->ref = 1; + + EnterCriticalSection(&d3d9_cs); + hrc = IWineD3DDevice_CreateStateBlock(This->WineD3DDevice, (WINED3DSTATEBLOCKTYPE)Type, &object->wineD3DStateBlock, (IUnknown*)object); + LeaveCriticalSection(&d3d9_cs); + if(hrc != D3D_OK){ + FIXME("(%p) Call to IWineD3DDevice_CreateStateBlock failed.\n", This); + HeapFree(GetProcessHeap(), 0, object); + } else { + IUnknown_AddRef(iface); + object->parentDevice = iface; + *ppStateBlock = (IDirect3DStateBlock9*)object; + TRACE("(%p) : Created stateblock %p\n", This, object); + } + TRACE("(%p) returning token (ptr to stateblock) of %p\n", This, object); + return hrc; +} + +HRESULT WINAPI IDirect3DDevice9Impl_BeginStateBlock(LPDIRECT3DDEVICE9 iface) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_BeginStateBlock(This->WineD3DDevice); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +HRESULT WINAPI IDirect3DDevice9Impl_EndStateBlock(LPDIRECT3DDEVICE9 iface, IDirect3DStateBlock9** ppSB) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + IWineD3DStateBlock* wineD3DStateBlock; + IDirect3DStateBlock9Impl* object; + + TRACE("(%p) Relay\n", This); + + /* Tell wineD3D to endstatablock before anything else (in case we run out + * of memory later and cause locking problems) + */ + EnterCriticalSection(&d3d9_cs); + hr=IWineD3DDevice_EndStateBlock(This->WineD3DDevice,&wineD3DStateBlock); + LeaveCriticalSection(&d3d9_cs); + if(hr!= D3D_OK){ + FIXME("IWineD3DDevice_EndStateBlock returned an error\n"); + return hr; + } + /* allocate a new IDirectD3DStateBlock */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY ,sizeof(IDirect3DStateBlock9Impl)); + if (!object) return E_OUTOFMEMORY; + object->ref = 1; + object->lpVtbl = &Direct3DStateBlock9_Vtbl; + object->wineD3DStateBlock = wineD3DStateBlock; + + IUnknown_AddRef(iface); + object->parentDevice = iface; + *ppSB=(IDirect3DStateBlock9*)object; + TRACE("(%p)Returning %p %p\n", This, *ppSB, wineD3DStateBlock); + return D3D_OK; +} diff --git a/reactos/dll/directx/wine/d3d9/surface.c b/reactos/dll/directx/wine/d3d9/surface.c new file mode 100644 index 00000000000..54558b49a89 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/surface.c @@ -0,0 +1,292 @@ +/* + * 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); + +/* IDirect3DSurface9 IUnknown parts follow: */ +static HRESULT WINAPI IDirect3DSurface9Impl_QueryInterface(LPDIRECT3DSURFACE9 iface, REFIID riid, LPVOID* ppobj) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IDirect3DSurface9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3DSurface9Impl_AddRef(LPDIRECT3DSURFACE9 iface) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + + TRACE("(%p)\n", This); + + if (This->forwardReference) { + /* Forward refcounting */ + TRACE("(%p) : Forwarding to %p\n", This, This->forwardReference); + return IUnknown_AddRef(This->forwardReference); + } else { + /* No container, handle our own refcounting */ + ULONG ref = InterlockedIncrement(&This->ref); + if(ref == 1 && This->parentDevice) IUnknown_AddRef(This->parentDevice); + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + + return ref; + } + +} + +static ULONG WINAPI IDirect3DSurface9Impl_Release(LPDIRECT3DSURFACE9 iface) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + + TRACE("(%p)\n", This); + + if (This->forwardReference) { + /* Forward to the containerParent */ + TRACE("(%p) : Forwarding to %p\n", This, This->forwardReference); + return IUnknown_Release(This->forwardReference); + } else { + /* No container, handle our own refcounting */ + ULONG ref = InterlockedDecrement(&This->ref); + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + if (This->parentDevice) IUnknown_Release(This->parentDevice); + if (!This->isImplicit) { + EnterCriticalSection(&d3d9_cs); + IWineD3DSurface_Release(This->wineD3DSurface); + LeaveCriticalSection(&d3d9_cs); + HeapFree(GetProcessHeap(), 0, This); + } + } + + return ref; + } +} + +/* IDirect3DSurface9 IDirect3DResource9 Interface follow: */ +static HRESULT WINAPI IDirect3DSurface9Impl_GetDevice(LPDIRECT3DSURFACE9 iface, IDirect3DDevice9** ppDevice) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + HRESULT hr; + TRACE("(%p)->(%p)\n", This, ppDevice); + + EnterCriticalSection(&d3d9_cs); + hr = IDirect3DResource9Impl_GetDevice((LPDIRECT3DRESOURCE9) This, ppDevice); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DSurface9Impl_SetPrivateData(LPDIRECT3DSURFACE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DSurface_SetPrivateData(This->wineD3DSurface, refguid, pData, SizeOfData, Flags); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DSurface9Impl_GetPrivateData(LPDIRECT3DSURFACE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DSurface_GetPrivateData(This->wineD3DSurface, refguid, pData, pSizeOfData); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DSurface9Impl_FreePrivateData(LPDIRECT3DSURFACE9 iface, REFGUID refguid) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DSurface_FreePrivateData(This->wineD3DSurface, refguid); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static DWORD WINAPI IDirect3DSurface9Impl_SetPriority(LPDIRECT3DSURFACE9 iface, DWORD PriorityNew) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DSurface_SetPriority(This->wineD3DSurface, PriorityNew); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static DWORD WINAPI IDirect3DSurface9Impl_GetPriority(LPDIRECT3DSURFACE9 iface) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DSurface_GetPriority(This->wineD3DSurface); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static void WINAPI IDirect3DSurface9Impl_PreLoad(LPDIRECT3DSURFACE9 iface) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + IWineD3DSurface_PreLoad(This->wineD3DSurface); + LeaveCriticalSection(&d3d9_cs); + return ; +} + +static D3DRESOURCETYPE WINAPI IDirect3DSurface9Impl_GetType(LPDIRECT3DSURFACE9 iface) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + D3DRESOURCETYPE ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DSurface_GetType(This->wineD3DSurface); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +/* IDirect3DSurface9 Interface follow: */ +static HRESULT WINAPI IDirect3DSurface9Impl_GetContainer(LPDIRECT3DSURFACE9 iface, REFIID riid, void** ppContainer) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + HRESULT res; + + TRACE("(This %p, riid %s, ppContainer %p)\n", This, debugstr_guid(riid), ppContainer); + + if (!This->container) return E_NOINTERFACE; + + if (!ppContainer) { + ERR("Called without a valid ppContainer\n"); + } + + res = IUnknown_QueryInterface(This->container, riid, ppContainer); + + TRACE("Returning ppContainer %p, *ppContainer %p\n", ppContainer, *ppContainer); + + return res; +} + +static HRESULT WINAPI IDirect3DSurface9Impl_GetDesc(LPDIRECT3DSURFACE9 iface, D3DSURFACE_DESC* pDesc) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + WINED3DSURFACE_DESC wined3ddesc; + UINT tmpInt = -1; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + /* As d3d8 and d3d9 structures differ, pass in ptrs to where data needs to go */ + wined3ddesc.Format = (WINED3DFORMAT *)&pDesc->Format; + wined3ddesc.Type = (WINED3DRESOURCETYPE *)&pDesc->Type; + wined3ddesc.Usage = &pDesc->Usage; + wined3ddesc.Pool = (WINED3DPOOL *) &pDesc->Pool; + wined3ddesc.Size = &tmpInt; + wined3ddesc.MultiSampleType = (WINED3DMULTISAMPLE_TYPE *) &pDesc->MultiSampleType; + wined3ddesc.MultiSampleQuality = &pDesc->MultiSampleQuality; + wined3ddesc.Width = &pDesc->Width; + wined3ddesc.Height = &pDesc->Height; + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DSurface_GetDesc(This->wineD3DSurface, &wined3ddesc); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DSurface9Impl_LockRect(LPDIRECT3DSURFACE9 iface, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + TRACE("(%p) calling IWineD3DSurface_LockRect %p %p %p %d\n", This, This->wineD3DSurface, pLockedRect, pRect, Flags); + hr = IWineD3DSurface_LockRect(This->wineD3DSurface, (WINED3DLOCKED_RECT *) pLockedRect, pRect, Flags); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DSurface9Impl_UnlockRect(LPDIRECT3DSURFACE9 iface) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DSurface_UnlockRect(This->wineD3DSurface); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DSurface9Impl_GetDC(LPDIRECT3DSURFACE9 iface, HDC* phdc) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DSurface_GetDC(This->wineD3DSurface, phdc); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DSurface9Impl_ReleaseDC(LPDIRECT3DSURFACE9 iface, HDC hdc) { + IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DSurface_ReleaseDC(This->wineD3DSurface, hdc); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + + +const IDirect3DSurface9Vtbl Direct3DSurface9_Vtbl = +{ + /* IUnknown */ + IDirect3DSurface9Impl_QueryInterface, + IDirect3DSurface9Impl_AddRef, + IDirect3DSurface9Impl_Release, + /* IDirect3DResource9 */ + IDirect3DSurface9Impl_GetDevice, + IDirect3DSurface9Impl_SetPrivateData, + IDirect3DSurface9Impl_GetPrivateData, + IDirect3DSurface9Impl_FreePrivateData, + IDirect3DSurface9Impl_SetPriority, + IDirect3DSurface9Impl_GetPriority, + IDirect3DSurface9Impl_PreLoad, + IDirect3DSurface9Impl_GetType, + /* IDirect3DSurface9 */ + IDirect3DSurface9Impl_GetContainer, + IDirect3DSurface9Impl_GetDesc, + IDirect3DSurface9Impl_LockRect, + IDirect3DSurface9Impl_UnlockRect, + IDirect3DSurface9Impl_GetDC, + IDirect3DSurface9Impl_ReleaseDC +}; diff --git a/reactos/dll/directx/wine/d3d9/swapchain.c b/reactos/dll/directx/wine/d3d9/swapchain.c new file mode 100644 index 00000000000..79bea2da2ec --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/swapchain.c @@ -0,0 +1,291 @@ +/* + * 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); + +/* IDirect3DSwapChain IUnknown parts follow: */ +static HRESULT WINAPI IDirect3DSwapChain9Impl_QueryInterface(LPDIRECT3DSWAPCHAIN9 iface, REFIID riid, LPVOID* ppobj) +{ + IDirect3DSwapChain9Impl *This = (IDirect3DSwapChain9Impl *)iface; + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DSwapChain9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3DSwapChain9Impl_AddRef(LPDIRECT3DSWAPCHAIN9 iface) { + IDirect3DSwapChain9Impl *This = (IDirect3DSwapChain9Impl *)iface; + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + + if(ref == 1 && This->parentDevice) IUnknown_AddRef(This->parentDevice); + + return ref; +} + +static ULONG WINAPI IDirect3DSwapChain9Impl_Release(LPDIRECT3DSWAPCHAIN9 iface) { + IDirect3DSwapChain9Impl *This = (IDirect3DSwapChain9Impl *)iface; + ULONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + if (This->parentDevice) IUnknown_Release(This->parentDevice); + if (!This->isImplicit) { + EnterCriticalSection(&d3d9_cs); + IWineD3DSwapChain_Destroy(This->wineD3DSwapChain, D3D9CB_DestroyRenderTarget); + LeaveCriticalSection(&d3d9_cs); + HeapFree(GetProcessHeap(), 0, This); + } + } + return ref; +} + +/* IDirect3DSwapChain9 parts follow: */ +static HRESULT WINAPI IDirect3DSwapChain9Impl_Present(LPDIRECT3DSWAPCHAIN9 iface, CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion, DWORD dwFlags) { + IDirect3DSwapChain9Impl *This = (IDirect3DSwapChain9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DSwapChain_Present(This->wineD3DSwapChain, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion, dwFlags); +} + +static HRESULT WINAPI IDirect3DSwapChain9Impl_GetFrontBufferData(LPDIRECT3DSWAPCHAIN9 iface, IDirect3DSurface9* pDestSurface) { + IDirect3DSwapChain9Impl *This = (IDirect3DSwapChain9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DSwapChain_GetFrontBufferData(This->wineD3DSwapChain, ((IDirect3DSurface9Impl *)pDestSurface)->wineD3DSurface); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DSwapChain9Impl_GetBackBuffer(LPDIRECT3DSWAPCHAIN9 iface, UINT iBackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface9** ppBackBuffer) { + IDirect3DSwapChain9Impl *This = (IDirect3DSwapChain9Impl *)iface; + HRESULT hrc = D3D_OK; + IWineD3DSurface *mySurface = NULL; + + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hrc = IWineD3DSwapChain_GetBackBuffer(This->wineD3DSwapChain, iBackBuffer, (WINED3DBACKBUFFER_TYPE) Type, &mySurface); + if (hrc == D3D_OK && NULL != mySurface) { + IWineD3DSurface_GetParent(mySurface, (IUnknown **)ppBackBuffer); + IWineD3DSurface_Release(mySurface); + } + LeaveCriticalSection(&d3d9_cs); + /* Do not touch the **ppBackBuffer pointer otherwise! (see device test) */ + return hrc; +} + +static HRESULT WINAPI IDirect3DSwapChain9Impl_GetRasterStatus(LPDIRECT3DSWAPCHAIN9 iface, D3DRASTER_STATUS* pRasterStatus) { + IDirect3DSwapChain9Impl *This = (IDirect3DSwapChain9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DSwapChain_GetRasterStatus(This->wineD3DSwapChain, (WINED3DRASTER_STATUS *) pRasterStatus); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DSwapChain9Impl_GetDisplayMode(LPDIRECT3DSWAPCHAIN9 iface, D3DDISPLAYMODE* pMode) { + IDirect3DSwapChain9Impl *This = (IDirect3DSwapChain9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DSwapChain_GetDisplayMode(This->wineD3DSwapChain, (WINED3DDISPLAYMODE *) pMode); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DSwapChain9Impl_GetDevice(LPDIRECT3DSWAPCHAIN9 iface, IDirect3DDevice9** ppDevice) { + IDirect3DSwapChain9Impl *This = (IDirect3DSwapChain9Impl *)iface; + HRESULT hrc = D3D_OK; + IWineD3DDevice *device = NULL; + + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hrc = IWineD3DSwapChain_GetDevice(This->wineD3DSwapChain, &device); + if (hrc == D3D_OK && NULL != device) { + IWineD3DDevice_GetParent(device, (IUnknown **)ppDevice); + IWineD3DDevice_Release(device); + } + LeaveCriticalSection(&d3d9_cs); + return hrc; +} + +static HRESULT WINAPI IDirect3DSwapChain9Impl_GetPresentParameters(LPDIRECT3DSWAPCHAIN9 iface, D3DPRESENT_PARAMETERS* pPresentationParameters) { + IDirect3DSwapChain9Impl *This = (IDirect3DSwapChain9Impl *)iface; + WINED3DPRESENT_PARAMETERS winePresentParameters; + HRESULT hr; + + TRACE("(%p)->(%p): Relay\n", This, pPresentationParameters); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DSwapChain_GetPresentParameters(This->wineD3DSwapChain, &winePresentParameters); + LeaveCriticalSection(&d3d9_cs); + + pPresentationParameters->BackBufferWidth = winePresentParameters.BackBufferWidth; + pPresentationParameters->BackBufferHeight = winePresentParameters.BackBufferHeight; + pPresentationParameters->BackBufferFormat = winePresentParameters.BackBufferFormat; + pPresentationParameters->BackBufferCount = winePresentParameters.BackBufferCount; + pPresentationParameters->MultiSampleType = winePresentParameters.MultiSampleType; + pPresentationParameters->MultiSampleQuality = winePresentParameters.MultiSampleQuality; + pPresentationParameters->SwapEffect = winePresentParameters.SwapEffect; + pPresentationParameters->hDeviceWindow = winePresentParameters.hDeviceWindow; + pPresentationParameters->Windowed = winePresentParameters.Windowed; + pPresentationParameters->EnableAutoDepthStencil = winePresentParameters.EnableAutoDepthStencil; + pPresentationParameters->Flags = winePresentParameters.Flags; + pPresentationParameters->FullScreen_RefreshRateInHz = winePresentParameters.FullScreen_RefreshRateInHz; + pPresentationParameters->PresentationInterval = winePresentParameters.PresentationInterval; + + return hr; +} + + +static const IDirect3DSwapChain9Vtbl Direct3DSwapChain9_Vtbl = +{ + IDirect3DSwapChain9Impl_QueryInterface, + IDirect3DSwapChain9Impl_AddRef, + IDirect3DSwapChain9Impl_Release, + IDirect3DSwapChain9Impl_Present, + IDirect3DSwapChain9Impl_GetFrontBufferData, + IDirect3DSwapChain9Impl_GetBackBuffer, + IDirect3DSwapChain9Impl_GetRasterStatus, + IDirect3DSwapChain9Impl_GetDisplayMode, + IDirect3DSwapChain9Impl_GetDevice, + IDirect3DSwapChain9Impl_GetPresentParameters +}; + + +/* IDirect3DDevice9 IDirect3DSwapChain9 Methods follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_CreateAdditionalSwapChain(LPDIRECT3DDEVICE9 iface, D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain9** pSwapChain) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IDirect3DSwapChain9Impl* object; + HRESULT hrc = D3D_OK; + WINED3DPRESENT_PARAMETERS localParameters; + + TRACE("(%p) Relay\n", This); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + if (NULL == object) { + FIXME("Allocation of memory failed, returning D3DERR_OUTOFVIDEOMEMORY\n"); + return D3DERR_OUTOFVIDEOMEMORY; + } + object->ref = 1; + object->lpVtbl = &Direct3DSwapChain9_Vtbl; + + /* The back buffer count is set to one if it's 0 */ + if(pPresentationParameters->BackBufferCount == 0) { + pPresentationParameters->BackBufferCount = 1; + } + + /* Allocate an associated WineD3DDevice object */ + localParameters.BackBufferWidth = pPresentationParameters->BackBufferWidth; + localParameters.BackBufferHeight = pPresentationParameters->BackBufferHeight; + localParameters.BackBufferFormat = pPresentationParameters->BackBufferFormat; + localParameters.BackBufferCount = pPresentationParameters->BackBufferCount; + localParameters.MultiSampleType = pPresentationParameters->MultiSampleType; + localParameters.MultiSampleQuality = pPresentationParameters->MultiSampleQuality; + localParameters.SwapEffect = pPresentationParameters->SwapEffect; + localParameters.hDeviceWindow = pPresentationParameters->hDeviceWindow; + localParameters.Windowed = pPresentationParameters->Windowed; + localParameters.EnableAutoDepthStencil = pPresentationParameters->EnableAutoDepthStencil; + localParameters.AutoDepthStencilFormat = pPresentationParameters->AutoDepthStencilFormat; + localParameters.Flags = pPresentationParameters->Flags; + localParameters.FullScreen_RefreshRateInHz = pPresentationParameters->FullScreen_RefreshRateInHz; + localParameters.PresentationInterval = pPresentationParameters->PresentationInterval; + + EnterCriticalSection(&d3d9_cs); + hrc = IWineD3DDevice_CreateAdditionalSwapChain(This->WineD3DDevice, &localParameters, &object->wineD3DSwapChain, (IUnknown*)object, D3D9CB_CreateRenderTarget, D3D9CB_CreateDepthStencilSurface); + LeaveCriticalSection(&d3d9_cs); + + pPresentationParameters->BackBufferWidth = localParameters.BackBufferWidth; + pPresentationParameters->BackBufferHeight = localParameters.BackBufferHeight; + pPresentationParameters->BackBufferFormat = localParameters.BackBufferFormat; + pPresentationParameters->BackBufferCount = localParameters.BackBufferCount; + pPresentationParameters->MultiSampleType = localParameters.MultiSampleType; + pPresentationParameters->MultiSampleQuality = localParameters.MultiSampleQuality; + pPresentationParameters->SwapEffect = localParameters.SwapEffect; + pPresentationParameters->hDeviceWindow = localParameters.hDeviceWindow; + pPresentationParameters->Windowed = localParameters.Windowed; + pPresentationParameters->EnableAutoDepthStencil = localParameters.EnableAutoDepthStencil; + pPresentationParameters->AutoDepthStencilFormat = localParameters.AutoDepthStencilFormat; + pPresentationParameters->Flags = localParameters.Flags; + pPresentationParameters->FullScreen_RefreshRateInHz = localParameters.FullScreen_RefreshRateInHz; + pPresentationParameters->PresentationInterval = localParameters.PresentationInterval; + + if (hrc != D3D_OK) { + FIXME("(%p) call to IWineD3DDevice_CreateAdditionalSwapChain failed\n", This); + HeapFree(GetProcessHeap(), 0 , object); + } else { + IUnknown_AddRef(iface); + object->parentDevice = iface; + *pSwapChain = (IDirect3DSwapChain9 *)object; + TRACE("(%p) : Created swapchain %p\n", This, *pSwapChain); + } + TRACE("(%p) returning %p\n", This, *pSwapChain); + return hrc; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetSwapChain(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, IDirect3DSwapChain9** pSwapChain) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hrc = D3D_OK; + IWineD3DSwapChain *swapchain = NULL; + + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hrc = IWineD3DDevice_GetSwapChain(This->WineD3DDevice, iSwapChain, &swapchain); + if (hrc == D3D_OK && NULL != swapchain) { + IWineD3DSwapChain_GetParent(swapchain, (IUnknown **)pSwapChain); + IWineD3DSwapChain_Release(swapchain); + } else { + *pSwapChain = NULL; + } + LeaveCriticalSection(&d3d9_cs); + return hrc; +} + +UINT WINAPI IDirect3DDevice9Impl_GetNumberOfSwapChains(LPDIRECT3DDEVICE9 iface) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + UINT ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DDevice_GetNumberOfSwapChains(This->WineD3DDevice); + LeaveCriticalSection(&d3d9_cs); + return ret; +} diff --git a/reactos/dll/directx/wine/d3d9/texture.c b/reactos/dll/directx/wine/d3d9/texture.c new file mode 100644 index 00000000000..aa873ebfc72 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/texture.c @@ -0,0 +1,366 @@ +/* + * IDirect3DTexture9 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" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d9); + +/* IDirect3DTexture9 IUnknown parts follow: */ +static HRESULT WINAPI IDirect3DTexture9Impl_QueryInterface(LPDIRECT3DTEXTURE9 iface, REFIID riid, LPVOID* ppobj) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9) + || IsEqualGUID(riid, &IID_IDirect3DTexture9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p) not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3DTexture9Impl_AddRef(LPDIRECT3DTEXTURE9 iface) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + + return ref; +} + +static ULONG WINAPI IDirect3DTexture9Impl_Release(LPDIRECT3DTEXTURE9 iface) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + ULONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + EnterCriticalSection(&d3d9_cs); + IWineD3DTexture_Destroy(This->wineD3DTexture, D3D9CB_DestroySurface); + LeaveCriticalSection(&d3d9_cs); + IUnknown_Release(This->parentDevice); + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DTexture9 IDirect3DResource9 Interface follow: */ +static HRESULT WINAPI IDirect3DTexture9Impl_GetDevice(LPDIRECT3DTEXTURE9 iface, IDirect3DDevice9** ppDevice) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IDirect3DResource9Impl_GetDevice((LPDIRECT3DRESOURCE9) This, ppDevice); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DTexture9Impl_SetPrivateData(LPDIRECT3DTEXTURE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DTexture_SetPrivateData(This->wineD3DTexture, refguid, pData, SizeOfData, Flags); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DTexture9Impl_GetPrivateData(LPDIRECT3DTEXTURE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DTexture_GetPrivateData(This->wineD3DTexture, refguid, pData, pSizeOfData); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DTexture9Impl_FreePrivateData(LPDIRECT3DTEXTURE9 iface, REFGUID refguid) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DTexture_FreePrivateData(This->wineD3DTexture, refguid); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static DWORD WINAPI IDirect3DTexture9Impl_SetPriority(LPDIRECT3DTEXTURE9 iface, DWORD PriorityNew) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + DWORD ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DTexture_SetPriority(This->wineD3DTexture, PriorityNew); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +static DWORD WINAPI IDirect3DTexture9Impl_GetPriority(LPDIRECT3DTEXTURE9 iface) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + DWORD ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DTexture_GetPriority(This->wineD3DTexture); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +static void WINAPI IDirect3DTexture9Impl_PreLoad(LPDIRECT3DTEXTURE9 iface) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + IWineD3DTexture_PreLoad(This->wineD3DTexture); + LeaveCriticalSection(&d3d9_cs); +} + +static D3DRESOURCETYPE WINAPI IDirect3DTexture9Impl_GetType(LPDIRECT3DTEXTURE9 iface) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + HRESULT ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DTexture_GetType(This->wineD3DTexture); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +/* IDirect3DTexture9 IDirect3DBaseTexture9 Interface follow: */ +static DWORD WINAPI IDirect3DTexture9Impl_SetLOD(LPDIRECT3DTEXTURE9 iface, DWORD LODNew) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + DWORD ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DTexture_SetLOD(This->wineD3DTexture, LODNew); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +static DWORD WINAPI IDirect3DTexture9Impl_GetLOD(LPDIRECT3DTEXTURE9 iface) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + DWORD ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DTexture_GetLOD(This->wineD3DTexture); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +static DWORD WINAPI IDirect3DTexture9Impl_GetLevelCount(LPDIRECT3DTEXTURE9 iface) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + DWORD ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DTexture_GetLevelCount(This->wineD3DTexture); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +static HRESULT WINAPI IDirect3DTexture9Impl_SetAutoGenFilterType(LPDIRECT3DTEXTURE9 iface, D3DTEXTUREFILTERTYPE FilterType) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DTexture_SetAutoGenFilterType(This->wineD3DTexture, (WINED3DTEXTUREFILTERTYPE) FilterType); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static D3DTEXTUREFILTERTYPE WINAPI IDirect3DTexture9Impl_GetAutoGenFilterType(LPDIRECT3DTEXTURE9 iface) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + D3DTEXTUREFILTERTYPE ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = (D3DTEXTUREFILTERTYPE) IWineD3DTexture_GetAutoGenFilterType(This->wineD3DTexture); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +static void WINAPI IDirect3DTexture9Impl_GenerateMipSubLevels(LPDIRECT3DTEXTURE9 iface) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + IWineD3DTexture_GenerateMipSubLevels(This->wineD3DTexture); + LeaveCriticalSection(&d3d9_cs); +} + +/* IDirect3DTexture9 Interface follow: */ +static HRESULT WINAPI IDirect3DTexture9Impl_GetLevelDesc(LPDIRECT3DTEXTURE9 iface, UINT Level, D3DSURFACE_DESC* pDesc) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + + WINED3DSURFACE_DESC wined3ddesc; + UINT tmpInt = -1; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + /* As d3d8 and d3d9 structures differ, pass in ptrs to where data needs to go */ + wined3ddesc.Format = (WINED3DFORMAT *)&pDesc->Format; + wined3ddesc.Type = (WINED3DRESOURCETYPE *)&pDesc->Type; + wined3ddesc.Usage = &pDesc->Usage; + wined3ddesc.Pool = (WINED3DPOOL *) &pDesc->Pool; + wined3ddesc.Size = &tmpInt; /* required for d3d8 */ + wined3ddesc.MultiSampleType = (WINED3DMULTISAMPLE_TYPE *) &pDesc->MultiSampleType; + wined3ddesc.MultiSampleQuality = &pDesc->MultiSampleQuality; + wined3ddesc.Width = &pDesc->Width; + wined3ddesc.Height = &pDesc->Height; + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DTexture_GetLevelDesc(This->wineD3DTexture, Level, &wined3ddesc); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DTexture9Impl_GetSurfaceLevel(LPDIRECT3DTEXTURE9 iface, UINT Level, IDirect3DSurface9** ppSurfaceLevel) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + HRESULT hrc = D3D_OK; + IWineD3DSurface *mySurface = NULL; + + TRACE("(%p) Relay\n", This); + EnterCriticalSection(&d3d9_cs); + hrc = IWineD3DTexture_GetSurfaceLevel(This->wineD3DTexture, Level, &mySurface); + if (hrc == D3D_OK && NULL != ppSurfaceLevel) { + IWineD3DSurface_GetParent(mySurface, (IUnknown **)ppSurfaceLevel); + IWineD3DSurface_Release(mySurface); + } + LeaveCriticalSection(&d3d9_cs); + return hrc; +} + +static HRESULT WINAPI IDirect3DTexture9Impl_LockRect(LPDIRECT3DTEXTURE9 iface, UINT Level, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DTexture_LockRect(This->wineD3DTexture, Level, (WINED3DLOCKED_RECT *) pLockedRect, pRect, Flags); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DTexture9Impl_UnlockRect(LPDIRECT3DTEXTURE9 iface, UINT Level) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DTexture_UnlockRect(This->wineD3DTexture, Level); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DTexture9Impl_AddDirtyRect(LPDIRECT3DTEXTURE9 iface, CONST RECT* pDirtyRect) { + IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DTexture_AddDirtyRect(This->wineD3DTexture, pDirtyRect); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static const IDirect3DTexture9Vtbl Direct3DTexture9_Vtbl = +{ + /* IUnknown */ + IDirect3DTexture9Impl_QueryInterface, + IDirect3DTexture9Impl_AddRef, + IDirect3DTexture9Impl_Release, + /* IDirect3DResource9 */ + IDirect3DTexture9Impl_GetDevice, + IDirect3DTexture9Impl_SetPrivateData, + IDirect3DTexture9Impl_GetPrivateData, + IDirect3DTexture9Impl_FreePrivateData, + IDirect3DTexture9Impl_SetPriority, + IDirect3DTexture9Impl_GetPriority, + IDirect3DTexture9Impl_PreLoad, + IDirect3DTexture9Impl_GetType, + /* IDirect3dBaseTexture9 */ + IDirect3DTexture9Impl_SetLOD, + IDirect3DTexture9Impl_GetLOD, + IDirect3DTexture9Impl_GetLevelCount, + IDirect3DTexture9Impl_SetAutoGenFilterType, + IDirect3DTexture9Impl_GetAutoGenFilterType, + IDirect3DTexture9Impl_GenerateMipSubLevels, + /* IDirect3DTexture9 */ + IDirect3DTexture9Impl_GetLevelDesc, + IDirect3DTexture9Impl_GetSurfaceLevel, + IDirect3DTexture9Impl_LockRect, + IDirect3DTexture9Impl_UnlockRect, + IDirect3DTexture9Impl_AddDirtyRect +}; + + +/* IDirect3DDevice9 IDirect3DTexture9 Methods follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_CreateTexture(LPDIRECT3DDEVICE9 iface, UINT Width, UINT Height, UINT Levels, DWORD Usage, + D3DFORMAT Format, D3DPOOL Pool, IDirect3DTexture9** ppTexture, HANDLE* pSharedHandle) { + IDirect3DTexture9Impl *object; + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hrc = D3D_OK; + + TRACE("(%p) : W(%d) H(%d), Lvl(%d) d(%d), Fmt(%#x), Pool(%d)\n", This, Width, Height, Levels, Usage, Format, Pool); + + /* Allocate the storage for the device */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DTexture9Impl)); + + if (NULL == object) { + FIXME("Allocation of memory failed, returning D3DERR_OUTOFVIDEOMEMORY\n"); + return D3DERR_OUTOFVIDEOMEMORY; + } + + object->lpVtbl = &Direct3DTexture9_Vtbl; + object->ref = 1; + EnterCriticalSection(&d3d9_cs); + hrc = IWineD3DDevice_CreateTexture(This->WineD3DDevice, Width, Height, Levels, Usage & WINED3DUSAGE_MASK, + (WINED3DFORMAT)Format, (WINED3DPOOL) Pool, &object->wineD3DTexture, pSharedHandle, (IUnknown *)object, D3D9CB_CreateSurface); + LeaveCriticalSection(&d3d9_cs); + + if (FAILED(hrc)) { + + /* free up object */ + FIXME("(%p) call to IWineD3DDevice_CreateTexture failed\n", This); + HeapFree(GetProcessHeap(), 0, object); + } else { + IUnknown_AddRef(iface); + object->parentDevice = iface; + *ppTexture= (LPDIRECT3DTEXTURE9) object; + TRACE("(%p) Created Texture %p, %p\n", This, object, object->wineD3DTexture); + } + + return hrc; +} diff --git a/reactos/dll/directx/wine/d3d9/version.rc b/reactos/dll/directx/wine/d3d9/version.rc new file mode 100644 index 00000000000..99b7c761aa0 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/version.rc @@ -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" diff --git a/reactos/dll/directx/wine/d3d9/vertexbuffer.c b/reactos/dll/directx/wine/d3d9/vertexbuffer.c new file mode 100644 index 00000000000..771695147a5 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/vertexbuffer.c @@ -0,0 +1,243 @@ +/* + * IDirect3DVertexBuffer9 implementation + * + * 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); + +/* IDirect3DVertexBuffer9 IUnknown parts follow: */ +static HRESULT WINAPI IDirect3DVertexBuffer9Impl_QueryInterface(LPDIRECT3DVERTEXBUFFER9 iface, REFIID riid, LPVOID* ppobj) { + IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface; + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IDirect3DVertexBuffer9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3DVertexBuffer9Impl_AddRef(LPDIRECT3DVERTEXBUFFER9 iface) { + IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface; + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + + return ref; +} + +static ULONG WINAPI IDirect3DVertexBuffer9Impl_Release(LPDIRECT3DVERTEXBUFFER9 iface) { + IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface; + ULONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + EnterCriticalSection(&d3d9_cs); + IWineD3DVertexBuffer_Release(This->wineD3DVertexBuffer); + LeaveCriticalSection(&d3d9_cs); + IUnknown_Release(This->parentDevice); + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DVertexBuffer9 IDirect3DResource9 Interface follow: */ +static HRESULT WINAPI IDirect3DVertexBuffer9Impl_GetDevice(LPDIRECT3DVERTEXBUFFER9 iface, IDirect3DDevice9** ppDevice) { + IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IDirect3DResource9Impl_GetDevice((LPDIRECT3DRESOURCE9) This, ppDevice); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DVertexBuffer9Impl_SetPrivateData(LPDIRECT3DVERTEXBUFFER9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DVertexBuffer_SetPrivateData(This->wineD3DVertexBuffer, refguid, pData, SizeOfData, Flags); +} + +static HRESULT WINAPI IDirect3DVertexBuffer9Impl_GetPrivateData(LPDIRECT3DVERTEXBUFFER9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DVertexBuffer_GetPrivateData(This->wineD3DVertexBuffer, refguid, pData, pSizeOfData); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DVertexBuffer9Impl_FreePrivateData(LPDIRECT3DVERTEXBUFFER9 iface, REFGUID refguid) { + IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DVertexBuffer_FreePrivateData(This->wineD3DVertexBuffer, refguid); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static DWORD WINAPI IDirect3DVertexBuffer9Impl_SetPriority(LPDIRECT3DVERTEXBUFFER9 iface, DWORD PriorityNew) { + IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DVertexBuffer_SetPriority(This->wineD3DVertexBuffer, PriorityNew); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static DWORD WINAPI IDirect3DVertexBuffer9Impl_GetPriority(LPDIRECT3DVERTEXBUFFER9 iface) { + IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DVertexBuffer_GetPriority(This->wineD3DVertexBuffer); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static void WINAPI IDirect3DVertexBuffer9Impl_PreLoad(LPDIRECT3DVERTEXBUFFER9 iface) { + IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + IWineD3DVertexBuffer_PreLoad(This->wineD3DVertexBuffer); + LeaveCriticalSection(&d3d9_cs); + return ; +} + +static D3DRESOURCETYPE WINAPI IDirect3DVertexBuffer9Impl_GetType(LPDIRECT3DVERTEXBUFFER9 iface) { + IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface; + D3DRESOURCETYPE ret; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + ret = IWineD3DVertexBuffer_GetType(This->wineD3DVertexBuffer); + LeaveCriticalSection(&d3d9_cs); + return ret; +} + +/* IDirect3DVertexBuffer9 Interface follow: */ +static HRESULT WINAPI IDirect3DVertexBuffer9Impl_Lock(LPDIRECT3DVERTEXBUFFER9 iface, UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags) { + IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DVertexBuffer_Lock(This->wineD3DVertexBuffer, OffsetToLock, SizeToLock, (BYTE **)ppbData, Flags); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DVertexBuffer9Impl_Unlock(LPDIRECT3DVERTEXBUFFER9 iface) { + IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DVertexBuffer_Unlock(This->wineD3DVertexBuffer); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DVertexBuffer9Impl_GetDesc(LPDIRECT3DVERTEXBUFFER9 iface, D3DVERTEXBUFFER_DESC* pDesc) { + IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface; + HRESULT hr; + TRACE("(%p) Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DVertexBuffer_GetDesc(This->wineD3DVertexBuffer, (WINED3DVERTEXBUFFER_DESC *) pDesc); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static const IDirect3DVertexBuffer9Vtbl Direct3DVertexBuffer9_Vtbl = +{ + /* IUnknown */ + IDirect3DVertexBuffer9Impl_QueryInterface, + IDirect3DVertexBuffer9Impl_AddRef, + IDirect3DVertexBuffer9Impl_Release, + /* IDirect3DResource9 */ + IDirect3DVertexBuffer9Impl_GetDevice, + IDirect3DVertexBuffer9Impl_SetPrivateData, + IDirect3DVertexBuffer9Impl_GetPrivateData, + IDirect3DVertexBuffer9Impl_FreePrivateData, + IDirect3DVertexBuffer9Impl_SetPriority, + IDirect3DVertexBuffer9Impl_GetPriority, + IDirect3DVertexBuffer9Impl_PreLoad, + IDirect3DVertexBuffer9Impl_GetType, + /* IDirect3DVertexBuffer9 */ + IDirect3DVertexBuffer9Impl_Lock, + IDirect3DVertexBuffer9Impl_Unlock, + IDirect3DVertexBuffer9Impl_GetDesc +}; + + +/* IDirect3DDevice9 IDirect3DVertexBuffer9 Methods follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_CreateVertexBuffer(LPDIRECT3DDEVICE9 iface, + UINT Size, DWORD Usage, DWORD FVF, D3DPOOL Pool, + IDirect3DVertexBuffer9** ppVertexBuffer, HANDLE* pSharedHandle) { + + IDirect3DVertexBuffer9Impl *object; + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hrc = D3D_OK; + + /* Allocate the storage for the device */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DVertexBuffer9Impl)); + if (NULL == object) { + FIXME("Allocation of memory failed, returning D3DERR_OUTOFVIDEOMEMORY\n"); + return D3DERR_OUTOFVIDEOMEMORY; + } + + object->lpVtbl = &Direct3DVertexBuffer9_Vtbl; + object->ref = 1; + EnterCriticalSection(&d3d9_cs); + hrc = IWineD3DDevice_CreateVertexBuffer(This->WineD3DDevice, Size, Usage & WINED3DUSAGE_MASK, FVF, (WINED3DPOOL) Pool, &(object->wineD3DVertexBuffer), pSharedHandle, (IUnknown *)object); + LeaveCriticalSection(&d3d9_cs); + + if (hrc != D3D_OK) { + + /* free up object */ + WARN("(%p) call to IWineD3DDevice_CreateVertexBuffer failed\n", This); + HeapFree(GetProcessHeap(), 0, object); + } else { + IUnknown_AddRef(iface); + object->parentDevice = iface; + TRACE("(%p) : Created vertex buffer %p\n", This, object); + *ppVertexBuffer = (LPDIRECT3DVERTEXBUFFER9) object; + } + return hrc; +} diff --git a/reactos/dll/directx/wine/d3d9/vertexdeclaration.c b/reactos/dll/directx/wine/d3d9/vertexdeclaration.c new file mode 100644 index 00000000000..3973c98fbf9 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/vertexdeclaration.c @@ -0,0 +1,419 @@ +/* + * 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); + +typedef struct _D3DDECLTYPE_INFO { + D3DDECLTYPE d3dType; + int size; + int typesize; +} D3DDECLTYPE_INFO; + +static D3DDECLTYPE_INFO const d3d_dtype_lookup[D3DDECLTYPE_UNUSED] = { + {D3DDECLTYPE_FLOAT1, 1, sizeof(float)}, + {D3DDECLTYPE_FLOAT2, 2, sizeof(float)}, + {D3DDECLTYPE_FLOAT3, 3, sizeof(float)}, + {D3DDECLTYPE_FLOAT4, 4, sizeof(float)}, + {D3DDECLTYPE_D3DCOLOR, 4, sizeof(BYTE)}, + {D3DDECLTYPE_UBYTE4, 4, sizeof(BYTE)}, + {D3DDECLTYPE_SHORT2, 2, sizeof(short int)}, + {D3DDECLTYPE_SHORT4, 4, sizeof(short int)}, + {D3DDECLTYPE_UBYTE4N, 4, sizeof(BYTE)}, + {D3DDECLTYPE_SHORT2N, 2, sizeof(short int)}, + {D3DDECLTYPE_SHORT4N, 4, sizeof(short int)}, + {D3DDECLTYPE_USHORT2N, 2, sizeof(short int)}, + {D3DDECLTYPE_USHORT4N, 4, sizeof(short int)}, + {D3DDECLTYPE_UDEC3, 3, sizeof(short int)}, + {D3DDECLTYPE_DEC3N, 3, sizeof(short int)}, + {D3DDECLTYPE_FLOAT16_2, 2, sizeof(short int)}, + {D3DDECLTYPE_FLOAT16_4, 4, sizeof(short int)}}; + +#define D3D_DECL_SIZE(type) d3d_dtype_lookup[type].size +#define D3D_DECL_TYPESIZE(type) d3d_dtype_lookup[type].typesize + +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 & 0x00FF0000) >> 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; + + memcpy(&elements[size-1], &end_element, sizeof(D3DVERTEXELEMENT9)); + idx = 0; + if (has_pos) { + if (!has_blend && (fvf & D3DFVF_XYZRHW)) { + elements[idx].Type = D3DDECLTYPE_FLOAT4; + elements[idx].Usage = D3DDECLUSAGE_POSITIONT; + } + 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 + elements[idx].Type = D3DDECLTYPE_FLOAT1 + num_blends - 1; + 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_DECL_SIZE(elements[idx].Type) * D3D_DECL_TYPESIZE(elements[idx].Type); + } + + *ppVertexElements = elements; + return D3D_OK; +} + +/* IDirect3DVertexDeclaration9 IUnknown parts follow: */ +static HRESULT WINAPI IDirect3DVertexDeclaration9Impl_QueryInterface(LPDIRECT3DVERTEXDECLARATION9 iface, REFIID riid, LPVOID* ppobj) { + IDirect3DVertexDeclaration9Impl *This = (IDirect3DVertexDeclaration9Impl *)iface; + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DVertexDeclaration9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3DVertexDeclaration9Impl_AddRef(LPDIRECT3DVERTEXDECLARATION9 iface) { + IDirect3DVertexDeclaration9Impl *This = (IDirect3DVertexDeclaration9Impl *)iface; + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + + if(ref == 1) { + IUnknown_AddRef(This->parentDevice); + } + + return ref; +} + +void IDirect3DVertexDeclaration9Impl_Destroy(LPDIRECT3DVERTEXDECLARATION9 iface) { + IDirect3DVertexDeclaration9Impl *This = (IDirect3DVertexDeclaration9Impl *)iface; + + if(This->ref != 0) { + /* Should not happen unless wine has a bug or the application releases references it does not own */ + ERR("Destroying vdecl with ref != 0\n"); + } + EnterCriticalSection(&d3d9_cs); + IWineD3DVertexDeclaration_Release(This->wineD3DVertexDeclaration); + LeaveCriticalSection(&d3d9_cs); + HeapFree(GetProcessHeap(), 0, This->elements); + HeapFree(GetProcessHeap(), 0, This); +} + +static ULONG WINAPI IDirect3DVertexDeclaration9Impl_Release(LPDIRECT3DVERTEXDECLARATION9 iface) { + IDirect3DVertexDeclaration9Impl *This = (IDirect3DVertexDeclaration9Impl *)iface; + ULONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + IDirect3DDevice9 *parentDevice = This->parentDevice; + + if(!This->convFVF) { + IDirect3DVertexDeclaration9Impl_Release(iface); + } + IUnknown_Release(parentDevice); + } + return ref; +} + +/* IDirect3DVertexDeclaration9 Interface follow: */ +static HRESULT WINAPI IDirect3DVertexDeclaration9Impl_GetDevice(LPDIRECT3DVERTEXDECLARATION9 iface, IDirect3DDevice9** ppDevice) { + IDirect3DVertexDeclaration9Impl *This = (IDirect3DVertexDeclaration9Impl *)iface; + IWineD3DDevice *myDevice = NULL; + HRESULT hr = D3D_OK; + + TRACE("(%p) : Relay\n", iface); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DVertexDeclaration_GetDevice(This->wineD3DVertexDeclaration, &myDevice); + if (hr == D3D_OK && myDevice != NULL) { + hr = IWineD3DDevice_GetParent(myDevice, (IUnknown **)ppDevice); + IWineD3DDevice_Release(myDevice); + } + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +static HRESULT WINAPI IDirect3DVertexDeclaration9Impl_GetDeclaration(LPDIRECT3DVERTEXDECLARATION9 iface, D3DVERTEXELEMENT9* pDecl, UINT* pNumElements) { + IDirect3DVertexDeclaration9Impl *This = (IDirect3DVertexDeclaration9Impl *)iface; + + TRACE("(%p) : pDecl %p, pNumElements %p)\n", This, pDecl, pNumElements); + + *pNumElements = This->element_count; + + /* Passing a NULL pDecl is used to just retrieve the number of elements */ + if (!pDecl) { + TRACE("NULL pDecl passed. Returning D3D_OK.\n"); + return D3D_OK; + } + + TRACE("Copying %p to %p\n", This->elements, pDecl); + CopyMemory(pDecl, This->elements, This->element_count * sizeof(D3DVERTEXELEMENT9)); + + return D3D_OK; +} + +static const IDirect3DVertexDeclaration9Vtbl Direct3DVertexDeclaration9_Vtbl = +{ + /* IUnknown */ + IDirect3DVertexDeclaration9Impl_QueryInterface, + IDirect3DVertexDeclaration9Impl_AddRef, + IDirect3DVertexDeclaration9Impl_Release, + /* IDirect3DVertexDeclaration9 */ + IDirect3DVertexDeclaration9Impl_GetDevice, + IDirect3DVertexDeclaration9Impl_GetDeclaration +}; + +static size_t convert_to_wined3d_declaration(const D3DVERTEXELEMENT9* d3d9_elements, WINED3DVERTEXELEMENT **wined3d_elements) { + const D3DVERTEXELEMENT9* element; + size_t element_count = 1; + size_t i; + + TRACE("d3d9_elements %p, wined3d_elements %p\n", d3d9_elements, wined3d_elements); + + element = d3d9_elements; + while (element++->Stream != 0xff && element_count++ < 128); + + if (element_count == 128) { + return 0; + } + + *wined3d_elements = HeapAlloc(GetProcessHeap(), 0, element_count * sizeof(WINED3DVERTEXELEMENT)); + if (!*wined3d_elements) { + FIXME("Memory allocation failed\n"); + return 0; + } + + for (i = 0; i < element_count; ++i) { + CopyMemory(*wined3d_elements + i, d3d9_elements + i, sizeof(D3DVERTEXELEMENT9)); + (*wined3d_elements)[i].Reg = -1; + } + + return element_count; +} + +/* IDirect3DDevice9 IDirect3DVertexDeclaration9 Methods follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_CreateVertexDeclaration(LPDIRECT3DDEVICE9 iface, CONST D3DVERTEXELEMENT9* pVertexElements, IDirect3DVertexDeclaration9** ppDecl) { + + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IDirect3DVertexDeclaration9Impl *object = NULL; + WINED3DVERTEXELEMENT* wined3d_elements; + size_t element_count; + HRESULT hr = D3D_OK; + + TRACE("(%p) : Relay\n", iface); + if (NULL == ppDecl) { + WARN("(%p) : Caller passed NULL As ppDecl, returning D3DERR_INVALIDCALL\n",This); + return D3DERR_INVALIDCALL; + } + + element_count = convert_to_wined3d_declaration(pVertexElements, &wined3d_elements); + if (!element_count) { + FIXME("(%p) : Error parsing vertex declaration\n", This); + return D3DERR_INVALIDCALL; + } + + /* Allocate the storage for the device */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DVertexDeclaration9Impl)); + if (NULL == object) { + HeapFree(GetProcessHeap(), 0, wined3d_elements); + FIXME("Allocation of memory failed, returning D3DERR_OUTOFVIDEOMEMORY\n"); + return D3DERR_OUTOFVIDEOMEMORY; + } + + object->lpVtbl = &Direct3DVertexDeclaration9_Vtbl; + object->ref = 0; + + object->elements = HeapAlloc(GetProcessHeap(), 0, element_count * sizeof(D3DVERTEXELEMENT9)); + if (!object->elements) { + HeapFree(GetProcessHeap(), 0, wined3d_elements); + HeapFree(GetProcessHeap(), 0, object); + ERR("Memory allocation failed\n"); + return D3DERR_OUTOFVIDEOMEMORY; + } + CopyMemory(object->elements, pVertexElements, element_count * sizeof(D3DVERTEXELEMENT9)); + object->element_count = element_count; + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_CreateVertexDeclaration(This->WineD3DDevice, &object->wineD3DVertexDeclaration, (IUnknown *)object, wined3d_elements, element_count); + LeaveCriticalSection(&d3d9_cs); + + HeapFree(GetProcessHeap(), 0, wined3d_elements); + + if (FAILED(hr)) { + + /* free up object */ + FIXME("(%p) call to IWineD3DDevice_CreateVertexDeclaration failed\n", This); + HeapFree(GetProcessHeap(), 0, object->elements); + HeapFree(GetProcessHeap(), 0, object); + } else { + object->parentDevice = iface; + *ppDecl = (LPDIRECT3DVERTEXDECLARATION9) object; + IUnknown_AddRef(*ppDecl); + TRACE("(%p) : Created vertex declaration %p\n", This, object); + } + return hr; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetVertexDeclaration(LPDIRECT3DDEVICE9 iface, IDirect3DVertexDeclaration9* pDecl) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IDirect3DVertexDeclaration9Impl *pDeclImpl = (IDirect3DVertexDeclaration9Impl *)pDecl; + HRESULT hr = D3D_OK; + + TRACE("(%p) : Relay\n", iface); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetVertexDeclaration(This->WineD3DDevice, pDeclImpl == NULL ? NULL : pDeclImpl->wineD3DVertexDeclaration); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetVertexDeclaration(LPDIRECT3DDEVICE9 iface, IDirect3DVertexDeclaration9** ppDecl) { + IDirect3DDevice9Impl* This = (IDirect3DDevice9Impl*) iface; + IWineD3DVertexDeclaration* pTest = NULL; + HRESULT hr = D3D_OK; + + TRACE("(%p) : Relay+\n", iface); + + if (NULL == ppDecl) { + return D3DERR_INVALIDCALL; + } + + *ppDecl = NULL; + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetVertexDeclaration(This->WineD3DDevice, &pTest); + if (hr == D3D_OK && NULL != pTest) { + IWineD3DVertexDeclaration_GetParent(pTest, (IUnknown **)ppDecl); + IWineD3DVertexDeclaration_Release(pTest); + } else { + *ppDecl = NULL; + } + LeaveCriticalSection(&d3d9_cs); + TRACE("(%p) : returning %p\n", This, *ppDecl); + return hr; +} diff --git a/reactos/dll/directx/wine/d3d9/vertexshader.c b/reactos/dll/directx/wine/d3d9/vertexshader.c new file mode 100644 index 00000000000..8c73d3fd055 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/vertexshader.c @@ -0,0 +1,243 @@ +/* + * IDirect3DVertexShader9 implementation + * + * 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); + +/* IDirect3DVertexShader9 IUnknown parts follow: */ +static HRESULT WINAPI IDirect3DVertexShader9Impl_QueryInterface(LPDIRECT3DVERTEXSHADER9 iface, REFIID riid, LPVOID* ppobj) { + IDirect3DVertexShader9Impl *This = (IDirect3DVertexShader9Impl *)iface; + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DVertexShader9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3DVertexShader9Impl_AddRef(LPDIRECT3DVERTEXSHADER9 iface) { + IDirect3DVertexShader9Impl *This = (IDirect3DVertexShader9Impl *)iface; + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + + return ref; +} + +static ULONG WINAPI IDirect3DVertexShader9Impl_Release(LPDIRECT3DVERTEXSHADER9 iface) { + IDirect3DVertexShader9Impl *This = (IDirect3DVertexShader9Impl *)iface; + ULONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + EnterCriticalSection(&d3d9_cs); + IWineD3DVertexShader_Release(This->wineD3DVertexShader); + LeaveCriticalSection(&d3d9_cs); + IUnknown_Release(This->parentDevice); + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DVertexShader9 Interface follow: */ +static HRESULT WINAPI IDirect3DVertexShader9Impl_GetDevice(LPDIRECT3DVERTEXSHADER9 iface, IDirect3DDevice9** ppDevice) { + IDirect3DVertexShader9Impl *This = (IDirect3DVertexShader9Impl *)iface; + IWineD3DDevice *myDevice = NULL; + HRESULT hr = D3D_OK; + TRACE("(%p) : Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + if (D3D_OK == (hr = IWineD3DVertexShader_GetDevice(This->wineD3DVertexShader, &myDevice) && myDevice != NULL)) { + hr = IWineD3DDevice_GetParent(myDevice, (IUnknown **)ppDevice); + IWineD3DDevice_Release(myDevice); + } else { + *ppDevice = NULL; + } + LeaveCriticalSection(&d3d9_cs); + TRACE("(%p) returning (%p)\n", This, *ppDevice); + return hr; +} + +static HRESULT WINAPI IDirect3DVertexShader9Impl_GetFunction(LPDIRECT3DVERTEXSHADER9 iface, VOID* pData, UINT* pSizeOfData) { + IDirect3DVertexShader9Impl *This = (IDirect3DVertexShader9Impl *)iface; + HRESULT hr; + TRACE("(%p) : Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DVertexShader_GetFunction(This->wineD3DVertexShader, pData, pSizeOfData); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + + +static const IDirect3DVertexShader9Vtbl Direct3DVertexShader9_Vtbl = +{ + /* IUnknown */ + IDirect3DVertexShader9Impl_QueryInterface, + IDirect3DVertexShader9Impl_AddRef, + IDirect3DVertexShader9Impl_Release, + /* IDirect3DVertexShader9 */ + IDirect3DVertexShader9Impl_GetDevice, + IDirect3DVertexShader9Impl_GetFunction +}; + + +/* IDirect3DDevice9 IDirect3DVertexShader9 Methods follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_CreateVertexShader(LPDIRECT3DDEVICE9 iface, CONST DWORD* pFunction, IDirect3DVertexShader9** ppShader) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hrc = D3D_OK; + IDirect3DVertexShader9Impl *object; + + /* Setup a stub object for now */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); + TRACE("(%p) : pFunction(%p), ppShader(%p)\n", This, pFunction, ppShader); + if (NULL == object) { + FIXME("Allocation of memory failed, returning D3DERR_OUTOFVIDEOMEMORY\n"); + return D3DERR_OUTOFVIDEOMEMORY; + } + + object->ref = 1; + object->lpVtbl = &Direct3DVertexShader9_Vtbl; + EnterCriticalSection(&d3d9_cs); + hrc= IWineD3DDevice_CreateVertexShader(This->WineD3DDevice, NULL /* declaration */, pFunction, &object->wineD3DVertexShader, (IUnknown *)object); + LeaveCriticalSection(&d3d9_cs); + + if (FAILED(hrc)) { + + /* free up object */ + FIXME("Call to IWineD3DDevice_CreateVertexShader failed\n"); + HeapFree(GetProcessHeap(), 0, object); + }else{ + IUnknown_AddRef(iface); + object->parentDevice = iface; + *ppShader = (IDirect3DVertexShader9 *)object; + TRACE("(%p) : Created vertex shader %p\n", This, object); + } + + TRACE("(%p) : returning %p\n", This, *ppShader); + return hrc; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetVertexShader(LPDIRECT3DDEVICE9 iface, IDirect3DVertexShader9* pShader) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hrc = D3D_OK; + + TRACE("(%p) : Relay\n", This); + EnterCriticalSection(&d3d9_cs); + hrc = IWineD3DDevice_SetVertexShader(This->WineD3DDevice, pShader==NULL?NULL:((IDirect3DVertexShader9Impl *)pShader)->wineD3DVertexShader); + LeaveCriticalSection(&d3d9_cs); + + TRACE("(%p) : returning hr(%u)\n", This, hrc); + return hrc; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetVertexShader(LPDIRECT3DDEVICE9 iface, IDirect3DVertexShader9** ppShader) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + IWineD3DVertexShader *pShader; + HRESULT hrc = D3D_OK; + + TRACE("(%p) : Relay device@%p\n", This, This->WineD3DDevice); + EnterCriticalSection(&d3d9_cs); + hrc = IWineD3DDevice_GetVertexShader(This->WineD3DDevice, &pShader); + if(hrc == D3D_OK && pShader != NULL){ + hrc = IWineD3DVertexShader_GetParent(pShader, (IUnknown **)ppShader); + IWineD3DVertexShader_Release(pShader); + } else { + WARN("(%p) : Call to IWineD3DDevice_GetVertexShader failed %u (device %p)\n", This, hrc, This->WineD3DDevice); + } + LeaveCriticalSection(&d3d9_cs); + TRACE("(%p) : returning %p\n", This, *ppShader); + return hrc; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetVertexShaderConstantF(LPDIRECT3DDEVICE9 iface, UINT Register, CONST float* pConstantData, UINT Vector4fCount) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) : Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetVertexShaderConstantF(This->WineD3DDevice, Register, pConstantData, Vector4fCount); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetVertexShaderConstantF(LPDIRECT3DDEVICE9 iface, UINT Register, float* pConstantData, UINT Vector4fCount) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + + TRACE("(%p) : Relay\n", This); + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetVertexShaderConstantF(This->WineD3DDevice, Register, pConstantData, Vector4fCount); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetVertexShaderConstantI(LPDIRECT3DDEVICE9 iface, UINT Register, CONST int* pConstantData, UINT Vector4iCount) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) : Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetVertexShaderConstantI(This->WineD3DDevice, Register, pConstantData, Vector4iCount); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetVertexShaderConstantI(LPDIRECT3DDEVICE9 iface, UINT Register, int* pConstantData, UINT Vector4iCount) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) : Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetVertexShaderConstantI(This->WineD3DDevice, Register, pConstantData, Vector4iCount); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetVertexShaderConstantB(LPDIRECT3DDEVICE9 iface, UINT Register, CONST BOOL* pConstantData, UINT BoolCount) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) : Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_SetVertexShaderConstantB(This->WineD3DDevice, Register, pConstantData, BoolCount); + LeaveCriticalSection(&d3d9_cs); + return hr; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetVertexShaderConstantB(LPDIRECT3DDEVICE9 iface, UINT Register, BOOL* pConstantData, UINT BoolCount) { + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hr; + TRACE("(%p) : Relay\n", This); + + EnterCriticalSection(&d3d9_cs); + hr = IWineD3DDevice_GetVertexShaderConstantB(This->WineD3DDevice, Register, pConstantData, BoolCount); + LeaveCriticalSection(&d3d9_cs); + return hr; +} diff --git a/reactos/dll/directx/wine/d3d9/volume.c b/reactos/dll/directx/wine/d3d9/volume.c new file mode 100644 index 00000000000..1a6f32daa78 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/volume.c @@ -0,0 +1,224 @@ +/* + * 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); + +/* IDirect3DVolume9 IUnknown parts follow: */ +static HRESULT WINAPI IDirect3DVolume9Impl_QueryInterface(LPDIRECT3DVOLUME9 iface, REFIID riid, LPVOID* ppobj) { + IDirect3DVolume9Impl *This = (IDirect3DVolume9Impl *)iface; + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DVolume9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3DVolume9Impl_AddRef(LPDIRECT3DVOLUME9 iface) { + IDirect3DVolume9Impl *This = (IDirect3DVolume9Impl *)iface; + + TRACE("(%p)\n", This); + + if (This->forwardReference) { + /* Forward refcounting */ + TRACE("(%p) : Forwarding to %p\n", This, This->forwardReference); + return IUnknown_AddRef(This->forwardReference); + } else { + /* No container, handle our own refcounting */ + ULONG ref = InterlockedIncrement(&This->ref); + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + return ref; + } +} + +static ULONG WINAPI IDirect3DVolume9Impl_Release(LPDIRECT3DVOLUME9 iface) { + IDirect3DVolume9Impl *This = (IDirect3DVolume9Impl *)iface; + + TRACE("(%p)\n", This); + + if (This->forwardReference) { + /* Forward refcounting */ + TRACE("(%p) : Forwarding to %p\n", This, This->forwardReference); + return IUnknown_Release(This->forwardReference); + } else { + /* No container, handle our own refcounting */ + ULONG ref = InterlockedDecrement(&This->ref); + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + IWineD3DVolume_Release(This->wineD3DVolume); + HeapFree(GetProcessHeap(), 0, This); + } + + return ref; + } +} + +/* IDirect3DVolume9 Interface follow: */ +static HRESULT WINAPI IDirect3DVolume9Impl_GetDevice(LPDIRECT3DVOLUME9 iface, IDirect3DDevice9** ppDevice) { + IDirect3DVolume9Impl *This = (IDirect3DVolume9Impl *)iface; + IWineD3DDevice *myDevice = NULL; + + IWineD3DVolume_GetDevice(This->wineD3DVolume, &myDevice); + IWineD3DDevice_GetParent(myDevice, (IUnknown **)ppDevice); + IWineD3DDevice_Release(myDevice); + return D3D_OK; +} + +static HRESULT WINAPI IDirect3DVolume9Impl_SetPrivateData(LPDIRECT3DVOLUME9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + IDirect3DVolume9Impl *This = (IDirect3DVolume9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DVolume_SetPrivateData(This->wineD3DVolume, refguid, pData, SizeOfData, Flags); +} + +static HRESULT WINAPI IDirect3DVolume9Impl_GetPrivateData(LPDIRECT3DVOLUME9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + IDirect3DVolume9Impl *This = (IDirect3DVolume9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DVolume_GetPrivateData(This->wineD3DVolume, refguid, pData, pSizeOfData); +} + +static HRESULT WINAPI IDirect3DVolume9Impl_FreePrivateData(LPDIRECT3DVOLUME9 iface, REFGUID refguid) { + IDirect3DVolume9Impl *This = (IDirect3DVolume9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DVolume_FreePrivateData(This->wineD3DVolume, refguid); +} + +static HRESULT WINAPI IDirect3DVolume9Impl_GetContainer(LPDIRECT3DVOLUME9 iface, REFIID riid, void** ppContainer) { + IDirect3DVolume9Impl *This = (IDirect3DVolume9Impl *)iface; + HRESULT res; + + TRACE("(This %p, riid %s, ppContainer %p)\n", This, debugstr_guid(riid), ppContainer); + + if (!This->container) return E_NOINTERFACE; + + if (!ppContainer) { + ERR("Called without a valid ppContainer.\n"); + } + + res = IUnknown_QueryInterface(This->container, riid, ppContainer); + + TRACE("Returning ppContainer %p, *ppContainer %p\n", ppContainer, *ppContainer); + + return res; +} + +static HRESULT WINAPI IDirect3DVolume9Impl_GetDesc(LPDIRECT3DVOLUME9 iface, D3DVOLUME_DESC* pDesc) { + IDirect3DVolume9Impl *This = (IDirect3DVolume9Impl *)iface; + WINED3DVOLUME_DESC wined3ddesc; + UINT tmpInt = -1; + + TRACE("(%p) Relay\n", This); + + /* As d3d8 and d3d9 structures differ, pass in ptrs to where data needs to go */ + wined3ddesc.Format = (WINED3DFORMAT *)&pDesc->Format; + wined3ddesc.Type = (WINED3DRESOURCETYPE *)&pDesc->Type; + wined3ddesc.Usage = &pDesc->Usage; + wined3ddesc.Pool = (WINED3DPOOL *) &pDesc->Pool; + wined3ddesc.Size = &tmpInt; + wined3ddesc.Width = &pDesc->Width; + wined3ddesc.Height = &pDesc->Height; + wined3ddesc.Depth = &pDesc->Depth; + + return IWineD3DVolume_GetDesc(This->wineD3DVolume, &wined3ddesc); +} + +static HRESULT WINAPI IDirect3DVolume9Impl_LockBox(LPDIRECT3DVOLUME9 iface, D3DLOCKED_BOX* pLockedVolume, CONST D3DBOX* pBox, DWORD Flags) { + IDirect3DVolume9Impl *This = (IDirect3DVolume9Impl *)iface; + TRACE("(%p) relay %p %p %p %d\n", This, This->wineD3DVolume, pLockedVolume, pBox, Flags); + return IWineD3DVolume_LockBox(This->wineD3DVolume, (WINED3DLOCKED_BOX *)pLockedVolume, (CONST WINED3DBOX *)pBox, Flags); +} + +static HRESULT WINAPI IDirect3DVolume9Impl_UnlockBox(LPDIRECT3DVOLUME9 iface) { + IDirect3DVolume9Impl *This = (IDirect3DVolume9Impl *)iface; + TRACE("(%p) relay %p\n", This, This->wineD3DVolume); + return IWineD3DVolume_UnlockBox(This->wineD3DVolume); +} + +static const IDirect3DVolume9Vtbl Direct3DVolume9_Vtbl = +{ + /* IUnknown */ + IDirect3DVolume9Impl_QueryInterface, + IDirect3DVolume9Impl_AddRef, + IDirect3DVolume9Impl_Release, + /* IDirect3DVolume9 */ + IDirect3DVolume9Impl_GetDevice, + IDirect3DVolume9Impl_SetPrivateData, + IDirect3DVolume9Impl_GetPrivateData, + IDirect3DVolume9Impl_FreePrivateData, + IDirect3DVolume9Impl_GetContainer, + IDirect3DVolume9Impl_GetDesc, + IDirect3DVolume9Impl_LockBox, + IDirect3DVolume9Impl_UnlockBox +}; + + +/* Internal function called back during the CreateVolumeTexture */ +HRESULT WINAPI D3D9CB_CreateVolume(IUnknown *pDevice, IUnknown *pSuperior, UINT Width, UINT Height, UINT Depth, + WINED3DFORMAT Format, WINED3DPOOL Pool, DWORD Usage, + IWineD3DVolume **ppVolume, + HANDLE * pSharedHandle) { + IDirect3DVolume9Impl *object; + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)pDevice; + HRESULT hrc = D3D_OK; + + /* Allocate the storage for the device */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DVolume9Impl)); + if (NULL == object) { + FIXME("Allocation of memory failed\n"); + *ppVolume = NULL; + return D3DERR_OUTOFVIDEOMEMORY; + } + + object->lpVtbl = &Direct3DVolume9_Vtbl; + object->ref = 1; + hrc = IWineD3DDevice_CreateVolume(This->WineD3DDevice, Width, Height, Depth, Usage & WINED3DUSAGE_MASK, Format, + Pool, &object->wineD3DVolume, pSharedHandle, (IUnknown *)object); + if (hrc != D3D_OK) { + /* free up object */ + FIXME("(%p) call to IWineD3DDevice_CreateVolume failed\n", This); + HeapFree(GetProcessHeap(), 0, object); + *ppVolume = NULL; + } else { + *ppVolume = (IWineD3DVolume *)object->wineD3DVolume; + object->container = pSuperior; + object->forwardReference = pSuperior; + } + TRACE("(%p) Created volume %p\n", This, *ppVolume); + return hrc; +} + +ULONG WINAPI D3D9CB_DestroyVolume(IWineD3DVolume *pVolume) { + IDirect3DVolume9Impl* volumeParent; + + IWineD3DVolume_GetParent(pVolume, (IUnknown **) &volumeParent); + /* GetParent's AddRef was forwarded to an object in destruction. + * Releasing it here again would cause an endless recursion. */ + volumeParent->forwardReference = NULL; + return IDirect3DVolume9_Release((IDirect3DVolume9*) volumeParent); +} diff --git a/reactos/dll/directx/wine/d3d9/volumetexture.c b/reactos/dll/directx/wine/d3d9/volumetexture.c new file mode 100644 index 00000000000..cf73f7a9467 --- /dev/null +++ b/reactos/dll/directx/wine/d3d9/volumetexture.c @@ -0,0 +1,279 @@ +/* + * IDirect3DVolumeTexture9 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); + +/* IDirect3DVolumeTexture9 IUnknown parts follow: */ +static HRESULT WINAPI IDirect3DVolumeTexture9Impl_QueryInterface(LPDIRECT3DVOLUMETEXTURE9 iface, REFIID riid, LPVOID* ppobj) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9) + || IsEqualGUID(riid, &IID_IDirect3DVolumeTexture9)) { + IUnknown_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + *ppobj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI IDirect3DVolumeTexture9Impl_AddRef(LPDIRECT3DVOLUMETEXTURE9 iface) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) : AddRef from %d\n", This, ref - 1); + + return ref; +} + +static ULONG WINAPI IDirect3DVolumeTexture9Impl_Release(LPDIRECT3DVOLUMETEXTURE9 iface) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + ULONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) : ReleaseRef to %d\n", This, ref); + + if (ref == 0) { + IWineD3DVolumeTexture_Destroy(This->wineD3DVolumeTexture, D3D9CB_DestroyVolume); + IUnknown_Release(This->parentDevice); + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DVolumeTexture9 IDirect3DResource9 Interface follow: */ +static HRESULT WINAPI IDirect3DVolumeTexture9Impl_GetDevice(LPDIRECT3DVOLUMETEXTURE9 iface, IDirect3DDevice9** ppDevice) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IDirect3DResource9Impl_GetDevice((LPDIRECT3DRESOURCE9) This, ppDevice); +} + +static HRESULT WINAPI IDirect3DVolumeTexture9Impl_SetPrivateData(LPDIRECT3DVOLUMETEXTURE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DVolumeTexture_SetPrivateData(This->wineD3DVolumeTexture, refguid, pData, SizeOfData, Flags); +} + +static HRESULT WINAPI IDirect3DVolumeTexture9Impl_GetPrivateData(LPDIRECT3DVOLUMETEXTURE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DVolumeTexture_GetPrivateData(This->wineD3DVolumeTexture, refguid, pData, pSizeOfData); +} + +static HRESULT WINAPI IDirect3DVolumeTexture9Impl_FreePrivateData(LPDIRECT3DVOLUMETEXTURE9 iface, REFGUID refguid) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DVolumeTexture_FreePrivateData(This->wineD3DVolumeTexture, refguid); +} + +static DWORD WINAPI IDirect3DVolumeTexture9Impl_SetPriority(LPDIRECT3DVOLUMETEXTURE9 iface, DWORD PriorityNew) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DVolumeTexture_SetPriority(This->wineD3DVolumeTexture, PriorityNew); +} + +static DWORD WINAPI IDirect3DVolumeTexture9Impl_GetPriority(LPDIRECT3DVOLUMETEXTURE9 iface) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DVolumeTexture_GetPriority(This->wineD3DVolumeTexture); +} + +static void WINAPI IDirect3DVolumeTexture9Impl_PreLoad(LPDIRECT3DVOLUMETEXTURE9 iface) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + IWineD3DVolumeTexture_PreLoad(This->wineD3DVolumeTexture); +} + +static D3DRESOURCETYPE WINAPI IDirect3DVolumeTexture9Impl_GetType(LPDIRECT3DVOLUMETEXTURE9 iface) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DVolumeTexture_GetType(This->wineD3DVolumeTexture); +} + +/* IDirect3DVolumeTexture9 IDirect3DBaseTexture9 Interface follow: */ +static DWORD WINAPI IDirect3DVolumeTexture9Impl_SetLOD(LPDIRECT3DVOLUMETEXTURE9 iface, DWORD LODNew) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DVolumeTexture_SetLOD(This->wineD3DVolumeTexture, LODNew); +} + +static DWORD WINAPI IDirect3DVolumeTexture9Impl_GetLOD(LPDIRECT3DVOLUMETEXTURE9 iface) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DVolumeTexture_GetLOD(This->wineD3DVolumeTexture); +} + +static DWORD WINAPI IDirect3DVolumeTexture9Impl_GetLevelCount(LPDIRECT3DVOLUMETEXTURE9 iface) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DVolumeTexture_GetLevelCount(This->wineD3DVolumeTexture); +} + +static HRESULT WINAPI IDirect3DVolumeTexture9Impl_SetAutoGenFilterType(LPDIRECT3DVOLUMETEXTURE9 iface, D3DTEXTUREFILTERTYPE FilterType) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DVolumeTexture_SetAutoGenFilterType(This->wineD3DVolumeTexture, (WINED3DTEXTUREFILTERTYPE) FilterType); +} + +static D3DTEXTUREFILTERTYPE WINAPI IDirect3DVolumeTexture9Impl_GetAutoGenFilterType(LPDIRECT3DVOLUMETEXTURE9 iface) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + return (D3DTEXTUREFILTERTYPE) IWineD3DVolumeTexture_GetAutoGenFilterType(This->wineD3DVolumeTexture); +} + +static void WINAPI IDirect3DVolumeTexture9Impl_GenerateMipSubLevels(LPDIRECT3DVOLUMETEXTURE9 iface) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + IWineD3DVolumeTexture_GenerateMipSubLevels(This->wineD3DVolumeTexture); +} + +/* IDirect3DVolumeTexture9 Interface follow: */ +static HRESULT WINAPI IDirect3DVolumeTexture9Impl_GetLevelDesc(LPDIRECT3DVOLUMETEXTURE9 iface, UINT Level, D3DVOLUME_DESC* pDesc) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + WINED3DVOLUME_DESC wined3ddesc; + UINT tmpInt = -1; + + TRACE("(%p) Relay\n", This); + + /* As d3d8 and d3d9 structures differ, pass in ptrs to where data needs to go */ + wined3ddesc.Format = (WINED3DFORMAT *)&pDesc->Format; + wined3ddesc.Type = (WINED3DRESOURCETYPE *)&pDesc->Type; + wined3ddesc.Usage = &pDesc->Usage; + wined3ddesc.Pool = (WINED3DPOOL *) &pDesc->Pool; + wined3ddesc.Size = &tmpInt; + wined3ddesc.Width = &pDesc->Width; + wined3ddesc.Height = &pDesc->Height; + wined3ddesc.Depth = &pDesc->Depth; + + return IWineD3DVolumeTexture_GetLevelDesc(This->wineD3DVolumeTexture, Level, &wined3ddesc); +} + +static HRESULT WINAPI IDirect3DVolumeTexture9Impl_GetVolumeLevel(LPDIRECT3DVOLUMETEXTURE9 iface, UINT Level, IDirect3DVolume9** ppVolumeLevel) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + HRESULT hrc = D3D_OK; + IWineD3DVolume *myVolume = NULL; + + TRACE("(%p) Relay\n", This); + + hrc = IWineD3DVolumeTexture_GetVolumeLevel(This->wineD3DVolumeTexture, Level, &myVolume); + if (hrc == D3D_OK && NULL != ppVolumeLevel) { + IWineD3DVolumeTexture_GetParent(myVolume, (IUnknown **)ppVolumeLevel); + IWineD3DVolumeTexture_Release(myVolume); + } + return hrc; +} + +static HRESULT WINAPI IDirect3DVolumeTexture9Impl_LockBox(LPDIRECT3DVOLUMETEXTURE9 iface, UINT Level, D3DLOCKED_BOX* pLockedVolume, CONST D3DBOX* pBox, DWORD Flags) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay %p %p %p %d\n", This, This->wineD3DVolumeTexture, pLockedVolume, pBox,Flags); + return IWineD3DVolumeTexture_LockBox(This->wineD3DVolumeTexture, Level, (WINED3DLOCKED_BOX *)pLockedVolume, (CONST WINED3DBOX *)pBox, Flags); +} + +static HRESULT WINAPI IDirect3DVolumeTexture9Impl_UnlockBox(LPDIRECT3DVOLUMETEXTURE9 iface, UINT Level) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay %p %d\n", This, This->wineD3DVolumeTexture, Level); + return IWineD3DVolumeTexture_UnlockBox(This->wineD3DVolumeTexture, Level); +} + +static HRESULT WINAPI IDirect3DVolumeTexture9Impl_AddDirtyBox(LPDIRECT3DVOLUMETEXTURE9 iface, CONST D3DBOX* pDirtyBox) { + IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl *)iface; + TRACE("(%p) Relay\n", This); + return IWineD3DVolumeTexture_AddDirtyBox(This->wineD3DVolumeTexture, (CONST WINED3DBOX *)pDirtyBox); +} + + +static const IDirect3DVolumeTexture9Vtbl Direct3DVolumeTexture9_Vtbl = +{ + /* IUnknown */ + IDirect3DVolumeTexture9Impl_QueryInterface, + IDirect3DVolumeTexture9Impl_AddRef, + IDirect3DVolumeTexture9Impl_Release, + /* IDirect3DResource9 */ + IDirect3DVolumeTexture9Impl_GetDevice, + IDirect3DVolumeTexture9Impl_SetPrivateData, + IDirect3DVolumeTexture9Impl_GetPrivateData, + IDirect3DVolumeTexture9Impl_FreePrivateData, + IDirect3DVolumeTexture9Impl_SetPriority, + IDirect3DVolumeTexture9Impl_GetPriority, + IDirect3DVolumeTexture9Impl_PreLoad, + IDirect3DVolumeTexture9Impl_GetType, + /* IDirect3DBaseTexture9 */ + IDirect3DVolumeTexture9Impl_SetLOD, + IDirect3DVolumeTexture9Impl_GetLOD, + IDirect3DVolumeTexture9Impl_GetLevelCount, + IDirect3DVolumeTexture9Impl_SetAutoGenFilterType, + IDirect3DVolumeTexture9Impl_GetAutoGenFilterType, + IDirect3DVolumeTexture9Impl_GenerateMipSubLevels, + /* IDirect3DVolumeTexture9 */ + IDirect3DVolumeTexture9Impl_GetLevelDesc, + IDirect3DVolumeTexture9Impl_GetVolumeLevel, + IDirect3DVolumeTexture9Impl_LockBox, + IDirect3DVolumeTexture9Impl_UnlockBox, + IDirect3DVolumeTexture9Impl_AddDirtyBox +}; + + +/* IDirect3DDevice9 IDirect3DVolumeTexture9 Methods follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_CreateVolumeTexture(LPDIRECT3DDEVICE9 iface, + UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage, + D3DFORMAT Format, D3DPOOL Pool, + IDirect3DVolumeTexture9** ppVolumeTexture, HANDLE* pSharedHandle) { + + IDirect3DVolumeTexture9Impl *object; + IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface; + HRESULT hrc = D3D_OK; + + TRACE("(%p) Relay\n", This); + + /* Allocate the storage for the device */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DVolumeTexture9Impl)); + if (NULL == object) { + FIXME("(%p) allocation of memory failed, returning D3DERR_OUTOFVIDEOMEMORY\n", This); + return D3DERR_OUTOFVIDEOMEMORY; + } + + object->lpVtbl = &Direct3DVolumeTexture9_Vtbl; + object->ref = 1; + hrc = IWineD3DDevice_CreateVolumeTexture(This->WineD3DDevice, Width, Height, Depth, Levels, Usage & WINED3DUSAGE_MASK, + (WINED3DFORMAT)Format, (WINED3DPOOL) Pool, &object->wineD3DVolumeTexture, pSharedHandle, + (IUnknown *)object, D3D9CB_CreateVolume); + + + if (hrc != D3D_OK) { + + /* free up object */ + FIXME("(%p) call to IWineD3DDevice_CreateVolumeTexture failed\n", This); + HeapFree(GetProcessHeap(), 0, object); + } else { + IUnknown_AddRef(iface); + object->parentDevice = iface; + *ppVolumeTexture = (LPDIRECT3DVOLUMETEXTURE9) object; + TRACE("(%p) : Created volume texture %p\n", This, object); + } + TRACE("(%p) returning %p\n", This , *ppVolumeTexture); + return hrc; +} diff --git a/reactos/dll/directx/wine/wine.rbuild b/reactos/dll/directx/wine/wine.rbuild index 7427b0caf9b..242711e5e2b 100644 --- a/reactos/dll/directx/wine/wine.rbuild +++ b/reactos/dll/directx/wine/wine.rbuild @@ -7,4 +7,7 @@ + + +