From a3dbd7e2c720682b4388bf83cd5918b39e39627b Mon Sep 17 00:00:00 2001 From: Raphael Junqueira Date: Tue, 1 Jul 2003 01:09:17 +0000 Subject: [PATCH] - some cleanups and fixes on d3d8 and d3d9 headers - a lot of stubs for d3d9.dll --- dlls/d3d9/.cvsignore | 5 + dlls/d3d9/Makefile.in | 37 + dlls/d3d9/basetexture.c | 170 +++++ dlls/d3d9/cubetexture.c | 258 +++++++ dlls/d3d9/d3d9.spec | 5 + dlls/d3d9/d3d9_main.c | 95 +++ dlls/d3d9/d3d9_private.h | 1199 ++++++++++++++++++++++++++++++++ dlls/d3d9/device.c | 837 ++++++++++++++++++++++ dlls/d3d9/directx.c | 185 +++++ dlls/d3d9/indexbuffer.c | 185 +++++ dlls/d3d9/pixelshader.c | 242 +++++++ dlls/d3d9/query.c | 122 ++++ dlls/d3d9/resource.c | 132 ++++ dlls/d3d9/stateblock.c | 120 ++++ dlls/d3d9/surface.c | 184 +++++ dlls/d3d9/swapchain.c | 151 ++++ dlls/d3d9/texture.c | 248 +++++++ dlls/d3d9/version.rc | 27 + dlls/d3d9/vertexbuffer.c | 182 +++++ dlls/d3d9/vertexdeclaration.c | 113 +++ dlls/d3d9/vertexshader.c | 242 +++++++ dlls/d3d9/volume.c | 141 ++++ dlls/d3d9/volumetexture.c | 255 +++++++ dlls/d3d9/vshaderdeclaration.c | 83 +++ include/d3d8.h | 4 + include/d3d9.h | 91 ++- include/d3d9types.h | 2 +- 27 files changed, 5265 insertions(+), 50 deletions(-) create mode 100644 dlls/d3d9/.cvsignore create mode 100644 dlls/d3d9/Makefile.in create mode 100644 dlls/d3d9/basetexture.c create mode 100644 dlls/d3d9/cubetexture.c create mode 100644 dlls/d3d9/d3d9.spec create mode 100644 dlls/d3d9/d3d9_main.c create mode 100644 dlls/d3d9/d3d9_private.h create mode 100644 dlls/d3d9/device.c create mode 100644 dlls/d3d9/directx.c create mode 100644 dlls/d3d9/indexbuffer.c create mode 100644 dlls/d3d9/pixelshader.c create mode 100644 dlls/d3d9/query.c create mode 100644 dlls/d3d9/resource.c create mode 100644 dlls/d3d9/stateblock.c create mode 100644 dlls/d3d9/surface.c create mode 100644 dlls/d3d9/swapchain.c create mode 100644 dlls/d3d9/texture.c create mode 100644 dlls/d3d9/version.rc create mode 100644 dlls/d3d9/vertexbuffer.c create mode 100644 dlls/d3d9/vertexdeclaration.c create mode 100644 dlls/d3d9/vertexshader.c create mode 100644 dlls/d3d9/volume.c create mode 100644 dlls/d3d9/volumetexture.c create mode 100644 dlls/d3d9/vshaderdeclaration.c diff --git a/dlls/d3d9/.cvsignore b/dlls/d3d9/.cvsignore new file mode 100644 index 00000000000..a57f3714793 --- /dev/null +++ b/dlls/d3d9/.cvsignore @@ -0,0 +1,5 @@ +Makefile +d3d9.dll.dbg.c +d3d9.spec.c +d3d9.spec.def +version.res diff --git a/dlls/d3d9/Makefile.in b/dlls/d3d9/Makefile.in new file mode 100644 index 00000000000..8f055b80206 --- /dev/null +++ b/dlls/d3d9/Makefile.in @@ -0,0 +1,37 @@ +TOPSRCDIR = @top_srcdir@ +TOPOBJDIR = ../.. +SRCDIR = @srcdir@ +VPATH = @srcdir@ +MODULE = d3d9.dll +IMPORTS = user32 gdi32 kernel32 +EXTRAINCL = @X_CFLAGS@ +EXTRALIBS = $(LIBUUID) @X_LIBS@ @X_PRE_LIBS@ @XLIB@ @X_EXTRA_LIBS@ @OPENGL_LIBS@ + +LDDLLFLAGS = @LDDLLFLAGS@ +SYMBOLFILE = $(MODULE).tmp.o + +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: diff --git a/dlls/d3d9/basetexture.c b/dlls/d3d9/basetexture.c new file mode 100644 index 00000000000..6b738e02cf4 --- /dev/null +++ b/dlls/d3d9/basetexture.c @@ -0,0 +1,170 @@ +/* + * IDirect3DBaseTexture9 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DBaseTexture9 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DBaseTexture9Impl_QueryInterface(LPDIRECT3DBASETEXTURE9 iface, REFIID riid, LPVOID* ppobj) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9)) { + IDirect3DBaseTexture9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DBaseTexture9Impl_AddRef(LPDIRECT3DBASETEXTURE9 iface) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DBaseTexture9Impl_Release(LPDIRECT3DBASETEXTURE9 iface) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) + HeapFree(GetProcessHeap(), 0, This); + return ref; +} + +/* IDirect3DBaseTexture9 IDirect3DResource9 Interface follow: */ +HRESULT WINAPI IDirect3DBaseTexture9Impl_GetDevice(LPDIRECT3DBASETEXTURE9 iface, IDirect3DDevice9** ppDevice) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + return IDirect3DResource9Impl_GetDevice((LPDIRECT3DRESOURCE9) This, ppDevice); +} + +HRESULT WINAPI IDirect3DBaseTexture9Impl_SetPrivateData(LPDIRECT3DBASETEXTURE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DBaseTexture9Impl_GetPrivateData(LPDIRECT3DBASETEXTURE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DBaseTexture9Impl_FreePrivateData(LPDIRECT3DBASETEXTURE9 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +DWORD WINAPI IDirect3DBaseTexture9Impl_SetPriority(LPDIRECT3DBASETEXTURE9 iface, DWORD PriorityNew) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + return IDirect3DResource9Impl_SetPriority((LPDIRECT3DRESOURCE9) This, PriorityNew); +} + +DWORD WINAPI IDirect3DBaseTexture9Impl_GetPriority(LPDIRECT3DBASETEXTURE9 iface) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + return IDirect3DResource9Impl_GetPriority((LPDIRECT3DRESOURCE9) This); +} + +void WINAPI IDirect3DBaseTexture9Impl_PreLoad(LPDIRECT3DBASETEXTURE9 iface) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return ; +} + +D3DRESOURCETYPE WINAPI IDirect3DBaseTexture9Impl_GetType(LPDIRECT3DBASETEXTURE9 iface) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + return IDirect3DResource9Impl_GetType((LPDIRECT3DRESOURCE9) This); +} + +/* IDirect3DBaseTexture9 Interface follow: */ +DWORD WINAPI IDirect3DBaseTexture9Impl_SetLOD(LPDIRECT3DBASETEXTURE9 iface, DWORD LODNew) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return 0; +} + +DWORD WINAPI IDirect3DBaseTexture9Impl_GetLOD(LPDIRECT3DBASETEXTURE9 iface) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return 0; +} + +DWORD WINAPI IDirect3DBaseTexture9Impl_GetLevelCount(LPDIRECT3DBASETEXTURE9 iface) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return 0; +} + +HRESULT WINAPI IDirect3DBaseTexture9Impl_SetAutoGenFilterType(LPDIRECT3DBASETEXTURE9 iface, D3DTEXTUREFILTERTYPE FilterType) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +D3DTEXTUREFILTERTYPE WINAPI IDirect3DBaseTexture9Impl_GetAutoGenFilterType(LPDIRECT3DBASETEXTURE9 iface) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3DTEXF_NONE; +} + +void WINAPI IDirect3DBaseTexture9Impl_GenerateMipSubLevels(LPDIRECT3DBASETEXTURE9 iface) { + ICOM_THIS(IDirect3DBaseTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return ; +} + + +ICOM_VTABLE(IDirect3DBaseTexture9) Direct3DBaseTexture9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + 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/dlls/d3d9/cubetexture.c b/dlls/d3d9/cubetexture.c new file mode 100644 index 00000000000..6cc3a5bffdb --- /dev/null +++ b/dlls/d3d9/cubetexture.c @@ -0,0 +1,258 @@ +/* + * IDirect3DCubeTexture9 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DCubeTexture9 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DCubeTexture9Impl_QueryInterface(LPDIRECT3DCUBETEXTURE9 iface, REFIID riid, LPVOID* ppobj) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9) + || IsEqualGUID(riid, &IID_IDirect3DCubeTexture9)) { + IDirect3DCubeTexture9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DCubeTexture9Impl_AddRef(LPDIRECT3DCUBETEXTURE9 iface) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DCubeTexture9Impl_Release(LPDIRECT3DCUBETEXTURE9 iface) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + ULONG ref = --This->ref; + int i; + int j; + + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + for (i = 0; i < This->levels; i++) { + for (j = 0; j < 6; j++) { + if (This->surfaces[j][i] != NULL) { + TRACE("(%p) : Releasing surface %p\n", This, This->surfaces[j][i]); + IDirect3DSurface9Impl_Release((LPDIRECT3DSURFACE9) This->surfaces[j][i]); + } + } + } + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DCubeTexture9 IDirect3DResource9 Interface follow: */ +HRESULT WINAPI IDirect3DCubeTexture9Impl_GetDevice(LPDIRECT3DCUBETEXTURE9 iface, IDirect3DDevice9** ppDevice) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + return IDirect3DResource9Impl_GetDevice((LPDIRECT3DRESOURCE9) This, ppDevice); +} + +HRESULT WINAPI IDirect3DCubeTexture9Impl_SetPrivateData(LPDIRECT3DCUBETEXTURE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DCubeTexture9Impl_GetPrivateData(LPDIRECT3DCUBETEXTURE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DCubeTexture9Impl_FreePrivateData(LPDIRECT3DCUBETEXTURE9 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +DWORD WINAPI IDirect3DCubeTexture9Impl_SetPriority(LPDIRECT3DCUBETEXTURE9 iface, DWORD PriorityNew) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + return IDirect3DResource9Impl_SetPriority((LPDIRECT3DRESOURCE9) This, PriorityNew); +} + +DWORD WINAPI IDirect3DCubeTexture9Impl_GetPriority(LPDIRECT3DCUBETEXTURE9 iface) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + return IDirect3DResource9Impl_GetPriority((LPDIRECT3DRESOURCE9) This); +} + +void WINAPI IDirect3DCubeTexture9Impl_PreLoad(LPDIRECT3DCUBETEXTURE9 iface) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return ; +} + +D3DRESOURCETYPE WINAPI IDirect3DCubeTexture9Impl_GetType(LPDIRECT3DCUBETEXTURE9 iface) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + return IDirect3DResource9Impl_GetType((LPDIRECT3DRESOURCE9) This); +} + +/* IDirect3DCubeTexture9 IDirect3DBaseTexture9 Interface follow: */ +DWORD WINAPI IDirect3DCubeTexture9Impl_SetLOD(LPDIRECT3DCUBETEXTURE9 iface, DWORD LODNew) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + return IDirect3DBaseTexture9Impl_SetLOD((LPDIRECT3DBASETEXTURE9) This, LODNew); +} + +DWORD WINAPI IDirect3DCubeTexture9Impl_GetLOD(LPDIRECT3DCUBETEXTURE9 iface) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + return IDirect3DBaseTexture9Impl_GetLOD((LPDIRECT3DBASETEXTURE9) This); +} + +DWORD WINAPI IDirect3DCubeTexture9Impl_GetLevelCount(LPDIRECT3DCUBETEXTURE9 iface) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + return IDirect3DBaseTexture9Impl_GetLevelCount((LPDIRECT3DBASETEXTURE9) This); +} + +HRESULT WINAPI IDirect3DCubeTexture9Impl_SetAutoGenFilterType(LPDIRECT3DCUBETEXTURE9 iface, D3DTEXTUREFILTERTYPE FilterType) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + return IDirect3DBaseTexture9Impl_SetAutoGenFilterType((LPDIRECT3DBASETEXTURE9) This, FilterType); +} + +D3DTEXTUREFILTERTYPE WINAPI IDirect3DCubeTexture9Impl_GetAutoGenFilterType(LPDIRECT3DCUBETEXTURE9 iface) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + return IDirect3DBaseTexture9Impl_GetAutoGenFilterType((LPDIRECT3DBASETEXTURE9) This); +} + +void WINAPI IDirect3DCubeTexture9Impl_GenerateMipSubLevels(LPDIRECT3DCUBETEXTURE9 iface) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return ; +} + +/* IDirect3DCubeTexture9 Interface follow: */ +HRESULT WINAPI IDirect3DCubeTexture9Impl_GetLevelDesc(LPDIRECT3DCUBETEXTURE9 iface, UINT Level, D3DSURFACE_DESC* pDesc) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + if (Level < This->levels) { + TRACE("(%p) level (%d)\n", This, Level); + return IDirect3DSurface9Impl_GetDesc((LPDIRECT3DSURFACE9) This->surfaces[0][Level], pDesc); + } else { + FIXME("(%p) level(%d) overflow Levels(%d)\n", This, Level, This->levels); + return D3DERR_INVALIDCALL; + } + return D3D_OK; +} + +HRESULT WINAPI IDirect3DCubeTexture9Impl_GetCubeMapSurface(LPDIRECT3DCUBETEXTURE9 iface, D3DCUBEMAP_FACES FaceType, UINT Level, IDirect3DSurface9** ppCubeMapSurface) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + if (Level < This->levels) { + *ppCubeMapSurface = (LPDIRECT3DSURFACE9) This->surfaces[FaceType][Level]; + IDirect3DSurface9Impl_AddRef((LPDIRECT3DSURFACE9) *ppCubeMapSurface); + TRACE("(%p) -> faceType(%d) level(%d) returning surface@%p \n", This, FaceType, Level, This->surfaces[FaceType][Level]); + } else { + FIXME("(%p) level(%d) overflow Levels(%d)\n", This, Level, This->levels); + return D3DERR_INVALIDCALL; + } + return D3D_OK; +} + +HRESULT WINAPI IDirect3DCubeTexture9Impl_LockRect(LPDIRECT3DCUBETEXTURE9 iface, D3DCUBEMAP_FACES FaceType, UINT Level, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) { + HRESULT hr; + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + if (Level < This->levels) { + /** + * Not dirtified while Surfaces don't notify dirtification + * This->Dirty = TRUE; + */ + hr = IDirect3DSurface9Impl_LockRect((LPDIRECT3DSURFACE9) This->surfaces[FaceType][Level], pLockedRect, pRect, Flags); + TRACE("(%p) -> faceType(%d) level(%d) returning memory@%p success(%lu)\n", This, FaceType, Level, pLockedRect->pBits, hr); + } else { + FIXME("(%p) level(%d) overflow Levels(%d)\n", This, Level, This->levels); + return D3DERR_INVALIDCALL; + } + return hr; +} + +HRESULT WINAPI IDirect3DCubeTexture9Impl_UnlockRect(LPDIRECT3DCUBETEXTURE9 iface, D3DCUBEMAP_FACES FaceType, UINT Level) { + HRESULT hr; + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + if (Level < This->levels) { + hr = IDirect3DSurface9Impl_UnlockRect((LPDIRECT3DSURFACE9) This->surfaces[FaceType][Level]); + TRACE("(%p) -> faceType(%d) level(%d) success(%lu)\n", This, FaceType, Level, hr); + } else { + FIXME("(%p) level(%d) overflow Levels(%d)\n", This, Level, This->levels); + return D3DERR_INVALIDCALL; + } + return hr; +} + +HRESULT WINAPI IDirect3DCubeTexture9Impl_AddDirtyRect(LPDIRECT3DCUBETEXTURE9 iface, D3DCUBEMAP_FACES FaceType, CONST RECT* pDirtyRect) { + ICOM_THIS(IDirect3DCubeTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + This->Dirty = TRUE; + return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DCubeTexture9) Direct3DCubeTexture9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DCubeTexture9Impl_QueryInterface, + IDirect3DCubeTexture9Impl_AddRef, + IDirect3DCubeTexture9Impl_Release, + IDirect3DCubeTexture9Impl_GetDevice, + IDirect3DCubeTexture9Impl_SetPrivateData, + IDirect3DCubeTexture9Impl_GetPrivateData, + IDirect3DCubeTexture9Impl_FreePrivateData, + IDirect3DCubeTexture9Impl_SetPriority, + IDirect3DCubeTexture9Impl_GetPriority, + IDirect3DCubeTexture9Impl_PreLoad, + IDirect3DCubeTexture9Impl_GetType, + 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) { + + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} diff --git a/dlls/d3d9/d3d9.spec b/dlls/d3d9/d3d9.spec new file mode 100644 index 00000000000..c72b3802e8f --- /dev/null +++ b/dlls/d3d9/d3d9.spec @@ -0,0 +1,5 @@ +@ stdcall D3D9GetSWInfo() +@ stdcall DebugSetMute() +@ stdcall Direct3DCreate9(long) +@ stdcall ValidatePixelShader(ptr ptr) +@ stdcall ValidateVertexShader(ptr ptr) diff --git a/dlls/d3d9/d3d9_main.c b/dlls/d3d9/d3d9_main.c new file mode 100644 index 00000000000..5b1be9d201e --- /dev/null +++ b/dlls/d3d9/d3d9_main.c @@ -0,0 +1,95 @@ +/* + * Direct3D 9 + * + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "wingdi.h" +#include "winuser.h" +#include "wine/debug.h" + +#include "d3d9.h" +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + + +void (*wine_tsx11_lock_ptr)(void) = NULL; +void (*wine_tsx11_unlock_ptr)(void) = NULL; + + +HRESULT WINAPI D3D9GetSWInfo(void) { + FIXME("(void): stub\n"); + return 0; +} + +void 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; + + TRACE("SDKVersion = %x, Created Direct3D object at %p\n", SDKVersion, object); + + return (IDirect3D9*) object; +} + +/* At process attach */ +BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv) { + TRACE("fdwReason=%ld\n", fdwReason); + if (fdwReason == DLL_PROCESS_ATTACH) { + HMODULE mod; + + DisableThreadLibraryCalls(hInstDLL); + + mod = GetModuleHandleA( "x11drv.dll" ); + if (mod) + { + wine_tsx11_lock_ptr = (void*) GetProcAddress(mod, "wine_tsx11_lock"); + wine_tsx11_unlock_ptr = (void*) GetProcAddress(mod, "wine_tsx11_unlock"); + } + } + return TRUE; +} + +/*********************************************************************** + * ValidateVertexShader (D3D9.@) + */ +BOOL WINAPI ValidateVertexShader(LPVOID what, LPVOID toto) { + FIXME("(void): stub: %p %p\n", what, toto); + return TRUE; +} + +/*********************************************************************** + * ValidatePixelShader (D3D9.@) + */ +BOOL WINAPI ValidatePixelShader(LPVOID what, LPVOID toto) { + FIXME("(void): stub: %p %p\n", what, toto); + return TRUE; +} diff --git a/dlls/d3d9/d3d9_private.h b/dlls/d3d9/d3d9_private.h new file mode 100644 index 00000000000..79f958a7fb4 --- /dev/null +++ b/dlls/d3d9/d3d9_private.h @@ -0,0 +1,1199 @@ +/* + * Direct3D 9 private include file + * + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef __WINE_D3D9_PRIVATE_H +#define __WINE_D3D9_PRIVATE_H + +#ifndef __WINE_CONFIG_H +# error You must include config.h to use this header +#endif + +/* THIS FILE MUST NOT CONTAIN X11 or MESA DEFINES */ +/* +#define XMD_H +#include +#include +#ifdef HAVE_GL_GLEXT_H +# include +#endif +#undef XMD_H +*/ + +#undef APIENTRY +#undef CALLBACK +#undef WINAPI + +/* Redefines the constants */ +#define CALLBACK __stdcall +#define WINAPI __stdcall +#define APIENTRY WINAPI + +/* X11 locking */ + +extern void (*wine_tsx11_lock_ptr)(void); +extern void (*wine_tsx11_unlock_ptr)(void); + +/* As GLX relies on X, this is needed */ +#define ENTER_GL() wine_tsx11_lock_ptr() +#define LEAVE_GL() wine_tsx11_unlock_ptr() + +#include "d3d9.h" + +/* Device caps */ +#define MAX_PALETTES 256 +#define MAX_STREAMS 16 +#define MAX_ACTIVE_LIGHTS 8 +#define MAX_CLIPPLANES D3DMAXUSERCLIPPLANES +#define MAX_LEVELS 256 + +/* Other useful values */ +#define HIGHEST_RENDER_STATE 174 +#define HIGHEST_TEXTURE_STATE 29 +#define HIGHEST_TRANSFORMSTATE 512 +#define D3DSBT_RECORDED 0xfffffffe + +#define D3D_VSHADER_MAX_CONSTANTS 96 +#define D3D_PSHADER_MAX_CONSTANTS 32 + +/* Direct3D9 Interfaces: */ +typedef struct IDirect3D9Impl IDirect3D9Impl; +typedef struct IDirect3DDevice9Impl IDirect3DDevice9Impl; +typedef struct IDirect3DBaseTexture9Impl IDirect3DBaseTexture9Impl; +typedef struct IDirect3DTexture9Impl IDirect3DTexture9Impl; +typedef struct IDirect3DVolumeTexture9Impl IDirect3DVolumeTexture9Impl; +typedef struct IDirect3DCubeTexture9Impl IDirect3DCubeTexture9Impl; +typedef struct IDirect3DVertexBuffer9Impl IDirect3DVertexBuffer9Impl; +typedef struct IDirect3DIndexBuffer9Impl IDirect3DIndexBuffer9Impl; +typedef struct IDirect3DSurface9Impl IDirect3DSurface9Impl; +typedef struct IDirect3DSwapChain9Impl IDirect3DSwapChain9Impl; +typedef struct IDirect3DResource9Impl IDirect3DResource9Impl; +typedef struct IDirect3DVolume9Impl IDirect3DVolume9Impl; +typedef struct IDirect3DStateBlock9Impl IDirect3DStateBlock9Impl; +typedef struct IDirect3DVertexShader9Impl IDirect3DVertexShader9Impl; +typedef struct IDirect3DPixelShader9Impl IDirect3DPixelShader9Impl; +typedef struct IDirect3DVertexDeclaration9Impl IDirect3DVertexDeclaration9Impl; +typedef struct IDirect3DQuery9Impl IDirect3DQuery9Impl; + + +#define D3DCOLOR_R(dw) (((float) (((dw) >> 16) & 0xFF)) / 255.0f) +#define D3DCOLOR_G(dw) (((float) (((dw) >> 8) & 0xFF)) / 255.0f) +#define D3DCOLOR_B(dw) (((float) (((dw) >> 0) & 0xFF)) / 255.0f) +#define D3DCOLOR_A(dw) (((float) (((dw) >> 24) & 0xFF)) / 255.0f) + +#define D3DCOLORTOCOLORVALUE(dw, col) \ + (col).r = D3DCOLOR_R(dw); \ + (col).g = D3DCOLOR_G(dw); \ + (col).b = D3DCOLOR_B(dw); \ + (col).a = D3DCOLOR_A(dw); + +#define D3DCOLORTOVECTOR4(dw, vec) \ + (vec).x = D3DCOLOR_R(dw); \ + (vec).y = D3DCOLOR_G(dw); \ + (vec).z = D3DCOLOR_B(dw); \ + (vec).w = D3DCOLOR_A(dw); + +#define D3DCOLORTOGLFLOAT4(dw, vec) \ + (vec)[0] = D3DCOLOR_R(dw); \ + (vec)[1] = D3DCOLOR_G(dw); \ + (vec)[2] = D3DCOLOR_B(dw); \ + (vec)[3] = D3DCOLOR_A(dw); + +/** + * State Block for Begin/End/Capture/Create/Apply State Block + * Note: Very long winded but I do not believe gl Lists will + * resolve everything we need, so doing it manually for now + */ +typedef struct SAVEDSTATES { + BOOL lightEnable[MAX_ACTIVE_LIGHTS]; + BOOL Indices; + BOOL lights[MAX_ACTIVE_LIGHTS]; + BOOL material; + BOOL stream_source[MAX_STREAMS]; + BOOL textures[8]; + BOOL transform[HIGHEST_TRANSFORMSTATE]; + BOOL viewport; + BOOL vertexShader; + BOOL vertexShaderConstant; + BOOL vertexShaderDecl; + BOOL pixelShader; + BOOL pixelShaderConstant; + BOOL renderstate[HIGHEST_RENDER_STATE]; + BOOL texture_state[8][HIGHEST_TEXTURE_STATE]; + BOOL clipplane[MAX_CLIPPLANES]; +} SAVEDSTATES; + +typedef struct D3DSHADERVECTORF { + float x; + float y; + float z; + float w; +} D3DSHADERVECTORF; + +typedef struct D3DSHADERVECTORI { + int x; + int y; + int z; + int w; +} D3DSHADERVECTORI; + +/* =========================================================================== + The interfactes themselves + =========================================================================== */ + +/* ---------- */ +/* IDirect3D9 */ +/* ---------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3D9) Direct3D9_Vtbl; + +/***************************************************************************** + * IDirect3D implementation structure + */ +struct IDirect3D9Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3D9); + DWORD ref; + + /* IDirect3D9 fields */ + /* + GL_Info gl_info; + */ +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3D9Impl_QueryInterface(LPDIRECT3D9 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3D9Impl_AddRef(LPDIRECT3D9 iface); +extern ULONG WINAPI IDirect3D9Impl_Release(LPDIRECT3D9 iface); + +/* IDirect3d9: */ +extern HRESULT WINAPI IDirect3D9Impl_RegisterSoftwareDevice(LPDIRECT3D9 iface, void* pInitializeFunction); +extern UINT WINAPI IDirect3D9Impl_GetAdapterCount(LPDIRECT3D9 iface); +extern HRESULT WINAPI IDirect3D9Impl_GetAdapterIdentifier(LPDIRECT3D9 iface, UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER9* pIdentifier); +extern UINT WINAPI IDirect3D9Impl_GetAdapterModeCount(LPDIRECT3D9 iface, UINT Adapter, D3DFORMAT Format); +extern HRESULT WINAPI IDirect3D9Impl_EnumAdapterModes(LPDIRECT3D9 iface, UINT Adapter, D3DFORMAT Format, UINT Mode, D3DDISPLAYMODE* pMode); +extern HRESULT WINAPI IDirect3D9Impl_GetAdapterDisplayMode(LPDIRECT3D9 iface, UINT Adapter, D3DDISPLAYMODE* pMode); +extern HRESULT WINAPI IDirect3D9Impl_CheckDeviceType(LPDIRECT3D9 iface, UINT Adapter, D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat, D3DFORMAT BackBufferFormat, BOOL Windowed); +extern HRESULT WINAPI IDirect3D9Impl_CheckDeviceFormat(LPDIRECT3D9 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat); +extern HRESULT WINAPI IDirect3D9Impl_CheckDeviceMultiSampleType(LPDIRECT3D9 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType, DWORD* pQualityLevels); +extern HRESULT WINAPI IDirect3D9Impl_CheckDepthStencilMatch(LPDIRECT3D9 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat); +extern HRESULT WINAPI IDirect3D9Impl_CheckDeviceFormatConversion(LPDIRECT3D9 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SourceFormat, D3DFORMAT TargetFormat); +extern HRESULT WINAPI IDirect3D9Impl_GetDeviceCaps(LPDIRECT3D9 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS9* pCaps); +extern HMONITOR WINAPI IDirect3D9Impl_GetAdapterMonitor(LPDIRECT3D9 iface, UINT Adapter); +extern HRESULT WINAPI IDirect3D9Impl_CreateDevice(LPDIRECT3D9 iface, UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow, DWORD BehaviorFlags, D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DDevice9** ppReturnedDeviceInterface); + +/* ---------------- */ +/* IDirect3DDevice9 */ +/* ---------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DDevice9) Direct3DDevice9_Vtbl; + +/***************************************************************************** + * IDirect3DDevice9 implementation structure + */ +struct IDirect3DDevice9Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DDevice9); + DWORD ref; + + /* IDirect3DDevice9 fields */ + IDirect3D9Impl *direct3d; + + IDirect3DSurface9Impl *frontBuffer; + IDirect3DSurface9Impl *backBuffer; + IDirect3DSurface9Impl *depthStencilBuffer; + + IDirect3DSurface9Impl *renderTarget; + IDirect3DSurface9Impl *stencilBufferTarget; + + D3DPRESENT_PARAMETERS PresentParms; + D3DDEVICE_CREATION_PARAMETERS CreateParms; + + UINT adapterNo; + D3DDEVTYPE devType; + + UINT srcBlend; + UINT dstBlend; + UINT alphafunc; + UINT stencilfunc; + + /* State block related */ + BOOL isRecordingState; + IDirect3DStateBlock9Impl *StateBlock; + IDirect3DStateBlock9Impl *UpdateStateBlock; + + /* Other required values */ + float lightPosn[MAX_ACTIVE_LIGHTS][4]; + float lightDirn[MAX_ACTIVE_LIGHTS][4]; + + /* palettes texture management */ + PALETTEENTRY palettes[MAX_PALETTES][256]; + UINT currentPalette; + + /* Optimization */ + D3DMATRIX lastProj; + D3DMATRIX lastView; + D3DMATRIX lastWorld0; + D3DMATRIX lastTexTrans[8]; + + /* OpenGL related */ + /* + GLXContext glCtx; + XVisualInfo *visInfo; + Display *display; + GLXContext render_ctx; + Drawable drawable; + Window win; + */ + HWND win_handle; + + /* OpenGL Extension related */ + + /* Cursor management */ + BOOL bCursorVisible; + UINT xHotSpot; + UINT yHotSpot; + UINT xScreenSpace; + UINT yScreenSpace; + + UINT dummyTextureName[8]; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DDevice9Impl_QueryInterface(LPDIRECT3DDEVICE9 iface, REFIID refiid, LPVOID *obj); +extern ULONG WINAPI IDirect3DDevice9Impl_AddRef(LPDIRECT3DDEVICE9 iface); +extern ULONG WINAPI IDirect3DDevice9Impl_Release(LPDIRECT3DDEVICE9 iface); + +/* IDirect3DDevice9: */ +extern HRESULT WINAPI IDirect3DDevice9Impl_TestCooperativeLevel(LPDIRECT3DDEVICE9 iface); +extern UINT WINAPI IDirect3DDevice9Impl_GetAvailableTextureMem(LPDIRECT3DDEVICE9 iface); +extern HRESULT WINAPI IDirect3DDevice9Impl_EvictManagedRessources(LPDIRECT3DDEVICE9 iface); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetDirect3D(LPDIRECT3DDEVICE9 iface, IDirect3D9** ppD3D9); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetDeviceCaps(LPDIRECT3DDEVICE9 iface, D3DCAPS9* pCaps); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetDisplayMode(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, D3DDISPLAYMODE* pMode); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetCreationParameters(LPDIRECT3DDEVICE9 iface, D3DDEVICE_CREATION_PARAMETERS* pParameters); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetCursorProperties(LPDIRECT3DDEVICE9 iface, UINT XHotSpot, UINT YHotSpot, IDirect3DSurface9* pCursorBitmap); +extern void WINAPI IDirect3DDevice9Impl_SetCursorPosition(LPDIRECT3DDEVICE9 iface, int XScreenSpace, int YScreenSpace, DWORD Flags); +extern BOOL WINAPI IDirect3DDevice9Impl_ShowCursor(LPDIRECT3DDEVICE9 iface, BOOL bShow); +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_Reset(LPDIRECT3DDEVICE9 iface, D3DPRESENT_PARAMETERS* pPresentationParameters); +extern HRESULT WINAPI IDirect3DDevice9Impl_Present(LPDIRECT3DDEVICE9 iface, CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetBackBuffer(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, UINT BackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface9** ppBackBuffer); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetRasterStatus(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, D3DRASTER_STATUS* pRasterStatus); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetDialogBoxMode(LPDIRECT3DDEVICE9 iface, BOOL bEnableDialogs); +extern void WINAPI IDirect3DDevice9Impl_SetGammaRamp(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, DWORD Flags, CONST D3DGAMMARAMP* pRamp); +extern void WINAPI IDirect3DDevice9Impl_GetGammaRamp(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, D3DGAMMARAMP* pRamp); +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_CreateRenderTarget(LPDIRECT3DDEVICE9 iface, UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality, BOOL Lockable, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle); +extern HRESULT WINAPI IDirect3DDevice9Impl_CreateDepthStencilSurface(LPDIRECT3DDEVICE9 iface, UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality, BOOL Discard, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle); +extern HRESULT WINAPI IDirect3DDevice9Impl_UpdateSurface(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pSourceSurface, CONST RECT* pSourceRect, IDirect3DSurface9* pDestinationSurface, CONST POINT* pDestPoint); +extern HRESULT WINAPI IDirect3DDevice9Impl_UpdateTexture(LPDIRECT3DDEVICE9 iface, IDirect3DBaseTexture9* pSourceTexture, IDirect3DBaseTexture9* pDestinationTexture); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetRenderTargetData(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pRenderTarget, IDirect3DSurface9* pDestSurface); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetFrontBufferData(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, IDirect3DSurface9* pDestSurface); +extern HRESULT WINAPI IDirect3DDevice9Impl_StretchRects(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pSourceSurface, CONST RECT* pSourceRect, IDirect3DSurface9* pDestSurface, CONST RECT* pDestRect, D3DTEXTUREFILTERTYPE Filter); +extern HRESULT WINAPI IDirect3DDevice9Impl_ColorFill(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pSurface, CONST RECT* pRect, D3DCOLOR color); +extern HRESULT WINAPI IDirect3DDevice9Impl_CreateOffscreenPlainSurface(LPDIRECT3DDEVICE9 iface, UINT Width, UINT Height, D3DFORMAT Format, D3DPOOL Pool, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetRenderTarget(LPDIRECT3DDEVICE9 iface, DWORD RenderTargetIndex, IDirect3DSurface9* pRenderTarget); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetRenderTarget(LPDIRECT3DDEVICE9 iface, DWORD RenderTargetIndex, IDirect3DSurface9** ppRenderTarget); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetDepthStencilSurface(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pNewZStencilSurface); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetDepthStencilSurface(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9** ppZStencilSurface); +extern HRESULT WINAPI IDirect3DDevice9Impl_BeginScene(LPDIRECT3DDEVICE9 iface); +extern HRESULT WINAPI IDirect3DDevice9Impl_EndScene(LPDIRECT3DDEVICE9 iface); +extern HRESULT WINAPI IDirect3DDevice9Impl_Clear(LPDIRECT3DDEVICE9 iface, DWORD Count, CONST D3DRECT* pRects, DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetTransform(LPDIRECT3DDEVICE9 iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetTransform(LPDIRECT3DDEVICE9 iface, D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix); +extern HRESULT WINAPI IDirect3DDevice9Impl_MultiplyTransform(LPDIRECT3DDEVICE9 iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetViewport(LPDIRECT3DDEVICE9 iface, CONST D3DVIEWPORT9* pViewport); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetViewport(LPDIRECT3DDEVICE9 iface, D3DVIEWPORT9* pViewport); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetMaterial(LPDIRECT3DDEVICE9 iface, CONST D3DMATERIAL9* pMaterial); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetMaterial(LPDIRECT3DDEVICE9 iface, D3DMATERIAL9* pMaterial); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetLight(LPDIRECT3DDEVICE9 iface, DWORD Index, CONST D3DLIGHT9* pLight); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetLight(LPDIRECT3DDEVICE9 iface, DWORD Index, D3DLIGHT9* pLight); +extern HRESULT WINAPI IDirect3DDevice9Impl_LightEnable(LPDIRECT3DDEVICE9 iface, DWORD Index, BOOL Enable); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetLightEnable(LPDIRECT3DDEVICE9 iface, DWORD Index, BOOL* pEnable); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetClipPlane(LPDIRECT3DDEVICE9 iface, DWORD Index, CONST float* pPlane); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetClipPlane(LPDIRECT3DDEVICE9 iface, DWORD Index, float* pPlane); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetRenderState(LPDIRECT3DDEVICE9 iface, D3DRENDERSTATETYPE State, DWORD Value); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetRenderState(LPDIRECT3DDEVICE9 iface, D3DRENDERSTATETYPE State, DWORD* pValue); +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_SetClipStatus(LPDIRECT3DDEVICE9 iface, CONST D3DCLIPSTATUS9* pClipStatus); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetClipStatus(LPDIRECT3DDEVICE9 iface, D3DCLIPSTATUS9* pClipStatus); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetTexture(LPDIRECT3DDEVICE9 iface, DWORD Stage, IDirect3DBaseTexture9** ppTexture); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetTexture(LPDIRECT3DDEVICE9 iface, DWORD Stage, IDirect3DBaseTexture9* pTexture); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetTextureStageState(LPDIRECT3DDEVICE9 iface, DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD* pValue); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetTextureStageState(LPDIRECT3DDEVICE9 iface, DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetSamplerState(LPDIRECT3DDEVICE9 iface, DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD* pValue); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetSamplerState(LPDIRECT3DDEVICE9 iface, DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value); +extern HRESULT WINAPI IDirect3DDevice9Impl_ValidateDevice(LPDIRECT3DDEVICE9 iface, DWORD* pNumPasses); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetPaletteEntries(LPDIRECT3DDEVICE9 iface, UINT PaletteNumber, CONST PALETTEENTRY* pEntries); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetPaletteEntries(LPDIRECT3DDEVICE9 iface, UINT PaletteNumber, PALETTEENTRY* pEntries); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetCurrentTexturePalette(LPDIRECT3DDEVICE9 iface, UINT PaletteNumber); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetCurrentTexturePalette(LPDIRECT3DDEVICE9 iface, UINT *PaletteNumber); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetScissorRect(LPDIRECT3DDEVICE9 iface, CONST RECT* pRect); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetScissorRect(LPDIRECT3DDEVICE9 iface, RECT* pRect); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetSoftwareVertexProcessing(LPDIRECT3DDEVICE9 iface, BOOL bSoftware); +extern BOOL WINAPI IDirect3DDevice9Impl_GetSoftwareVertexProcessing(LPDIRECT3DDEVICE9 iface); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetNPatchMode(LPDIRECT3DDEVICE9 iface, float nSegments); +extern float WINAPI IDirect3DDevice9Impl_GetNPatchMode(LPDIRECT3DDEVICE9 iface); +extern HRESULT WINAPI IDirect3DDevice9Impl_DrawPrimitive(LPDIRECT3DDEVICE9 iface, D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount); +extern HRESULT WINAPI IDirect3DDevice9Impl_DrawIndexedPrimitive(LPDIRECT3DDEVICE9 iface, D3DPRIMITIVETYPE, INT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount); +extern HRESULT WINAPI IDirect3DDevice9Impl_DrawPrimitiveUP(LPDIRECT3DDEVICE9 iface, D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride); +extern HRESULT WINAPI IDirect3DDevice9Impl_DrawIndexedPrimitiveUP(LPDIRECT3DDEVICE9 iface, D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex, UINT NumVertices, UINT PrimitiveCount, CONST void* pIndexData, D3DFORMAT IndexDataFormat, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride); +extern HRESULT WINAPI IDirect3DDevice9Impl_ProcessVertices(LPDIRECT3DDEVICE9 iface, UINT SrcStartIndex, UINT DestIndex, UINT VertexCount, IDirect3DVertexBuffer9* pDestBuffer, IDirect3DVertexDeclaration9* pVertexDecl, DWORD Flags); +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_SetStreamSourceFreq(LPDIRECT3DDEVICE9 iface, UINT StreamNumber, UINT Divider); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetStreamSourceFreq(LPDIRECT3DDEVICE9 iface, UINT StreamNumber, UINT* Divider); +extern HRESULT WINAPI IDirect3DDevice9Impl_SetIndices(LPDIRECT3DDEVICE9 iface, IDirect3DIndexBuffer9* pIndexData); +extern HRESULT WINAPI IDirect3DDevice9Impl_GetIndices(LPDIRECT3DDEVICE9 iface, IDirect3DIndexBuffer9** ppIndexData); +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_DrawRectPatch(LPDIRECT3DDEVICE9 iface, UINT Handle, CONST float* pNumSegs, CONST D3DRECTPATCH_INFO* pRectPatchInfo); +extern HRESULT WINAPI IDirect3DDevice9Impl_DrawTriPatch(LPDIRECT3DDEVICE9 iface, UINT Handle, CONST float* pNumSegs, CONST D3DTRIPATCH_INFO* pTriPatchInfo); +extern HRESULT WINAPI IDirect3DDevice9Impl_DeletePatch(LPDIRECT3DDEVICE9 iface, UINT Handle); +extern HRESULT WINAPI IDirect3DDevice9Impl_CreateQuery(LPDIRECT3DDEVICE9 iface, D3DQUERYTYPE Type, IDirect3DQuery9** ppQuery); + + +/* ---------------- */ +/* IDirect3DVolume9 */ +/* ---------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DVolume9) Direct3DVolume9_Vtbl; + +/***************************************************************************** + * IDirect3DVolume9 implementation structure + */ +struct IDirect3DVolume9Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DVolume9); + DWORD ref; + + /* IDirect3DVolume9 fields */ + IDirect3DDevice9Impl *Device; + D3DRESOURCETYPE ResourceType; + + IUnknown *Container; + D3DVOLUME_DESC myDesc; + BYTE *allocatedMemory; + UINT textureName; + UINT bytesPerPixel; + + BOOL lockable; + BOOL locked; + D3DBOX lockedBox; + D3DBOX dirtyBox; + BOOL Dirty; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DVolume9Impl_QueryInterface(LPDIRECT3DVOLUME9 iface, REFIID refiid, LPVOID* obj); +extern ULONG WINAPI IDirect3DVolume9Impl_AddRef(LPDIRECT3DVOLUME9 iface); +extern ULONG WINAPI IDirect3DVolume9Impl_Release(LPDIRECT3DVOLUME9 iface); + +/* IDirect3DVolume9: */ +extern HRESULT WINAPI IDirect3DVolume9Impl_GetDevice(LPDIRECT3DVOLUME9 iface, IDirect3DDevice9** ppDevice); +extern HRESULT WINAPI IDirect3DVolume9Impl_SetPrivateData(LPDIRECT3DVOLUME9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DVolume9Impl_GetPrivateData(LPDIRECT3DVOLUME9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DVolume9Impl_FreePrivateData(LPDIRECT3DVOLUME9 iface, REFGUID refguid); +extern HRESULT WINAPI IDirect3DVolume9Impl_GetContainer(LPDIRECT3DVOLUME9 iface, REFIID riid, void** ppContainer); +extern HRESULT WINAPI IDirect3DVolume9Impl_GetDesc(LPDIRECT3DVOLUME9 iface, D3DVOLUME_DESC* pDesc); +extern HRESULT WINAPI IDirect3DVolume9Impl_LockBox(LPDIRECT3DVOLUME9 iface, D3DLOCKED_BOX* pLockedVolume, CONST D3DBOX* pBox, DWORD Flags); +extern HRESULT WINAPI IDirect3DVolume9Impl_UnlockBox(LPDIRECT3DVOLUME9 iface); + + +/* ------------------- */ +/* IDirect3DSwapChain9 */ +/* ------------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DSwapChain9) Direct3DSwapChain9_Vtbl; + +/***************************************************************************** + * IDirect3DSwapChain9 implementation structure + */ +struct IDirect3DSwapChain9Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DSwapChain9); + DWORD ref; + + /* IDirect3DSwapChain9 fields */ + IDirect3DDevice9Impl *Device; + IDirect3DSurface9Impl *frontBuffer; + IDirect3DSurface9Impl *backBuffer; + IDirect3DSurface9Impl *depthStencilBuffer; + D3DPRESENT_PARAMETERS PresentParms; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DSwapChain9Impl_QueryInterface(LPDIRECT3DSWAPCHAIN9 iface, REFIID refiid, LPVOID* obj); +extern ULONG WINAPI IDirect3DSwapChain9Impl_AddRef(LPDIRECT3DSWAPCHAIN9 iface); +extern ULONG WINAPI IDirect3DSwapChain9Impl_Release(LPDIRECT3DSWAPCHAIN9 iface); + +/* IDirect3DSwapChain9: */ +extern HRESULT WINAPI IDirect3DSwapChain9Impl_Present(LPDIRECT3DSWAPCHAIN9 iface, CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion, DWORD dwFlags); +extern HRESULT WINAPI IDirect3DSwapChain9Impl_GetFrontBufferData(LPDIRECT3DSWAPCHAIN9 iface, IDirect3DSurface9* pDestSurface); +extern HRESULT WINAPI IDirect3DSwapChain9Impl_GetBackBuffer(LPDIRECT3DSWAPCHAIN9 iface, UINT iBackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface9** ppBackBuffer); +extern HRESULT WINAPI IDirect3DSwapChain9Impl_GetRasterStatus(LPDIRECT3DSWAPCHAIN9 iface, D3DRASTER_STATUS* pRasterStatus); +extern HRESULT WINAPI IDirect3DSwapChain9Impl_GetDisplayMode(LPDIRECT3DSWAPCHAIN9 iface, D3DDISPLAYMODE* pMode); +extern HRESULT WINAPI IDirect3DSwapChain9Impl_GetDevice(LPDIRECT3DSWAPCHAIN9 iface, IDirect3DDevice9** ppDevice); +extern HRESULT WINAPI IDirect3DSwapChain9Impl_GetPresentParameters(LPDIRECT3DSWAPCHAIN9 iface, D3DPRESENT_PARAMETERS* pPresentationParameters); + + +/* ------------------ */ +/* IDirect3DResource9 */ +/* ------------------ */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DResource9) Direct3DResource9_Vtbl; + +/***************************************************************************** + * IDirect3DResource9 implementation structure + */ +struct IDirect3DResource9Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DResource9); + DWORD ref; + + /* IDirect3DResource9 fields */ + IDirect3DDevice9Impl *Device; + D3DRESOURCETYPE ResourceType; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DResource9Impl_QueryInterface(LPDIRECT3DRESOURCE9 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DResource9Impl_AddRef(LPDIRECT3DRESOURCE9 iface); +extern ULONG WINAPI IDirect3DResource9Impl_Release(LPDIRECT3DRESOURCE9 iface); + +/* IDirect3DResource9: */ +extern HRESULT WINAPI IDirect3DResource9Impl_GetDevice(LPDIRECT3DRESOURCE9 iface, IDirect3DDevice9** ppDevice); +extern HRESULT WINAPI IDirect3DResource9Impl_SetPrivateData(LPDIRECT3DRESOURCE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DResource9Impl_GetPrivateData(LPDIRECT3DRESOURCE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DResource9Impl_FreePrivateData(LPDIRECT3DRESOURCE9 iface, REFGUID refguid); +extern DWORD WINAPI IDirect3DResource9Impl_SetPriority(LPDIRECT3DRESOURCE9 iface, DWORD PriorityNew); +extern DWORD WINAPI IDirect3DResource9Impl_GetPriority(LPDIRECT3DRESOURCE9 iface); +extern void WINAPI IDirect3DResource9Impl_PreLoad(LPDIRECT3DRESOURCE9 iface); +extern D3DRESOURCETYPE WINAPI IDirect3DResource9Impl_GetType(LPDIRECT3DRESOURCE9 iface); + + +/* ----------------- */ +/* IDirect3DSurface9 */ +/* ----------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DSurface9) Direct3DSurface9_Vtbl; + +/***************************************************************************** + * IDirect3DSurface9 implementation structure + */ +struct IDirect3DSurface9Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DSurface9); + DWORD ref; + + /* IDirect3DResource9 fields */ + IDirect3DDevice9Impl *Device; + D3DRESOURCETYPE ResourceType; + + /* IDirect3DSurface9 fields */ + IUnknown *Container; + D3DSURFACE_DESC myDesc; + BYTE *allocatedMemory; + UINT textureName; + UINT bytesPerPixel; + + BOOL lockable; + BOOL locked; + RECT lockedRect; + RECT dirtyRect; + BOOL Dirty; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DSurface9Impl_QueryInterface(LPDIRECT3DSURFACE9 iface, REFIID refiid, LPVOID* obj); +extern ULONG WINAPI IDirect3DSurface9Impl_AddRef(LPDIRECT3DSURFACE9 iface); +extern ULONG WINAPI IDirect3DSurface9Impl_Release(LPDIRECT3DSURFACE9 iface); + +/* IDirect3DSurface9: (Inherited from IDirect3DResource9) */ +extern HRESULT WINAPI IDirect3DSurface9Impl_GetDevice(LPDIRECT3DSURFACE9 iface, IDirect3DDevice9** ppDevice); +extern HRESULT WINAPI IDirect3DSurface9Impl_SetPrivateData(LPDIRECT3DSURFACE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DSurface9Impl_GetPrivateData(LPDIRECT3DSURFACE9 iface, REFGUID refguid, void* pData,DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DSurface9Impl_FreePrivateData(LPDIRECT3DSURFACE9 iface, REFGUID refguid); +extern DWORD WINAPI IDirect3DSurface9Impl_SetPriority(LPDIRECT3DSURFACE9 iface, DWORD PriorityNew); +extern DWORD WINAPI IDirect3DSurface9Impl_GetPriority(LPDIRECT3DSURFACE9 iface); +extern void WINAPI IDirect3DSurface9Impl_PreLoad(LPDIRECT3DSURFACE9 iface); +extern D3DRESOURCETYPE WINAPI IDirect3DSurface9Impl_GetType(LPDIRECT3DSURFACE9 iface); + +/* IDirect3DSurface9: */ +extern HRESULT WINAPI IDirect3DSurface9Impl_GetContainer(LPDIRECT3DSURFACE9 iface, REFIID riid, void** ppContainer); +extern HRESULT WINAPI IDirect3DSurface9Impl_GetDesc(LPDIRECT3DSURFACE9 iface, D3DSURFACE_DESC *pDesc); +extern HRESULT WINAPI IDirect3DSurface9Impl_LockRect(LPDIRECT3DSURFACE9 iface, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags); +extern HRESULT WINAPI IDirect3DSurface9Impl_UnlockRect(LPDIRECT3DSURFACE9 iface); +extern HRESULT WINAPI IDirect3DSurface9Impl_GetDC(LPDIRECT3DSURFACE9 iface, HDC* phdc); +extern HRESULT WINAPI IDirect3DSurface9Impl_ReleaseDC(LPDIRECT3DSURFACE9 iface, HDC hdc); + + +/* ---------------------- */ +/* IDirect3DVertexBuffer9 */ +/* ---------------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DVertexBuffer9) Direct3DVertexBuffer9_Vtbl; + +/***************************************************************************** + * IDirect3DVertexBuffer9 implementation structure + */ +struct IDirect3DVertexBuffer9Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DVertexBuffer9); + DWORD ref; + + /* IDirect3DResource9 fields */ + IDirect3DDevice9Impl *Device; + D3DRESOURCETYPE ResourceType; + + /* IDirect3DVertexBuffer9 fields */ + BYTE *allocatedMemory; + D3DVERTEXBUFFER_DESC myDesc; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DVertexBuffer9Impl_QueryInterface(LPDIRECT3DVERTEXBUFFER9 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DVertexBuffer9Impl_AddRef(LPDIRECT3DVERTEXBUFFER9 iface); +extern ULONG WINAPI IDirect3DVertexBuffer9Impl_Release(LPDIRECT3DVERTEXBUFFER9 iface); + +/* IDirect3DVertexBuffer9: (Inherited from IDirect3DResource9) */ +extern HRESULT WINAPI IDirect3DVertexBuffer9Impl_GetDevice(LPDIRECT3DVERTEXBUFFER9 iface, IDirect3DDevice9** ppDevice); +extern HRESULT WINAPI IDirect3DVertexBuffer9Impl_SetPrivateData(LPDIRECT3DVERTEXBUFFER9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DVertexBuffer9Impl_GetPrivateData(LPDIRECT3DVERTEXBUFFER9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DVertexBuffer9Impl_FreePrivateData(LPDIRECT3DVERTEXBUFFER9 iface, REFGUID refguid); +extern DWORD WINAPI IDirect3DVertexBuffer9Impl_SetPriority(LPDIRECT3DVERTEXBUFFER9 iface, DWORD PriorityNew); +extern DWORD WINAPI IDirect3DVertexBuffer9Impl_GetPriority(LPDIRECT3DVERTEXBUFFER9 iface); +extern void WINAPI IDirect3DVertexBuffer9Impl_PreLoad(LPDIRECT3DVERTEXBUFFER9 iface); +extern D3DRESOURCETYPE WINAPI IDirect3DVertexBuffer9Impl_GetType(LPDIRECT3DVERTEXBUFFER9 iface); + +/* IDirect3DVertexBuffer9: */ +extern HRESULT WINAPI IDirect3DVertexBuffer9Impl_Lock(LPDIRECT3DVERTEXBUFFER9 iface, UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags); +extern HRESULT WINAPI IDirect3DVertexBuffer9Impl_Unlock(LPDIRECT3DVERTEXBUFFER9 iface); +extern HRESULT WINAPI IDirect3DVertexBuffer9Impl_GetDesc(LPDIRECT3DVERTEXBUFFER9 iface, D3DVERTEXBUFFER_DESC *pDesc); + + +/* --------------------- */ +/* IDirect3DIndexBuffer9 */ +/* --------------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DIndexBuffer9) Direct3DIndexBuffer9_Vtbl; + +/***************************************************************************** + * IDirect3DIndexBuffer9 implementation structure + */ +struct IDirect3DIndexBuffer9Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DIndexBuffer9); + DWORD ref; + + /* IDirect3DResource9 fields */ + IDirect3DDevice9Impl *Device; + D3DRESOURCETYPE ResourceType; + + /* IDirect3DIndexBuffer9 fields */ + void *allocatedMemory; + D3DINDEXBUFFER_DESC myDesc; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DIndexBuffer9Impl_QueryInterface(LPDIRECT3DINDEXBUFFER9 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DIndexBuffer9Impl_AddRef(LPDIRECT3DINDEXBUFFER9 iface); +extern ULONG WINAPI IDirect3DIndexBuffer9Impl_Release(LPDIRECT3DINDEXBUFFER9 iface); + +/* IDirect3DIndexBuffer9: (Inherited from IDirect3DResource9) */ +extern HRESULT WINAPI IDirect3DIndexBuffer9Impl_GetDevice(LPDIRECT3DINDEXBUFFER9 iface, IDirect3DDevice9** ppDevice); +extern HRESULT WINAPI IDirect3DIndexBuffer9Impl_SetPrivateData(LPDIRECT3DINDEXBUFFER9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DIndexBuffer9Impl_GetPrivateData(LPDIRECT3DINDEXBUFFER9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DIndexBuffer9Impl_FreePrivateData(LPDIRECT3DINDEXBUFFER9 iface, REFGUID refguid); +extern DWORD WINAPI IDirect3DIndexBuffer9Impl_SetPriority(LPDIRECT3DINDEXBUFFER9 iface, DWORD PriorityNew); +extern DWORD WINAPI IDirect3DIndexBuffer9Impl_GetPriority(LPDIRECT3DINDEXBUFFER9 iface); +extern void WINAPI IDirect3DIndexBuffer9Impl_PreLoad(LPDIRECT3DINDEXBUFFER9 iface); +extern D3DRESOURCETYPE WINAPI IDirect3DIndexBuffer9Impl_GetType(LPDIRECT3DINDEXBUFFER9 iface); + +/* IDirect3DIndexBuffer9: */ +extern HRESULT WINAPI IDirect3DIndexBuffer9Impl_Lock(LPDIRECT3DINDEXBUFFER9 iface, UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags); +extern HRESULT WINAPI IDirect3DIndexBuffer9Impl_Unlock(LPDIRECT3DINDEXBUFFER9 iface); +extern HRESULT WINAPI IDirect3DIndexBuffer9Impl_GetDesc(LPDIRECT3DINDEXBUFFER9 iface, D3DINDEXBUFFER_DESC *pDesc); + + +/* --------------------- */ +/* IDirect3DBaseTexture9 */ +/* --------------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DBaseTexture9) Direct3DBaseTexture9_Vtbl; + +/***************************************************************************** + * IDirect3DBaseTexture9 implementation structure + */ +struct IDirect3DBaseTexture9Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DBaseTexture9); + DWORD ref; + + /* IDirect3DResource9 fields */ + IDirect3DDevice9Impl *Device; + D3DRESOURCETYPE ResourceType; + + /* IDirect3DBaseTexture9 fields */ + BOOL Dirty; + D3DFORMAT format; + UINT levels; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DBaseTexture9Impl_QueryInterface(LPDIRECT3DBASETEXTURE9 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DBaseTexture9Impl_AddRef(LPDIRECT3DBASETEXTURE9 iface); +extern ULONG WINAPI IDirect3DBaseTexture9Impl_Release(LPDIRECT3DBASETEXTURE9 iface); + +/* IDirect3DBaseTexture9: (Inherited from IDirect3DResource9) */ +extern HRESULT WINAPI IDirect3DBaseTexture9Impl_GetDevice(LPDIRECT3DBASETEXTURE9 iface, IDirect3DDevice9** ppDevice); +extern HRESULT WINAPI IDirect3DBaseTexture9Impl_SetPrivateData(LPDIRECT3DBASETEXTURE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DBaseTexture9Impl_GetPrivateData(LPDIRECT3DBASETEXTURE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DBaseTexture9Impl_FreePrivateData(LPDIRECT3DBASETEXTURE9 iface, REFGUID refguid); +extern DWORD WINAPI IDirect3DBaseTexture9Impl_SetPriority(LPDIRECT3DBASETEXTURE9 iface, DWORD PriorityNew); +extern DWORD WINAPI IDirect3DBaseTexture9Impl_GetPriority(LPDIRECT3DBASETEXTURE9 iface); +extern void WINAPI IDirect3DBaseTexture9Impl_PreLoad(LPDIRECT3DBASETEXTURE9 iface); +extern D3DRESOURCETYPE WINAPI IDirect3DBaseTexture9Impl_GetType(LPDIRECT3DBASETEXTURE9 iface); + +/* IDirect3DBaseTexture9: */ +extern DWORD WINAPI IDirect3DBaseTexture9Impl_SetLOD(LPDIRECT3DBASETEXTURE9 iface, DWORD LODNew); +extern DWORD WINAPI IDirect3DBaseTexture9Impl_GetLOD(LPDIRECT3DBASETEXTURE9 iface); +extern DWORD WINAPI IDirect3DBaseTexture9Impl_GetLevelCount(LPDIRECT3DBASETEXTURE9 iface); +extern HRESULT WINAPI IDirect3DBaseTexture9Impl_SetAutoGenFilterType(LPDIRECT3DBASETEXTURE9 iface, D3DTEXTUREFILTERTYPE FilterType); +extern D3DTEXTUREFILTERTYPE WINAPI IDirect3DBaseTexture9Impl_GetAutoGenFilterType(LPDIRECT3DBASETEXTURE9 iface); +extern void WINAPI IDirect3DBaseTexture9Impl_GenerateMipSubLevels(LPDIRECT3DBASETEXTURE9 iface); + + +/* --------------------- */ +/* IDirect3DCubeTexture9 */ +/* --------------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DCubeTexture9) Direct3DCubeTexture9_Vtbl; + +/***************************************************************************** + * IDirect3DCubeTexture9 implementation structure + */ +struct IDirect3DCubeTexture9Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DCubeTexture9); + DWORD ref; + + /* IDirect3DResource9 fields */ + IDirect3DDevice9Impl *Device; + D3DRESOURCETYPE ResourceType; + + /* IDirect3DBaseTexture9 fields */ + BOOL Dirty; + D3DFORMAT format; + UINT levels; + + /* IDirect3DCubeTexture9 fields */ + UINT edgeLength; + DWORD usage; + IDirect3DSurface9Impl *surfaces[6][MAX_LEVELS]; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DCubeTexture9Impl_QueryInterface(LPDIRECT3DCUBETEXTURE9 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DCubeTexture9Impl_AddRef(LPDIRECT3DCUBETEXTURE9 iface); +extern ULONG WINAPI IDirect3DCubeTexture9Impl_Release(LPDIRECT3DCUBETEXTURE9 iface); + +/* IDirect3DCubeTexture9: (Inherited from IDirect3DResource9) */ +extern HRESULT WINAPI IDirect3DCubeTexture9Impl_GetDevice(LPDIRECT3DCUBETEXTURE9 iface, IDirect3DDevice9** ppDevice); +extern HRESULT WINAPI IDirect3DCubeTexture9Impl_SetPrivateData(LPDIRECT3DCUBETEXTURE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DCubeTexture9Impl_GetPrivateData(LPDIRECT3DCUBETEXTURE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DCubeTexture9Impl_FreePrivateData(LPDIRECT3DCUBETEXTURE9 iface, REFGUID refguid); +extern DWORD WINAPI IDirect3DCubeTexture9Impl_SetPriority(LPDIRECT3DCUBETEXTURE9 iface, DWORD PriorityNew); +extern DWORD WINAPI IDirect3DCubeTexture9Impl_GetPriority(LPDIRECT3DCUBETEXTURE9 iface); +extern void WINAPI IDirect3DCubeTexture9Impl_PreLoad(LPDIRECT3DCUBETEXTURE9 iface); +extern D3DRESOURCETYPE WINAPI IDirect3DCubeTexture9Impl_GetType(LPDIRECT3DCUBETEXTURE9 iface); + +/* IDirect3DCubeTexture9: (Inherited from IDirect3DBaseTexture9) */ +extern DWORD WINAPI IDirect3DCubeTexture9Impl_SetLOD(LPDIRECT3DCUBETEXTURE9 iface, DWORD LODNew); +extern DWORD WINAPI IDirect3DCubeTexture9Impl_GetLOD(LPDIRECT3DCUBETEXTURE9 iface); +extern DWORD WINAPI IDirect3DCubeTexture9Impl_GetLevelCount(LPDIRECT3DCUBETEXTURE9 iface); +extern HRESULT WINAPI IDirect3DCubeTexture9Impl_SetAutoGenFilterType(LPDIRECT3DCUBETEXTURE9 iface, D3DTEXTUREFILTERTYPE FilterType); +extern D3DTEXTUREFILTERTYPE WINAPI IDirect3DCubeTexture9Impl_GetAutoGenFilterType(LPDIRECT3DCUBETEXTURE9 iface); +extern void WINAPI IDirect3DCubeTexture9Impl_GenerateMipSubLevels(LPDIRECT3DCUBETEXTURE9 iface); + +/* IDirect3DCubeTexture9 */ +extern HRESULT WINAPI IDirect3DCubeTexture9Impl_GetLevelDesc(LPDIRECT3DCUBETEXTURE9 iface, UINT Level, D3DSURFACE_DESC* pDesc); +extern HRESULT WINAPI IDirect3DCubeTexture9Impl_GetCubeMapSurface(LPDIRECT3DCUBETEXTURE9 iface, D3DCUBEMAP_FACES FaceType, UINT Level, IDirect3DSurface9** ppCubeMapSurface); +extern HRESULT WINAPI IDirect3DCubeTexture9Impl_LockRect(LPDIRECT3DCUBETEXTURE9 iface, D3DCUBEMAP_FACES FaceType, UINT Level, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags); +extern HRESULT WINAPI IDirect3DCubeTexture9Impl_UnlockRect(LPDIRECT3DCUBETEXTURE9 iface, D3DCUBEMAP_FACES FaceType, UINT Level); +extern HRESULT WINAPI IDirect3DCubeTexture9Impl_AddDirtyRect(LPDIRECT3DCUBETEXTURE9 iface, D3DCUBEMAP_FACES FaceType, CONST RECT* pDirtyRect); + + +/* ----------------- */ +/* IDirect3DTexture9 */ +/* ----------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DTexture9) Direct3DTexture9_Vtbl; + +/***************************************************************************** + * IDirect3DTexture9 implementation structure + */ +struct IDirect3DTexture9Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DTexture9); + DWORD ref; + + /* IDirect3DResource9 fields */ + IDirect3DDevice9Impl *Device; + D3DRESOURCETYPE ResourceType; + + /* IDirect3DBaseTexture9 fields */ + BOOL Dirty; + D3DFORMAT format; + UINT levels; + + /* IDirect3DTexture9 fields */ + UINT width; + UINT height; + DWORD usage; + IDirect3DSurface9Impl *surfaces[MAX_LEVELS]; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DTexture9Impl_QueryInterface(LPDIRECT3DTEXTURE9 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DTexture9Impl_AddRef(LPDIRECT3DTEXTURE9 iface); +extern ULONG WINAPI IDirect3DTexture9Impl_Release(LPDIRECT3DTEXTURE9 iface); + +/* IDirect3DTexture9: (Inherited from IDirect3DResource9) */ +extern HRESULT WINAPI IDirect3DTexture9Impl_GetDevice(LPDIRECT3DTEXTURE9 iface, IDirect3DDevice9** ppDevice); +extern HRESULT WINAPI IDirect3DTexture9Impl_SetPrivateData(LPDIRECT3DTEXTURE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DTexture9Impl_GetPrivateData(LPDIRECT3DTEXTURE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DTexture9Impl_FreePrivateData(LPDIRECT3DTEXTURE9 iface, REFGUID refguid); +extern DWORD WINAPI IDirect3DTexture9Impl_SetPriority(LPDIRECT3DTEXTURE9 iface, DWORD PriorityNew); +extern DWORD WINAPI IDirect3DTexture9Impl_GetPriority(LPDIRECT3DTEXTURE9 iface); +extern void WINAPI IDirect3DTexture9Impl_PreLoad(LPDIRECT3DTEXTURE9 iface); +extern D3DRESOURCETYPE WINAPI IDirect3DTexture9Impl_GetType(LPDIRECT3DTEXTURE9 iface); + +/* IDirect3DTexture9: (Inherited from IDirect3DBaseTexture9) */ +extern DWORD WINAPI IDirect3DTexture9Impl_SetLOD(LPDIRECT3DTEXTURE9 iface, DWORD LODNew); +extern DWORD WINAPI IDirect3DTexture9Impl_GetLOD(LPDIRECT3DTEXTURE9 iface); +extern DWORD WINAPI IDirect3DTexture9Impl_GetLevelCount(LPDIRECT3DTEXTURE9 iface); +extern HRESULT WINAPI IDirect3DTexture9Impl_SetAutoGenFilterType(LPDIRECT3DTEXTURE9 iface, D3DTEXTUREFILTERTYPE FilterType); +extern D3DTEXTUREFILTERTYPE WINAPI IDirect3DTexture9Impl_GetAutoGenFilterType(LPDIRECT3DTEXTURE9 iface); +extern void WINAPI IDirect3DTexture9Impl_GenerateMipSubLevels(LPDIRECT3DTEXTURE9 iface); + +/* IDirect3DTexture9: */ +extern HRESULT WINAPI IDirect3DTexture9Impl_GetLevelDesc(LPDIRECT3DTEXTURE9 iface, UINT Level, D3DSURFACE_DESC* pDesc); +extern HRESULT WINAPI IDirect3DTexture9Impl_GetSurfaceLevel(LPDIRECT3DTEXTURE9 iface, UINT Level, IDirect3DSurface9** ppSurfaceLevel); +extern HRESULT WINAPI IDirect3DTexture9Impl_LockRect(LPDIRECT3DTEXTURE9 iface, UINT Level, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags); +extern HRESULT WINAPI IDirect3DTexture9Impl_UnlockRect(LPDIRECT3DTEXTURE9 iface, UINT Level); +extern HRESULT WINAPI IDirect3DTexture9Impl_AddDirtyRect(LPDIRECT3DTEXTURE9 iface, CONST RECT* pDirtyRect); + + +/* ----------------------- */ +/* IDirect3DVolumeTexture9 */ +/* ----------------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DVolumeTexture9) Direct3DVolumeTexture9_Vtbl; + +/***************************************************************************** + * IDirect3DVolumeTexture9 implementation structure + */ +struct IDirect3DVolumeTexture9Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DVolumeTexture9); + DWORD ref; + + /* IDirect3DResource9 fields */ + IDirect3DDevice9Impl *Device; + D3DRESOURCETYPE ResourceType; + + /* IDirect3DBaseTexture9 fields */ + BOOL Dirty; + D3DFORMAT format; + UINT levels; + + /* IDirect3DVolumeTexture9 fields */ + UINT width; + UINT height; + UINT depth; + DWORD usage; + IDirect3DVolume9Impl *volumes[MAX_LEVELS]; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DVolumeTexture9Impl_QueryInterface(LPDIRECT3DVOLUMETEXTURE9 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DVolumeTexture9Impl_AddRef(LPDIRECT3DVOLUMETEXTURE9 iface); +extern ULONG WINAPI IDirect3DVolumeTexture9Impl_Release(LPDIRECT3DVOLUMETEXTURE9 iface); + +/* IDirect3DVolumeTexture9: (Inherited from IDirect3DResource9) */ +extern HRESULT WINAPI IDirect3DVolumeTexture9Impl_GetDevice(LPDIRECT3DVOLUMETEXTURE9 iface, IDirect3DDevice9** ppDevice); +extern HRESULT WINAPI IDirect3DVolumeTexture9Impl_SetPrivateData(LPDIRECT3DVOLUMETEXTURE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DVolumeTexture9Impl_GetPrivateData(LPDIRECT3DVOLUMETEXTURE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DVolumeTexture9Impl_FreePrivateData(LPDIRECT3DVOLUMETEXTURE9 iface, REFGUID refguid); +extern DWORD WINAPI IDirect3DVolumeTexture9Impl_SetPriority(LPDIRECT3DVOLUMETEXTURE9 iface, DWORD PriorityNew); +extern DWORD WINAPI IDirect3DVolumeTexture9Impl_GetPriority(LPDIRECT3DVOLUMETEXTURE9 iface); +extern void WINAPI IDirect3DVolumeTexture9Impl_PreLoad(LPDIRECT3DVOLUMETEXTURE9 iface); +extern D3DRESOURCETYPE WINAPI IDirect3DVolumeTexture9Impl_GetType(LPDIRECT3DVOLUMETEXTURE9 iface); + +/* IDirect3DVolumeTexture9: (Inherited from IDirect3DBaseTexture9) */ +extern DWORD WINAPI IDirect3DVolumeTexture9Impl_SetLOD(LPDIRECT3DVOLUMETEXTURE9 iface, DWORD LODNew); +extern DWORD WINAPI IDirect3DVolumeTexture9Impl_GetLOD(LPDIRECT3DVOLUMETEXTURE9 iface); +extern DWORD WINAPI IDirect3DVolumeTexture9Impl_GetLevelCount(LPDIRECT3DVOLUMETEXTURE9 iface); +extern HRESULT WINAPI IDirect3DVolumeTexture9Impl_SetAutoGenFilterType(LPDIRECT3DVOLUMETEXTURE9 iface, D3DTEXTUREFILTERTYPE FilterType); +extern D3DTEXTUREFILTERTYPE WINAPI IDirect3DVolumeTexture9Impl_GetAutoGenFilterType(LPDIRECT3DVOLUMETEXTURE9 iface); +extern void WINAPI IDirect3DVolumeTexture9Impl_GenerateMipSubLevels(LPDIRECT3DVOLUMETEXTURE9 iface); + +/* IDirect3DVolumeTexture9: */ +extern HRESULT WINAPI IDirect3DVolumeTexture9Impl_GetLevelDesc(LPDIRECT3DVOLUMETEXTURE9 iface, UINT Level, D3DVOLUME_DESC *pDesc); +extern HRESULT WINAPI IDirect3DVolumeTexture9Impl_GetVolumeLevel(LPDIRECT3DVOLUMETEXTURE9 iface, UINT Level, IDirect3DVolume9** ppVolumeLevel); +extern HRESULT WINAPI IDirect3DVolumeTexture9Impl_LockBox(LPDIRECT3DVOLUMETEXTURE9 iface, UINT Level, D3DLOCKED_BOX* pLockedVolume, CONST D3DBOX* pBox, DWORD Flags); +extern HRESULT WINAPI IDirect3DVolumeTexture9Impl_UnlockBox(LPDIRECT3DVOLUMETEXTURE9 iface, UINT Level); +extern HRESULT WINAPI IDirect3DVolumeTexture9Impl_AddDirtyBox(LPDIRECT3DVOLUMETEXTURE9 iface, CONST D3DBOX* pDirtyBox); + + +/* ----------------------- */ +/* IDirect3DStateBlock9 */ +/* ----------------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DStateBlock9) Direct3DStateBlock9_Vtbl; + +/***************************************************************************** + * IDirect3DStateBlock9 implementation structure + */ +struct IDirect3DStateBlock9Impl { + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DStateBlock9); + DWORD ref; + + /* IDirect3DStateBlock9 fields */ + IDirect3DDevice9Impl* Device; + + D3DSTATEBLOCKTYPE blockType; + + SAVEDSTATES Changed; + SAVEDSTATES Set; + + /* Light Enable */ + BOOL lightEnable[MAX_ACTIVE_LIGHTS]; + + /* ClipPlane */ + double clipplane[MAX_CLIPPLANES][4]; + + /* Stream Source */ + UINT stream_stride[MAX_STREAMS]; + IDirect3DVertexBuffer9* stream_source[MAX_STREAMS]; + BOOL streamIsUP; + + /* Indices */ + IDirect3DIndexBuffer9* pIndexData; + UINT baseVertexIndex; + + /* Texture */ + IDirect3DBaseTexture9* textures[8]; + int textureDimensions[8]; + /* Texture State Stage */ + DWORD texture_state[8][HIGHEST_TEXTURE_STATE]; + + /* RenderState */ + DWORD renderstate[HIGHEST_RENDER_STATE]; + + /* Transform */ + D3DMATRIX transforms[HIGHEST_TRANSFORMSTATE]; + + + /* ViewPort */ + D3DVIEWPORT9 viewport; + + /* Lights */ + D3DLIGHT9 lights[MAX_ACTIVE_LIGHTS]; + + /* Material */ + D3DMATERIAL9 material; + + DWORD FVF; + + /* Vertex Shader */ + IDirect3DVertexShader9* VertexShader; + + /* Vertex Shader Declaration */ + IDirect3DVertexDeclaration9Impl* vertexDecl; + + /* Pixel Shader */ + IDirect3DPixelShader9* PixelShader; + + /* Indexed Vertex Blending */ + D3DVERTEXBLENDFLAGS vertex_blend; + FLOAT tween_factor; + + /* Vertex Shader Constant */ + D3DSHADERVECTORF vertexShaderConstantF[D3D_VSHADER_MAX_CONSTANTS]; + D3DSHADERVECTORI vertexShaderConstantI[D3D_VSHADER_MAX_CONSTANTS]; + BOOL vertexShaderConstantB[D3D_VSHADER_MAX_CONSTANTS]; + /* Pixel Shader Constant */ + D3DSHADERVECTORF pixelShaderConstantF[D3D_PSHADER_MAX_CONSTANTS]; + D3DSHADERVECTORI pixelShaderConstantI[D3D_PSHADER_MAX_CONSTANTS]; + BOOL pixelShaderConstantB[D3D_PSHADER_MAX_CONSTANTS]; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DStateBlock9Impl_QueryInterface(LPDIRECT3DSTATEBLOCK9 iface, REFIID refiid, LPVOID* obj); +extern ULONG WINAPI IDirect3DStateBlock9Impl_AddRef(LPDIRECT3DSTATEBLOCK9 iface); +extern ULONG WINAPI IDirect3DStateBlock9Impl_Release(LPDIRECT3DSTATEBLOCK9 iface); + +/* IDirect3DStateBlock9: */ +extern HRESULT WINAPI IDirect3DStateBlock9Impl_GetDevice(LPDIRECT3DSTATEBLOCK9 iface, IDirect3DDevice9** ppDevice); +extern HRESULT WINAPI IDirect3DStateBlock9Impl_Capture(LPDIRECT3DSTATEBLOCK9 iface); +extern HRESULT WINAPI IDirect3DStateBlock9Impl_Apply(LPDIRECT3DSTATEBLOCK9 iface); + + +/* --------------------------- */ +/* IDirect3DVertexDeclaration9 */ +/* --------------------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DVertexDeclaration9) Direct3DVertexDeclaration9_Vtbl; + +/***************************************************************************** + * IDirect3DVertexShaderDeclaration implementation structure + */ +struct IDirect3DVertexDeclaration9Impl { + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DVertexDeclaration9); + DWORD ref; + + /* IDirect3DVertexDeclaration9 fields */ + IDirect3DDevice9Impl* Device; + + /** precomputed fvf if simple declaration */ + DWORD fvf[MAX_STREAMS]; + DWORD allFVF; + + /** dx8 compatible Declaration fields */ + DWORD* pDeclaration8; + DWORD declaration8Length; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DVertexDeclaration9Impl_QueryInterface(LPDIRECT3DVERTEXDECLARATION9 iface, REFIID refiid, LPVOID* obj); +extern ULONG WINAPI IDirect3DVertexDeclaration9Impl_AddRef(LPDIRECT3DVERTEXDECLARATION9 iface); +extern ULONG WINAPI IDirect3DVertexDeclaration9Impl_Release(LPDIRECT3DVERTEXDECLARATION9 iface); + +/* IDirect3DVertexDeclaration9: */ +extern HRESULT WINAPI IDirect3DVertexDeclaration9Impl_GetDevice(LPDIRECT3DVERTEXDECLARATION9 iface, IDirect3DDevice9** ppDevice); +extern HRESULT WINAPI IDirect3DVertexDeclaration9Impl_GetDeclaration(LPDIRECT3DVERTEXDECLARATION9 iface, D3DVERTEXELEMENT9* pDecl, UINT* pNumElements); + + +/* ---------------------- */ +/* IDirect3DVertexShader9 */ +/* ---------------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DVertexShader9) Direct3DVertexShader9_Vtbl; + +/***************************************************************************** + * IDirect3DVertexShader implementation structure + */ +struct IDirect3DVertexShader9Impl { + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DVertexShader9); + DWORD ref; + + /* IDirect3DVertexDeclaration9 fields */ + IDirect3DDevice9Impl* Device; + + DWORD* function; + UINT functionLength; + DWORD usage; /* 0 || D3DUSAGE_SOFTWAREPROCESSING */ + DWORD version; + /* run time datas */ + /* + VSHADERDATA* data; + VSHADERINPUTDATA input; + VSHADEROUTPUTDATA output; + */ +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DVertexShader9Impl_QueryInterface(LPDIRECT3DVERTEXSHADER9 iface, REFIID refiid, LPVOID* obj); +extern ULONG WINAPI IDirect3DVertexShader9Impl_AddRef(LPDIRECT3DVERTEXSHADER9 iface); +extern ULONG WINAPI IDirect3DVertexShader9Impl_Release(LPDIRECT3DVERTEXSHADER9 iface); + +/* IDirect3DVertexShader9: */ +extern HRESULT WINAPI IDirect3DVertexShader9Impl_GetDevice(LPDIRECT3DVERTEXSHADER9 iface, IDirect3DDevice9** ppDevice); +extern HRESULT WINAPI IDirect3DVertexShader9Impl_GetFunction(LPDIRECT3DVERTEXSHADER9 iface, VOID* pData, UINT* pSizeOfData); + + +/* --------------------- */ +/* IDirect3DPixelShader9 */ +/* --------------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DPixelShader9) Direct3DPixelShader9_Vtbl; + +/***************************************************************************** + * IDirect3DPixelShader implementation structure + */ +struct IDirect3DPixelShader9Impl { + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DPixelShader9); + DWORD ref; + + /* IDirect3DPixelShader9 fields */ + IDirect3DDevice9Impl* Device; + + DWORD* function; + UINT functionLength; + DWORD version; + /* run time datas */ + /* + PSHADERDATA* data; + PSHADERINPUTDATA input; + PSHADEROUTPUTDATA output; + */ +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DPixelShader9Impl_QueryInterface(LPDIRECT3DPIXELSHADER9 iface, REFIID refiid, LPVOID* obj); +extern ULONG WINAPI IDirect3DPixelShader9Impl_AddRef(LPDIRECT3DPIXELSHADER9 iface); +extern ULONG WINAPI IDirect3DPixelShader9Impl_Release(LPDIRECT3DPIXELSHADER9 iface); + +/* IDirect3DPixelShader9: */ +extern HRESULT WINAPI IDirect3DPixelShader9Impl_GetDevice(LPDIRECT3DPIXELSHADER9 iface, IDirect3DDevice9** ppDevice); +extern HRESULT WINAPI IDirect3DPixelShader9Impl_GetFunction(LPDIRECT3DPIXELSHADER9 iface, VOID* pData, UINT* pSizeOfData); + + +/* --------------- */ +/* IDirect3DQuery9 */ +/* --------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DQuery9) Direct3DQuery9_Vtbl; + +/***************************************************************************** + * IDirect3DPixelShader implementation structure + */ +struct IDirect3DQuery9Impl { + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DQuery9); + DWORD ref; + + /* IDirect3DQuery9 fields */ + IDirect3DDevice9Impl* Device; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DQuery9Impl_QueryInterface(LPDIRECT3DQUERY9 iface, REFIID riid, LPVOID* ppobj); +extern ULONG WINAPI IDirect3DQuery9Impl_AddRef(LPDIRECT3DQUERY9 iface); +extern ULONG WINAPI IDirect3DQuery9Impl_Release(LPDIRECT3DQUERY9 iface); + +/* IDirect3DQuery9: */ +extern HRESULT WINAPI IDirect3DQuery9Impl_GetDevice(LPDIRECT3DQUERY9 iface, IDirect3DDevice9** ppDevice); +extern D3DQUERYTYPE WINAPI IDirect3DQuery9Impl_GetType(LPDIRECT3DQUERY9 iface); +extern DWORD WINAPI IDirect3DQuery9Impl_GetDataSize(LPDIRECT3DQUERY9 iface); +extern HRESULT WINAPI IDirect3DQuery9Impl_Issue(LPDIRECT3DQUERY9 iface, DWORD dwIssueFlags); +extern HRESULT WINAPI IDirect3DQuery9Impl_GetData(LPDIRECT3DQUERY9 iface, void* pData, DWORD dwSize, DWORD dwGetDataFlags); + + +#endif /* __WINE_D3D9_PRIVATE_H */ diff --git a/dlls/d3d9/device.c b/dlls/d3d9/device.c new file mode 100644 index 00000000000..03038433a56 --- /dev/null +++ b/dlls/d3d9/device.c @@ -0,0 +1,837 @@ +/* + * IDirect3DDevice9 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#include + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d9_private.h" + +/** currently desactiving 1_4 support as mesa doesn't implement all 1_4 support while defining it */ +#undef GL_VERSION_1_4 + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); +WINE_DECLARE_DEBUG_CHANNEL(d3d_shader); + + +/* IDirect3D IUnknown parts follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_QueryInterface(LPDIRECT3DDEVICE9 iface, REFIID riid, LPVOID* ppobj) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DDevice9)) { + IDirect3DDevice9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DDevice9Impl_AddRef(LPDIRECT3DDEVICE9 iface) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DDevice9Impl_Release(LPDIRECT3DDEVICE9 iface) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DDevice Interface follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_TestCooperativeLevel(LPDIRECT3DDEVICE9 iface) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : stub\n", This); /* No way of notifying yet! */ + return D3D_OK; +} + +UINT WINAPI IDirect3DDevice9Impl_GetAvailableTextureMem(LPDIRECT3DDEVICE9 iface) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : stub, emulating 32Mb for now\n", This); + /* + * pretend we have 32MB of any type of memory queried. + */ + return (1024*1024*32); +} + +HRESULT WINAPI IDirect3DDevice9Impl_EvictManagedRessources(LPDIRECT3DDEVICE9 iface) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetDirect3D(LPDIRECT3DDEVICE9 iface, IDirect3D9** ppD3D9) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : returning %p\n", This, This->direct3d); + /* Inc ref count */ + *ppD3D9 = (IDirect3D9*) This->direct3d; + IDirect3D9_AddRef(*ppD3D9); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetDeviceCaps(LPDIRECT3DDEVICE9 iface, D3DCAPS9* pCaps) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub, calling idirect3d for now\n", This); + IDirect3D9Impl_GetDeviceCaps((LPDIRECT3D9) This->direct3d, This->adapterNo, This->devType, pCaps); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetDisplayMode(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, D3DDISPLAYMODE* pMode) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetCreationParameters(LPDIRECT3DDEVICE9 iface, D3DDEVICE_CREATION_PARAMETERS *pParameters) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) copying to %p\n", This, pParameters); + memcpy(pParameters, &This->CreateParms, sizeof(D3DDEVICE_CREATION_PARAMETERS)); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetCursorProperties(LPDIRECT3DDEVICE9 iface, UINT XHotSpot, UINT YHotSpot, IDirect3DSurface9* pCursorBitmap) { + IDirect3DSurface9Impl* pSur = (IDirect3DSurface9Impl*) pCursorBitmap; + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : Spot Pos(%u,%u)\n", This, XHotSpot, YHotSpot); + + if (D3DFMT_A8R8G8B8 != pSur->myDesc.Format) { + ERR("(%p) : surface(%p) have a invalid format\n", This, pCursorBitmap); + return D3DERR_INVALIDCALL; + } + if (32 != pSur->myDesc.Height || 32 != pSur->myDesc.Width) { + ERR("(%p) : surface(%p) have a invalid size\n", This, pCursorBitmap); + return D3DERR_INVALIDCALL; + } + + This->xHotSpot = XHotSpot; + This->yHotSpot = YHotSpot; + return D3D_OK; +} + +void WINAPI IDirect3DDevice9Impl_SetCursorPosition(LPDIRECT3DDEVICE9 iface, int XScreenSpace, int YScreenSpace, DWORD Flags) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : SetPos to (%u,%u)\n", This, XScreenSpace, YScreenSpace); + This->xScreenSpace = XScreenSpace; + This->yScreenSpace = YScreenSpace; + return; +} + +BOOL WINAPI IDirect3DDevice9Impl_ShowCursor(LPDIRECT3DDEVICE9 iface, BOOL bShow) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : visible(%d)\n", This, bShow); + This->bCursorVisible = bShow; + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_Reset(LPDIRECT3DDEVICE9 iface, D3DPRESENT_PARAMETERS* pPresentationParameters) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_Present(LPDIRECT3DDEVICE9 iface, CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : stub!\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetBackBuffer(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, UINT BackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface9** ppBackBuffer) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + *ppBackBuffer = (LPDIRECT3DSURFACE9) This->backBuffer; + TRACE("(%p) : BackBuf %d Type %d returning %p\n", This, BackBuffer, Type, *ppBackBuffer); + if (BackBuffer > This->PresentParms.BackBufferCount - 1) { + FIXME("Only one backBuffer currently supported\n"); + return D3DERR_INVALIDCALL; + } + /* Note inc ref on returned surface */ + IDirect3DSurface9Impl_AddRef((LPDIRECT3DSURFACE9) *ppBackBuffer); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetRasterStatus(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, D3DRASTER_STATUS* pRasterStatus) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetDialogBoxMode(LPDIRECT3DDEVICE9 iface, BOOL bEnableDialogs) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +void WINAPI IDirect3DDevice9Impl_SetGammaRamp(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, DWORD Flags, CONST D3DGAMMARAMP* pRamp) { + HDC hDC; + ICOM_THIS(IDirect3DDevice9Impl,iface); + + FIXME("(%p) : pRamp@%p\n", This, pRamp); + hDC = GetDC(This->win_handle); + SetDeviceGammaRamp(hDC, (LPVOID) pRamp); + ReleaseDC(This->win_handle, hDC); + return; +} + +void WINAPI IDirect3DDevice9Impl_GetGammaRamp(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, D3DGAMMARAMP* pRamp) { + HDC hDC; + ICOM_THIS(IDirect3DDevice9Impl,iface); + + FIXME("(%p) : pRamp@%p\n", This, pRamp); + hDC = GetDC(This->win_handle); + GetDeviceGammaRamp(hDC, pRamp); + ReleaseDC(This->win_handle, hDC); + return; +} + +HRESULT WINAPI IDirect3DDevice9Impl_CreateRenderTarget(LPDIRECT3DDEVICE9 iface, UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality, BOOL Lockable, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_CreateDepthStencilSurface(LPDIRECT3DDEVICE9 iface, UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality, BOOL Discard, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_UpdateSurface(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pSourceSurface, CONST RECT* pSourceRect, IDirect3DSurface9* pDestinationSurface, CONST POINT* pDestPoint) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_UpdateTexture(LPDIRECT3DDEVICE9 iface, IDirect3DBaseTexture9* pSourceTexture, IDirect3DBaseTexture9* pDestinationTexture) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetFrontBuffer(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pDestSurface) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetRenderTargetData(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pRenderTarget, IDirect3DSurface9* pDestSurface) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetFrontBufferData(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, IDirect3DSurface9* pDestSurface) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_StretchRects(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pSourceSurface, CONST RECT* pSourceRect, IDirect3DSurface9* pDestSurface, CONST RECT* pDestRect, D3DTEXTUREFILTERTYPE Filter) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_ColorFill(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pSurface, CONST RECT* pRect, D3DCOLOR color) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_CreateOffscreenPlainSurface(LPDIRECT3DDEVICE9 iface, UINT Width, UINT Height, D3DFORMAT Format, D3DPOOL Pool, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetRenderTarget(LPDIRECT3DDEVICE9 iface, DWORD RenderTargetIndex, IDirect3DSurface9* pRenderTarget) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetRenderTarget(LPDIRECT3DDEVICE9 iface, DWORD RenderTargetIndex, IDirect3DSurface9** ppRenderTarget) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetDepthStencilSurface(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9* pZStencilSurface) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetDepthStencilSurface(LPDIRECT3DDEVICE9 iface, IDirect3DSurface9** ppZStencilSurface) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_BeginScene(LPDIRECT3DDEVICE9 iface) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_EndScene(LPDIRECT3DDEVICE9 iface) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_Clear(LPDIRECT3DDEVICE9 iface, DWORD Count, CONST D3DRECT* pRects, DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetTransform(LPDIRECT3DDEVICE9 iface, D3DTRANSFORMSTATETYPE d3dts, CONST D3DMATRIX* lpmatrix) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetTransform(LPDIRECT3DDEVICE9 iface, D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : for State %d\n", This, State); + memcpy(pMatrix, &This->StateBlock->transforms[State], sizeof(D3DMATRIX)); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_MultiplyTransform(LPDIRECT3DDEVICE9 iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix) { + D3DMATRIX *mat = NULL; + D3DMATRIX temp; + + /* Note: Using UpdateStateBlock means it would be recorded in a state block change, + but works regardless of recording being on. + If this is found to be wrong, change to StateBlock. */ + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : For state %u\n", This, State); + + if (State < HIGHEST_TRANSFORMSTATE) { + mat = &This->UpdateStateBlock->transforms[State]; + } else { + FIXME("Unhandled transform state!!\n"); + } + + /* Copied from ddraw code: */ + temp.u.s._11 = (mat->u.s._11 * pMatrix->u.s._11) + (mat->u.s._21 * pMatrix->u.s._12) + (mat->u.s._31 * pMatrix->u.s._13) + (mat->u.s._41 * pMatrix->u.s._14); + temp.u.s._21 = (mat->u.s._11 * pMatrix->u.s._21) + (mat->u.s._21 * pMatrix->u.s._22) + (mat->u.s._31 * pMatrix->u.s._23) + (mat->u.s._41 * pMatrix->u.s._24); + temp.u.s._31 = (mat->u.s._11 * pMatrix->u.s._31) + (mat->u.s._21 * pMatrix->u.s._32) + (mat->u.s._31 * pMatrix->u.s._33) + (mat->u.s._41 * pMatrix->u.s._34); + temp.u.s._41 = (mat->u.s._11 * pMatrix->u.s._41) + (mat->u.s._21 * pMatrix->u.s._42) + (mat->u.s._31 * pMatrix->u.s._43) + (mat->u.s._41 * pMatrix->u.s._44); + + temp.u.s._12 = (mat->u.s._12 * pMatrix->u.s._11) + (mat->u.s._22 * pMatrix->u.s._12) + (mat->u.s._32 * pMatrix->u.s._13) + (mat->u.s._42 * pMatrix->u.s._14); + temp.u.s._22 = (mat->u.s._12 * pMatrix->u.s._21) + (mat->u.s._22 * pMatrix->u.s._22) + (mat->u.s._32 * pMatrix->u.s._23) + (mat->u.s._42 * pMatrix->u.s._24); + temp.u.s._32 = (mat->u.s._12 * pMatrix->u.s._31) + (mat->u.s._22 * pMatrix->u.s._32) + (mat->u.s._32 * pMatrix->u.s._33) + (mat->u.s._42 * pMatrix->u.s._34); + temp.u.s._42 = (mat->u.s._12 * pMatrix->u.s._41) + (mat->u.s._22 * pMatrix->u.s._42) + (mat->u.s._32 * pMatrix->u.s._43) + (mat->u.s._42 * pMatrix->u.s._44); + + temp.u.s._13 = (mat->u.s._13 * pMatrix->u.s._11) + (mat->u.s._23 * pMatrix->u.s._12) + (mat->u.s._33 * pMatrix->u.s._13) + (mat->u.s._43 * pMatrix->u.s._14); + temp.u.s._23 = (mat->u.s._13 * pMatrix->u.s._21) + (mat->u.s._23 * pMatrix->u.s._22) + (mat->u.s._33 * pMatrix->u.s._23) + (mat->u.s._43 * pMatrix->u.s._24); + temp.u.s._33 = (mat->u.s._13 * pMatrix->u.s._31) + (mat->u.s._23 * pMatrix->u.s._32) + (mat->u.s._33 * pMatrix->u.s._33) + (mat->u.s._43 * pMatrix->u.s._34); + temp.u.s._43 = (mat->u.s._13 * pMatrix->u.s._41) + (mat->u.s._23 * pMatrix->u.s._42) + (mat->u.s._33 * pMatrix->u.s._43) + (mat->u.s._43 * pMatrix->u.s._44); + + temp.u.s._14 = (mat->u.s._14 * pMatrix->u.s._11) + (mat->u.s._24 * pMatrix->u.s._12) + (mat->u.s._34 * pMatrix->u.s._13) + (mat->u.s._44 * pMatrix->u.s._14); + temp.u.s._24 = (mat->u.s._14 * pMatrix->u.s._21) + (mat->u.s._24 * pMatrix->u.s._22) + (mat->u.s._34 * pMatrix->u.s._23) + (mat->u.s._44 * pMatrix->u.s._24); + temp.u.s._34 = (mat->u.s._14 * pMatrix->u.s._31) + (mat->u.s._24 * pMatrix->u.s._32) + (mat->u.s._34 * pMatrix->u.s._33) + (mat->u.s._44 * pMatrix->u.s._34); + temp.u.s._44 = (mat->u.s._14 * pMatrix->u.s._41) + (mat->u.s._24 * pMatrix->u.s._42) + (mat->u.s._34 * pMatrix->u.s._43) + (mat->u.s._44 * pMatrix->u.s._44); + + /* Apply change via set transform - will reapply to eg. lights this way */ + IDirect3DDevice9Impl_SetTransform(iface, State, &temp); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetViewport(LPDIRECT3DDEVICE9 iface, CONST D3DVIEWPORT9* pViewport) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetViewport(LPDIRECT3DDEVICE9 iface, D3DVIEWPORT9* pViewport) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p)\n", This); + memcpy(pViewport, &This->StateBlock->viewport, sizeof(D3DVIEWPORT9)); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetMaterial(LPDIRECT3DDEVICE9 iface, CONST D3DMATERIAL9* pMaterial) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetMaterial(LPDIRECT3DDEVICE9 iface, D3DMATERIAL9* pMaterial) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + memcpy(pMaterial, &This->UpdateStateBlock->material, sizeof (D3DMATERIAL9)); + TRACE("(%p) : Diffuse (%f,%f,%f,%f)\n", This, pMaterial->Diffuse.r, pMaterial->Diffuse.g, pMaterial->Diffuse.b, pMaterial->Diffuse.a); + TRACE("(%p) : Ambient (%f,%f,%f,%f)\n", This, pMaterial->Ambient.r, pMaterial->Ambient.g, pMaterial->Ambient.b, pMaterial->Ambient.a); + TRACE("(%p) : Specular (%f,%f,%f,%f)\n", This, pMaterial->Specular.r, pMaterial->Specular.g, pMaterial->Specular.b, pMaterial->Specular.a); + TRACE("(%p) : Emissive (%f,%f,%f,%f)\n", This, pMaterial->Emissive.r, pMaterial->Emissive.g, pMaterial->Emissive.b, pMaterial->Emissive.a); + TRACE("(%p) : Power (%f)\n", This, pMaterial->Power); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetLight(LPDIRECT3DDEVICE9 iface, DWORD Index, CONST D3DLIGHT9* pLight) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetLight(LPDIRECT3DDEVICE9 iface, DWORD Index,D3DLIGHT9* pLight) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_LightEnable(LPDIRECT3DDEVICE9 iface, DWORD Index, BOOL Enable) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetLightEnable(LPDIRECT3DDEVICE9 iface, DWORD Index, BOOL* pEnable) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetClipPlane(LPDIRECT3DDEVICE9 iface, DWORD Index, CONST float* pPlane) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetClipPlane(LPDIRECT3DDEVICE9 iface, DWORD Index, float* pPlane) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetRenderState(LPDIRECT3DDEVICE9 iface, D3DRENDERSTATETYPE State, DWORD Value) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetRenderState(LPDIRECT3DDEVICE9 iface, D3DRENDERSTATETYPE State, DWORD* pValue) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) for State %d = %ld\n", This, State, This->UpdateStateBlock->renderstate[State]); + *pValue = This->StateBlock->renderstate[State]; + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetClipStatus(LPDIRECT3DDEVICE9 iface, CONST D3DCLIPSTATUS9* pClipStatus) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetClipStatus(LPDIRECT3DDEVICE9 iface, D3DCLIPSTATUS9* pClipStatus) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetTexture(LPDIRECT3DDEVICE9 iface, DWORD Stage, IDirect3DBaseTexture9** ppTexture) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : returning %p for stage %ld\n", This, This->UpdateStateBlock->textures[Stage], Stage); + *ppTexture = (LPDIRECT3DBASETEXTURE9) This->UpdateStateBlock->textures[Stage]; + IDirect3DBaseTexture9Impl_AddRef(*ppTexture); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetTexture(LPDIRECT3DDEVICE9 iface, DWORD Stage, IDirect3DBaseTexture9* pTexture) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetTextureStageState(LPDIRECT3DDEVICE9 iface, DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD* pValue) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : requesting Stage %ld, Type %d getting %ld\n", This, Stage, Type, This->UpdateStateBlock->texture_state[Stage][Type]); + *pValue = This->UpdateStateBlock->texture_state[Stage][Type]; + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetTextureStageState(LPDIRECT3DDEVICE9 iface, DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetSamplerState(LPDIRECT3DDEVICE9 iface, DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD* pValue) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetSamplerState(LPDIRECT3DDEVICE9 iface, DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_ValidateDevice(LPDIRECT3DDEVICE9 iface, DWORD* pNumPasses) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetPaletteEntries(LPDIRECT3DDEVICE9 iface, UINT PaletteNumber, CONST PALETTEENTRY* pEntries) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : setting p[%u] <= RGBA(%02x,%02x,%02x,%02x)\n", This, PaletteNumber, pEntries->peRed, pEntries->peGreen, pEntries->peBlue, pEntries->peFlags); + memcpy(This->palettes[PaletteNumber], pEntries, 256 * sizeof(PALETTEENTRY)); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetPaletteEntries(LPDIRECT3DDEVICE9 iface, UINT PaletteNumber, PALETTEENTRY* pEntries) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + memcpy(pEntries, This->palettes[PaletteNumber], 256 * sizeof(PALETTEENTRY)); + FIXME("(%p) : returning p[%u] => RGBA(%02x,%02x,%02x,%02x)\n", This, PaletteNumber, pEntries->peRed, pEntries->peGreen, pEntries->peBlue, pEntries->peFlags); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetCurrentTexturePalette(LPDIRECT3DDEVICE9 iface, UINT PaletteNumber) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetCurrentTexturePalette(LPDIRECT3DDEVICE9 iface, UINT* PaletteNumber) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + *PaletteNumber = This->currentPalette; + FIXME("(%p) : Returning (%u)\n", This, *PaletteNumber); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetScissorRect(LPDIRECT3DDEVICE9 iface, CONST RECT* pRect) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetScissorRect(LPDIRECT3DDEVICE9 iface, RECT* pRect) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetSoftwareVertexProcessing(LPDIRECT3DDEVICE9 iface, BOOL bSoftware) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +BOOL WINAPI IDirect3DDevice9Impl_GetSoftwareVertexProcessing(LPDIRECT3DDEVICE9 iface) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetNPatchMode(LPDIRECT3DDEVICE9 iface, float nSegments) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +float WINAPI IDirect3DDevice9Impl_GetNPatchMode(LPDIRECT3DDEVICE9 iface) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return 0.0f; +} + +HRESULT WINAPI IDirect3DDevice9Impl_DrawPrimitive(LPDIRECT3DDEVICE9 iface, D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_DrawIndexedPrimitive(LPDIRECT3DDEVICE9 iface, D3DPRIMITIVETYPE PrimitiveType, + INT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_DrawPrimitiveUP(LPDIRECT3DDEVICE9 iface, D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_DrawIndexedPrimitiveUP(LPDIRECT3DDEVICE9 iface, D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex, + UINT NumVertexIndices, UINT PrimitiveCount, CONST void* pIndexData, + D3DFORMAT IndexDataFormat, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_ProcessVertices(LPDIRECT3DDEVICE9 iface, UINT SrcStartIndex, UINT DestIndex, UINT VertexCount, IDirect3DVertexBuffer9* pDestBuffer, IDirect3DVertexDeclaration9* pVertexDecl, DWORD Flags) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetFVF(LPDIRECT3DDEVICE9 iface, DWORD FVF) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetFVF(LPDIRECT3DDEVICE9 iface, DWORD* pFVF) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetStreamSource(LPDIRECT3DDEVICE9 iface, UINT StreamNumber, IDirect3DVertexBuffer9* pStreamData, UINT OffsetInBytes, UINT Stride) { + IDirect3DVertexBuffer9 *oldSrc; + ICOM_THIS(IDirect3DDevice9Impl,iface); + + oldSrc = This->StateBlock->stream_source[StreamNumber]; + TRACE("(%p) : StreamNo: %d, OldStream (%p), NewStream (%p), NewStride %d\n", This, StreamNumber, oldSrc, pStreamData, Stride); + + This->UpdateStateBlock->Changed.stream_source[StreamNumber] = TRUE; + This->UpdateStateBlock->Set.stream_source[StreamNumber] = TRUE; + This->UpdateStateBlock->stream_stride[StreamNumber] = Stride; + This->UpdateStateBlock->stream_source[StreamNumber] = pStreamData; + + /* Handle recording of state blocks */ + if (This->isRecordingState) { + TRACE("Recording... not performing anything\n"); + return D3D_OK; + } + + if (oldSrc != NULL) IDirect3DVertexBuffer9Impl_Release(oldSrc); + if (pStreamData != NULL) IDirect3DVertexBuffer9Impl_AddRef(pStreamData); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetStreamSource(LPDIRECT3DDEVICE9 iface, UINT StreamNumber, IDirect3DVertexBuffer9** pStream, UINT* OffsetInBytes, UINT* pStride) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : StreamNo: %d, Stream (%p), Stride %d\n", This, StreamNumber, This->StateBlock->stream_source[StreamNumber], This->StateBlock->stream_stride[StreamNumber]); + *pStream = This->StateBlock->stream_source[StreamNumber]; + *pStride = This->StateBlock->stream_stride[StreamNumber]; + IDirect3DVertexBuffer9Impl_AddRef((LPDIRECT3DVERTEXBUFFER9) *pStream); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetStreamSourceFreq(LPDIRECT3DDEVICE9 iface, UINT StreamNumber, UINT Divider) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetStreamSourceFreq(LPDIRECT3DDEVICE9 iface, UINT StreamNumber, UINT* Divider) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetIndices(LPDIRECT3DDEVICE9 iface, IDirect3DIndexBuffer9* pIndexData) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + IDirect3DIndexBuffer9 *oldIdxs; + + TRACE("(%p) : Setting to %p\n", This, pIndexData); + oldIdxs = This->StateBlock->pIndexData; + + This->UpdateStateBlock->Changed.Indices = TRUE; + This->UpdateStateBlock->Set.Indices = TRUE; + This->UpdateStateBlock->pIndexData = pIndexData; + + /* Handle recording of state blocks */ + if (This->isRecordingState) { + TRACE("Recording... not performing anything\n"); + return D3D_OK; + } + + if (oldIdxs) IDirect3DIndexBuffer9Impl_Release(oldIdxs); + if (pIndexData) IDirect3DIndexBuffer9Impl_AddRef(This->StateBlock->pIndexData); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetIndices(LPDIRECT3DDEVICE9 iface, IDirect3DIndexBuffer9** ppIndexData) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + + *ppIndexData = This->StateBlock->pIndexData; + /* up ref count on ppindexdata */ + if (*ppIndexData) IDirect3DIndexBuffer9Impl_AddRef(*ppIndexData); + + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_DrawRectPatch(LPDIRECT3DDEVICE9 iface, UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_DrawTriPatch(LPDIRECT3DDEVICE9 iface, UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_DeletePatch(LPDIRECT3DDEVICE9 iface, UINT Handle) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DDevice9) Direct3DDevice9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DDevice9Impl_QueryInterface, + IDirect3DDevice9Impl_AddRef, + IDirect3DDevice9Impl_Release, + IDirect3DDevice9Impl_TestCooperativeLevel, + IDirect3DDevice9Impl_GetAvailableTextureMem, + IDirect3DDevice9Impl_EvictManagedRessources, + 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_StretchRects, + 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 +}; diff --git a/dlls/d3d9/directx.c b/dlls/d3d9/directx.c new file mode 100644 index 00000000000..b8aa95fefa7 --- /dev/null +++ b/dlls/d3d9/directx.c @@ -0,0 +1,185 @@ +/* + * IDirect3D9 implementation + * + * Copyright 2002 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" +#include "wine/unicode.h" + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3D9 IUnknown parts follow: */ +HRESULT WINAPI IDirect3D9Impl_QueryInterface(LPDIRECT3D9 iface, REFIID riid, LPVOID* ppobj) +{ + ICOM_THIS(IDirect3D9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3D9)) { + IDirect3D9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3D9Impl_AddRef(LPDIRECT3D9 iface) { + ICOM_THIS(IDirect3D9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3D9Impl_Release(LPDIRECT3D9 iface) { + ICOM_THIS(IDirect3D9Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) + HeapFree(GetProcessHeap(), 0, This); + return ref; +} + +/* IDirect3D9 Interface follow: */ +HRESULT WINAPI IDirect3D9Impl_RegisterSoftwareDevice(LPDIRECT3D9 iface, void* pInitializeFunction) { + ICOM_THIS(IDirect3D9Impl,iface); + FIXME("(%p)->(%p): stub\n", This, pInitializeFunction); + return D3D_OK; +} + +UINT WINAPI IDirect3D9Impl_GetAdapterCount(LPDIRECT3D9 iface) { + ICOM_THIS(IDirect3D9Impl,iface); + /* FIXME: Set to one for now to imply the display */ + TRACE("(%p): Mostly stub, only returns primary display\n", This); + return 1; +} + +HRESULT WINAPI IDirect3D9Impl_GetAdapterIdentifier(LPDIRECT3D9 iface, UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER9* pIdentifier) { + ICOM_THIS(IDirect3D9Impl,iface); + FIXME("(%p): stub\n", This); + return D3D_OK; +} + +UINT WINAPI IDirect3D9Impl_GetAdapterModeCount(LPDIRECT3D9 iface, UINT Adapter, D3DFORMAT Format) { + ICOM_THIS(IDirect3D9Impl,iface); + FIXME("(%p): stub\n", This); + return 0; +} + +HRESULT WINAPI IDirect3D9Impl_EnumAdapterModes(LPDIRECT3D9 iface, UINT Adapter, D3DFORMAT Format, UINT Mode, D3DDISPLAYMODE* pMode) { + ICOM_THIS(IDirect3D9Impl,iface); + FIXME("(%p): stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3D9Impl_GetAdapterDisplayMode(LPDIRECT3D9 iface, UINT Adapter, D3DDISPLAYMODE* pMode) { + ICOM_THIS(IDirect3D9Impl,iface); + FIXME("(%p): stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3D9Impl_CheckDeviceType(LPDIRECT3D9 iface, + UINT Adapter, D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat, + D3DFORMAT BackBufferFormat, BOOL Windowed) { + ICOM_THIS(IDirect3D9Impl,iface); + FIXME("(%p): stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3D9Impl_CheckDeviceFormat(LPDIRECT3D9 iface, + UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, + DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat) { + ICOM_THIS(IDirect3D9Impl,iface); + FIXME("(%p): stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3D9Impl_CheckDeviceMultiSampleType(LPDIRECT3D9 iface, + UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, + BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType, DWORD* pQualityLevels) { + ICOM_THIS(IDirect3D9Impl,iface); + FIXME("(%p): stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3D9Impl_CheckDepthStencilMatch(LPDIRECT3D9 iface, + UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, + D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat) { + ICOM_THIS(IDirect3D9Impl,iface); + FIXME("(%p): stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3D9Impl_CheckDeviceFormatConversion(LPDIRECT3D9 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SourceFormat, D3DFORMAT TargetFormat) { + ICOM_THIS(IDirect3D9Impl,iface); + FIXME("(%p): stub\n", This); + return D3D_OK; +} + + +HRESULT WINAPI IDirect3D9Impl_GetDeviceCaps(LPDIRECT3D9 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS9* pCaps) { + ICOM_THIS(IDirect3D9Impl,iface); + FIXME("(%p): stub\n", This); + return D3D_OK; +} + +HMONITOR WINAPI IDirect3D9Impl_GetAdapterMonitor(LPDIRECT3D9 iface, UINT Adapter) { + ICOM_THIS(IDirect3D9Impl,iface); + FIXME("(%p) : stub\n", This); + return NULL; +} + +HRESULT WINAPI IDirect3D9Impl_CreateDevice(LPDIRECT3D9 iface, UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow, + DWORD BehaviourFlags, D3DPRESENT_PARAMETERS* pPresentationParameters, + IDirect3DDevice9** ppReturnedDeviceInterface) { + + ICOM_THIS(IDirect3D9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +ICOM_VTABLE(IDirect3D9) Direct3D9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3D9Impl_QueryInterface, + IDirect3D9Impl_AddRef, + IDirect3D9Impl_Release, + 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/dlls/d3d9/indexbuffer.c b/dlls/d3d9/indexbuffer.c new file mode 100644 index 00000000000..2ced1ee2f0e --- /dev/null +++ b/dlls/d3d9/indexbuffer.c @@ -0,0 +1,185 @@ +/* + * IDirect3DIndexBuffer9 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DIndexBuffer9 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DIndexBuffer9Impl_QueryInterface(LPDIRECT3DINDEXBUFFER9 iface, REFIID riid, LPVOID* ppobj) { + ICOM_THIS(IDirect3DIndexBuffer9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IDirect3DIndexBuffer9)) { + IDirect3DIndexBuffer9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DIndexBuffer9Impl_AddRef(LPDIRECT3DINDEXBUFFER9 iface) { + ICOM_THIS(IDirect3DIndexBuffer9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DIndexBuffer9Impl_Release(LPDIRECT3DINDEXBUFFER9 iface) { + ICOM_THIS(IDirect3DIndexBuffer9Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + HeapFree(GetProcessHeap(), 0, This->allocatedMemory); + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DIndexBuffer9 IDirect3DResource9 Interface follow: */ +HRESULT WINAPI IDirect3DIndexBuffer9Impl_GetDevice(LPDIRECT3DINDEXBUFFER9 iface, IDirect3DDevice9** ppDevice) { + ICOM_THIS(IDirect3DIndexBuffer9Impl,iface); + return IDirect3DResource9Impl_GetDevice((LPDIRECT3DRESOURCE9) This, ppDevice); +} + +HRESULT WINAPI IDirect3DIndexBuffer9Impl_SetPrivateData(LPDIRECT3DINDEXBUFFER9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DIndexBuffer9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DIndexBuffer9Impl_GetPrivateData(LPDIRECT3DINDEXBUFFER9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DIndexBuffer9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DIndexBuffer9Impl_FreePrivateData(LPDIRECT3DINDEXBUFFER9 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DIndexBuffer9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +DWORD WINAPI IDirect3DIndexBuffer9Impl_SetPriority(LPDIRECT3DINDEXBUFFER9 iface, DWORD PriorityNew) { + ICOM_THIS(IDirect3DIndexBuffer9Impl,iface); + return IDirect3DResource9Impl_SetPriority((LPDIRECT3DRESOURCE9) This, PriorityNew); +} + +DWORD WINAPI IDirect3DIndexBuffer9Impl_GetPriority(LPDIRECT3DINDEXBUFFER9 iface) { + ICOM_THIS(IDirect3DIndexBuffer9Impl,iface); + return IDirect3DResource9Impl_GetPriority((LPDIRECT3DRESOURCE9) This); +} + +void WINAPI IDirect3DIndexBuffer9Impl_PreLoad(LPDIRECT3DINDEXBUFFER9 iface) { + ICOM_THIS(IDirect3DIndexBuffer9Impl,iface); + FIXME("(%p) : stub\n", This); + return ; +} + +D3DRESOURCETYPE WINAPI IDirect3DIndexBuffer9Impl_GetType(LPDIRECT3DINDEXBUFFER9 iface) { + ICOM_THIS(IDirect3DIndexBuffer9Impl,iface); + return IDirect3DResource9Impl_GetType((LPDIRECT3DRESOURCE9) This); +} + +/* IDirect3DIndexBuffer9 Interface follow: */ +HRESULT WINAPI IDirect3DIndexBuffer9Impl_Lock(LPDIRECT3DINDEXBUFFER9 iface, UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags) { + ICOM_THIS(IDirect3DIndexBuffer9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DIndexBuffer9Impl_Unlock(LPDIRECT3DINDEXBUFFER9 iface) { + ICOM_THIS(IDirect3DIndexBuffer9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DIndexBuffer9Impl_GetDesc(LPDIRECT3DINDEXBUFFER9 iface, D3DINDEXBUFFER_DESC *pDesc) { + ICOM_THIS(IDirect3DIndexBuffer9Impl,iface); + TRACE("(%p) : copying into %p\n", This, pDesc); + memcpy(pDesc, &This->myDesc, sizeof(D3DINDEXBUFFER_DESC)); + return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DIndexBuffer9) Direct3DIndexBuffer9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DIndexBuffer9Impl_QueryInterface, + IDirect3DIndexBuffer9Impl_AddRef, + IDirect3DIndexBuffer9Impl_Release, + IDirect3DIndexBuffer9Impl_GetDevice, + IDirect3DIndexBuffer9Impl_SetPrivateData, + IDirect3DIndexBuffer9Impl_GetPrivateData, + IDirect3DIndexBuffer9Impl_FreePrivateData, + IDirect3DIndexBuffer9Impl_SetPriority, + IDirect3DIndexBuffer9Impl_GetPriority, + IDirect3DIndexBuffer9Impl_PreLoad, + IDirect3DIndexBuffer9Impl_GetType, + 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; + + ICOM_THIS(IDirect3DDevice9Impl,iface); + + /*TRACE("(%p) : Len=%d, Use=%lx, Format=(%u,%s), Pool=%d\n", This, Length, Usage, Format, debug_d3dformat(Format), Pool);*/ + + /* Allocate the storage for the device */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DIndexBuffer9Impl)); + object->lpVtbl = &Direct3DIndexBuffer9_Vtbl; + object->ref = 1; + object->Device = This; + + object->ResourceType = D3DRTYPE_INDEXBUFFER; + + object->allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, Length); + object->myDesc.Type = D3DRTYPE_INDEXBUFFER; + object->myDesc.Usage = Usage; + object->myDesc.Pool = Pool; + object->myDesc.Format = Format; + object->myDesc.Size = Length; + + TRACE("(%p) : Iface@%p allocatedMem @ %p\n", This, object, object->allocatedMemory); + + *ppIndexBuffer = (LPDIRECT3DINDEXBUFFER9) object; + + return D3D_OK; +} diff --git a/dlls/d3d9/pixelshader.c b/dlls/d3d9/pixelshader.c new file mode 100644 index 00000000000..1b0a98e5f47 --- /dev/null +++ b/dlls/d3d9/pixelshader.c @@ -0,0 +1,242 @@ +/* + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader); + +/* IDirect3DPixelShader9 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DPixelShader9Impl_QueryInterface(LPDIRECT3DPIXELSHADER9 iface, REFIID riid, LPVOID* ppobj) { + ICOM_THIS(IDirect3DPixelShader9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DPixelShader9)) { + IDirect3DPixelShader9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DPixelShader9Impl_AddRef(LPDIRECT3DPIXELSHADER9 iface) { + ICOM_THIS(IDirect3DPixelShader9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DPixelShader9Impl_Release(LPDIRECT3DPIXELSHADER9 iface) { + ICOM_THIS(IDirect3DPixelShader9Impl,iface); + ULONG ref = --This->ref; + + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DPixelShader9 Interface follow: */ +HRESULT WINAPI IDirect3DPixelShader9Impl_GetDevice(LPDIRECT3DPIXELSHADER9 iface, IDirect3DDevice9** ppDevice) { + ICOM_THIS(IDirect3DPixelShader9Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE9) This->Device; + IDirect3DDevice9Impl_AddRef(*ppDevice); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DPixelShader9Impl_GetFunction(LPDIRECT3DPIXELSHADER9 iface, VOID* pData, UINT* pSizeOfData) { + ICOM_THIS(IDirect3DPixelShader9Impl,iface); + FIXME("(%p): stub\n", This); + return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DPixelShader9) Direct3DPixelShader9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DPixelShader9Impl_QueryInterface, + IDirect3DPixelShader9Impl_AddRef, + IDirect3DPixelShader9Impl_Release, + IDirect3DPixelShader9Impl_GetDevice, + IDirect3DPixelShader9Impl_GetFunction +}; + + +/* IDirect3DDevice9 IDirect3DPixelShader9 Methods follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_CreatePixelShader(LPDIRECT3DDEVICE9 iface, CONST DWORD* pFunction, IDirect3DPixelShader9** ppShader) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetPixelShader(LPDIRECT3DDEVICE9 iface, IDirect3DPixelShader9* pShader) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + + This->UpdateStateBlock->PixelShader = pShader; + This->UpdateStateBlock->Changed.pixelShader = TRUE; + This->UpdateStateBlock->Set.pixelShader = TRUE; + + /* Handle recording of state blocks */ + if (This->isRecordingState) { + TRACE("Recording... not performing anything\n"); + return D3D_OK; + } + /** + * TODO: merge HAL shaders context switching from prototype + */ + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetPixelShader(LPDIRECT3DDEVICE9 iface, IDirect3DPixelShader9** ppShader) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : GetPixelShader returning %p\n", This, This->StateBlock->PixelShader); + *ppShader = This->StateBlock->PixelShader; + IDirect3DPixelShader9Impl_AddRef(*ppShader); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetPixelShaderConstantF(LPDIRECT3DDEVICE9 iface, UINT Register, CONST float* pConstantData, UINT Vector4fCount) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + + if (Register + Vector4fCount > D3D_VSHADER_MAX_CONSTANTS) { + ERR("(%p) : SetPixelShaderConstant C[%u] invalid\n", This, Register); + return D3DERR_INVALIDCALL; + } + if (NULL == pConstantData) { + return D3DERR_INVALIDCALL; + } + if (Vector4fCount > 1) { + CONST FLOAT* f = pConstantData; + UINT i; + TRACE("(%p) : SetPixelShaderConstant C[%u..%u]=\n", This, Register, Register + Vector4fCount - 1); + for (i = 0; i < Vector4fCount; ++i) { + TRACE("{%f, %f, %f, %f}\n", f[0], f[1], f[2], f[3]); + f += 4; + } + } else { + FLOAT* f = (FLOAT*) pConstantData; + TRACE("(%p) : SetPixelShaderConstant, C[%u]={%f, %f, %f, %f}\n", This, Register, f[0], f[1], f[2], f[3]); + } + This->UpdateStateBlock->Changed.pixelShaderConstant = TRUE; + memcpy(&This->UpdateStateBlock->pixelShaderConstantF[Register], pConstantData, Vector4fCount * 4 * sizeof(FLOAT)); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetPixelShaderConstantF(LPDIRECT3DDEVICE9 iface, UINT Register, float* pConstantData, UINT Vector4fCount) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + + TRACE("(%p) : C[%u] count=%u\n", This, Register, Vector4fCount); + if (Register + Vector4fCount > D3D_VSHADER_MAX_CONSTANTS) { + return D3DERR_INVALIDCALL; + } + if (NULL == pConstantData) { + return D3DERR_INVALIDCALL; + } + memcpy(pConstantData, &This->UpdateStateBlock->pixelShaderConstantF[Register], Vector4fCount * 4 * sizeof(FLOAT)); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetPixelShaderConstantI(LPDIRECT3DDEVICE9 iface, UINT Register, CONST int* pConstantData, UINT Vector4iCount) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + + if (Register + Vector4iCount > D3D_VSHADER_MAX_CONSTANTS) { + ERR("(%p) : SetPixelShaderConstantI C[%u] invalid\n", This, Register); + return D3DERR_INVALIDCALL; + } + if (NULL == pConstantData) { + return D3DERR_INVALIDCALL; + } + if (Vector4iCount > 1) { + CONST int* f = pConstantData; + UINT i; + TRACE("(%p) : SetPixelShaderConstantI C[%u..%u]=\n", This, Register, Register + Vector4iCount - 1); + for (i = 0; i < Vector4iCount; ++i) { + TRACE("{%d, %d, %d, %d}\n", f[0], f[1], f[2], f[3]); + f += 4; + } + } else { + CONST int* f = pConstantData; + TRACE("(%p) : SetPixelShaderConstantI, C[%u]={%i, %i, %i, %i}\n", This, Register, f[0], f[1], f[2], f[3]); + } + This->UpdateStateBlock->Changed.pixelShaderConstant = TRUE; + memcpy(&This->UpdateStateBlock->pixelShaderConstantI[Register], pConstantData, Vector4iCount * 4 * sizeof(int)); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetPixelShaderConstantI(LPDIRECT3DDEVICE9 iface, UINT Register, int* pConstantData, UINT Vector4iCount) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + + TRACE("(%p) : C[%u] count=%u\n", This, Register, Vector4iCount); + if (Register + Vector4iCount > D3D_VSHADER_MAX_CONSTANTS) { + return D3DERR_INVALIDCALL; + } + if (NULL == pConstantData) { + return D3DERR_INVALIDCALL; + } + memcpy(pConstantData, &This->UpdateStateBlock->pixelShaderConstantI[Register], Vector4iCount * 4 * sizeof(FLOAT)); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetPixelShaderConstantB(LPDIRECT3DDEVICE9 iface, UINT Register, CONST BOOL* pConstantData, UINT BoolCount) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + UINT i; + + if (Register + BoolCount > D3D_VSHADER_MAX_CONSTANTS) { + ERR("(%p) : SetPixelShaderConstantB C[%u] invalid\n", This, Register); + return D3DERR_INVALIDCALL; + } + if (NULL == pConstantData) { + return D3DERR_INVALIDCALL; + } + if (BoolCount > 1) { + CONST BOOL* f = pConstantData; + TRACE("(%p) : SetPixelShaderConstantB C[%u..%u]=\n", This, Register, Register + BoolCount - 1); + for (i = 0; i < BoolCount; ++i) { + TRACE("{%u}\n", f[i]); + } + } else { + CONST BOOL* f = pConstantData; + TRACE("(%p) : SetPixelShaderConstantB, C[%u]={%u}\n", This, Register, f[0]); + } + This->UpdateStateBlock->Changed.pixelShaderConstant = TRUE; + for (i = 0; i < BoolCount; ++i) { + This->UpdateStateBlock->pixelShaderConstantB[Register] = pConstantData[i]; + } + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetPixelShaderConstantB(LPDIRECT3DDEVICE9 iface, UINT Register, BOOL* pConstantData, UINT BoolCount) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} diff --git a/dlls/d3d9/query.c b/dlls/d3d9/query.c new file mode 100644 index 00000000000..5ebf44c4e75 --- /dev/null +++ b/dlls/d3d9/query.c @@ -0,0 +1,122 @@ +/* + * IDirect3DQuery9 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DQuery9 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DQuery9Impl_QueryInterface(LPDIRECT3DQUERY9 iface, REFIID riid, LPVOID* ppobj) { + ICOM_THIS(IDirect3DQuery9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DQuery9)) { + IDirect3DQuery9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DQuery9Impl_AddRef(LPDIRECT3DQUERY9 iface) { + ICOM_THIS(IDirect3DQuery9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DQuery9Impl_Release(LPDIRECT3DQUERY9 iface) { + ICOM_THIS(IDirect3DQuery9Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DQuery9 Interface follow: */ +HRESULT WINAPI IDirect3DQuery9Impl_GetDevice(LPDIRECT3DQUERY9 iface, IDirect3DDevice9** ppDevice) { + ICOM_THIS(IDirect3DQuery9Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE9) This->Device; + IDirect3DDevice9Impl_AddRef(*ppDevice); + return D3D_OK; +} + +D3DQUERYTYPE WINAPI IDirect3DQuery9Impl_GetType(LPDIRECT3DQUERY9 iface) { + ICOM_THIS(IDirect3DQuery9Impl,iface); + FIXME("(%p) : stub\n", This); + return 0; +} + +DWORD WINAPI IDirect3DQuery9Impl_GetDataSize(LPDIRECT3DQUERY9 iface) { + ICOM_THIS(IDirect3DQuery9Impl,iface); + FIXME("(%p) : stub\n", This); + return 0; +} + +HRESULT WINAPI IDirect3DQuery9Impl_Issue(LPDIRECT3DQUERY9 iface, DWORD dwIssueFlags) { + ICOM_THIS(IDirect3DQuery9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DQuery9Impl_GetData(LPDIRECT3DQUERY9 iface, void* pData, DWORD dwSize, DWORD dwGetDataFlags) { + ICOM_THIS(IDirect3DQuery9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DQuery9) Direct3DQuery9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + 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) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} diff --git a/dlls/d3d9/resource.c b/dlls/d3d9/resource.c new file mode 100644 index 00000000000..8996212cad6 --- /dev/null +++ b/dlls/d3d9/resource.c @@ -0,0 +1,132 @@ +/* + * IDirect3DResource9 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DResource9 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DResource9Impl_QueryInterface(LPDIRECT3DRESOURCE9 iface, REFIID riid, LPVOID* ppobj) { + ICOM_THIS(IDirect3DResource9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DResource9)) { + IDirect3DResource9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DResource9Impl_AddRef(LPDIRECT3DRESOURCE9 iface) { + ICOM_THIS(IDirect3DResource9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DResource9Impl_Release(LPDIRECT3DRESOURCE9 iface) { + ICOM_THIS(IDirect3DResource9Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DResource9 Interface follow: */ +HRESULT WINAPI IDirect3DResource9Impl_GetDevice(LPDIRECT3DRESOURCE9 iface, IDirect3DDevice9** ppDevice) { + ICOM_THIS(IDirect3DResource9Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE9) This->Device; + IDirect3DDevice9Impl_AddRef(*ppDevice); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DResource9Impl_SetPrivateData(LPDIRECT3DRESOURCE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DResource9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DResource9Impl_GetPrivateData(LPDIRECT3DRESOURCE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DResource9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DResource9Impl_FreePrivateData(LPDIRECT3DRESOURCE9 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DResource9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +DWORD WINAPI IDirect3DResource9Impl_SetPriority(LPDIRECT3DRESOURCE9 iface, DWORD PriorityNew) { + ICOM_THIS(IDirect3DResource9Impl,iface); + FIXME("(%p) : stub\n", This); + return 0; +} + +DWORD WINAPI IDirect3DResource9Impl_GetPriority(LPDIRECT3DRESOURCE9 iface) { + ICOM_THIS(IDirect3DResource9Impl,iface); + FIXME("(%p) : stub\n", This); + return 0; +} + +void WINAPI IDirect3DResource9Impl_PreLoad(LPDIRECT3DRESOURCE9 iface) { + ICOM_THIS(IDirect3DResource9Impl,iface); + FIXME("(%p) : stub\n", This); +} + +D3DRESOURCETYPE WINAPI IDirect3DResource9Impl_GetType(LPDIRECT3DRESOURCE9 iface) { + ICOM_THIS(IDirect3DResource9Impl,iface); + TRACE("(%p) : returning %d\n", This, This->ResourceType); + return This->ResourceType; +} + + +ICOM_VTABLE(IDirect3DResource9) Direct3DResource9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + 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/dlls/d3d9/stateblock.c b/dlls/d3d9/stateblock.c new file mode 100644 index 00000000000..a82221c60fb --- /dev/null +++ b/dlls/d3d9/stateblock.c @@ -0,0 +1,120 @@ +/* + * IDirect3DStateBlock9 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DStateBlock9 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DStateBlock9Impl_QueryInterface(LPDIRECT3DSTATEBLOCK9 iface, REFIID riid, LPVOID* ppobj) { + ICOM_THIS(IDirect3DStateBlock9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DStateBlock9)) { + IDirect3DStateBlock9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DStateBlock9Impl_AddRef(LPDIRECT3DSTATEBLOCK9 iface) { + ICOM_THIS(IDirect3DStateBlock9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DStateBlock9Impl_Release(LPDIRECT3DSTATEBLOCK9 iface) { + ICOM_THIS(IDirect3DStateBlock9Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DStateBlock9 Interface follow: */ +HRESULT WINAPI IDirect3DStateBlock9Impl_GetDevice(LPDIRECT3DSTATEBLOCK9 iface, IDirect3DDevice9** ppDevice) { + ICOM_THIS(IDirect3DStateBlock9Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE9) This->Device; + IDirect3DDevice9Impl_AddRef(*ppDevice); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DStateBlock9Impl_Capture(LPDIRECT3DSTATEBLOCK9 iface) { + ICOM_THIS(IDirect3DStateBlock9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DStateBlock9Impl_Apply(LPDIRECT3DSTATEBLOCK9 iface) { + ICOM_THIS(IDirect3DStateBlock9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DStateBlock9) Direct3DStateBlock9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DStateBlock9Impl_QueryInterface, + IDirect3DStateBlock9Impl_AddRef, + IDirect3DStateBlock9Impl_Release, + IDirect3DStateBlock9Impl_GetDevice, + IDirect3DStateBlock9Impl_Capture, + IDirect3DStateBlock9Impl_Apply +}; + + +/* IDirect3DDevice9 IDirect3DStateBlock9 Methods follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_CreateStateBlock(LPDIRECT3DDEVICE9 iface, D3DSTATEBLOCKTYPE Type, IDirect3DStateBlock9** ppSB) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_BeginStateBlock(LPDIRECT3DDEVICE9 iface) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_EndStateBlock(LPDIRECT3DDEVICE9 iface, IDirect3DStateBlock9** ppSB) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} diff --git a/dlls/d3d9/surface.c b/dlls/d3d9/surface.c new file mode 100644 index 00000000000..edfa6649724 --- /dev/null +++ b/dlls/d3d9/surface.c @@ -0,0 +1,184 @@ +/* + * IDirect3DSurface9 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" +#include + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface); + +/* IDirect3DSurface9 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DSurface9Impl_QueryInterface(LPDIRECT3DSURFACE9 iface, REFIID riid, LPVOID* ppobj) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IDirect3DSurface9)) { + IDirect3DSurface9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DSurface9Impl_AddRef(LPDIRECT3DSURFACE9 iface) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DSurface9Impl_Release(LPDIRECT3DSURFACE9 iface) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + HeapFree(GetProcessHeap(), 0, This->allocatedMemory); + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DSurface9 IDirect3DResource9 Interface follow: */ +HRESULT WINAPI IDirect3DSurface9Impl_GetDevice(LPDIRECT3DSURFACE9 iface, IDirect3DDevice9** ppDevice) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + return IDirect3DResource9Impl_GetDevice((LPDIRECT3DRESOURCE9) This, ppDevice); +} + +HRESULT WINAPI IDirect3DSurface9Impl_SetPrivateData(LPDIRECT3DSURFACE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DSurface9Impl_GetPrivateData(LPDIRECT3DSURFACE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DSurface9Impl_FreePrivateData(LPDIRECT3DSURFACE9 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +DWORD WINAPI IDirect3DSurface9Impl_SetPriority(LPDIRECT3DSURFACE9 iface, DWORD PriorityNew) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + return IDirect3DResource9Impl_SetPriority((LPDIRECT3DRESOURCE9) This, PriorityNew); +} + +DWORD WINAPI IDirect3DSurface9Impl_GetPriority(LPDIRECT3DSURFACE9 iface) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + return IDirect3DResource9Impl_GetPriority((LPDIRECT3DRESOURCE9) This); +} + +void WINAPI IDirect3DSurface9Impl_PreLoad(LPDIRECT3DSURFACE9 iface) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + FIXME("(%p) : stub\n", This); + return ; +} + +D3DRESOURCETYPE WINAPI IDirect3DSurface9Impl_GetType(LPDIRECT3DSURFACE9 iface) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + return IDirect3DResource9Impl_GetType((LPDIRECT3DRESOURCE9) This); +} + +/* IDirect3DSurface9 Interface follow: */ +HRESULT WINAPI IDirect3DSurface9Impl_GetContainer(LPDIRECT3DSURFACE9 iface, REFIID riid, void** ppContainer) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + HRESULT res; + res = IUnknown_QueryInterface(This->Container, riid, ppContainer); + if (E_NOINTERFACE == res) { + /** + * If the surface is created using CreateImageSurface, CreateRenderTarget, + * or CreateDepthStencilSurface, the surface is considered stand alone. In this case, + * GetContainer will return the Direct3D device used to create the surface. + */ + res = IUnknown_QueryInterface(This->Container, &IID_IDirect3DDevice9, ppContainer); + } + TRACE("(%p) : returning %p\n", This, *ppContainer); + return res; +} + +HRESULT WINAPI IDirect3DSurface9Impl_GetDesc(LPDIRECT3DSURFACE9 iface, D3DSURFACE_DESC* pDesc) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + TRACE("(%p) : copying into %p\n", This, pDesc); + memcpy(pDesc, &This->myDesc, sizeof(D3DSURFACE_DESC)); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DSurface9Impl_LockRect(LPDIRECT3DSURFACE9 iface, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DSurface9Impl_UnlockRect(LPDIRECT3DSURFACE9 iface) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DSurface9Impl_GetDC(LPDIRECT3DSURFACE9 iface, HDC* phdc) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DSurface9Impl_ReleaseDC(LPDIRECT3DSURFACE9 iface, HDC hdc) { + ICOM_THIS(IDirect3DSurface9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DSurface9) Direct3DSurface9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DSurface9Impl_QueryInterface, + IDirect3DSurface9Impl_AddRef, + IDirect3DSurface9Impl_Release, + IDirect3DSurface9Impl_GetDevice, + IDirect3DSurface9Impl_SetPrivateData, + IDirect3DSurface9Impl_GetPrivateData, + IDirect3DSurface9Impl_FreePrivateData, + IDirect3DSurface9Impl_SetPriority, + IDirect3DSurface9Impl_GetPriority, + IDirect3DSurface9Impl_PreLoad, + IDirect3DSurface9Impl_GetType, + IDirect3DSurface9Impl_GetContainer, + IDirect3DSurface9Impl_GetDesc, + IDirect3DSurface9Impl_LockRect, + IDirect3DSurface9Impl_UnlockRect, + IDirect3DSurface9Impl_GetDC, + IDirect3DSurface9Impl_ReleaseDC +}; diff --git a/dlls/d3d9/swapchain.c b/dlls/d3d9/swapchain.c new file mode 100644 index 00000000000..f042fcf94bf --- /dev/null +++ b/dlls/d3d9/swapchain.c @@ -0,0 +1,151 @@ +/* + * IDirect3DSwapChain9 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DSwapChain IUnknown parts follow: */ +HRESULT WINAPI IDirect3DSwapChain9Impl_QueryInterface(LPDIRECT3DSWAPCHAIN9 iface, REFIID riid, LPVOID* ppobj) +{ + ICOM_THIS(IDirect3DSwapChain9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DSwapChain9)) { + IDirect3DSwapChain9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DSwapChain9Impl_AddRef(LPDIRECT3DSWAPCHAIN9 iface) { + ICOM_THIS(IDirect3DSwapChain9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DSwapChain9Impl_Release(LPDIRECT3DSWAPCHAIN9 iface) { + ICOM_THIS(IDirect3DSwapChain9Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DSwapChain9 parts follow: */ +HRESULT WINAPI IDirect3DSwapChain9Impl_Present(LPDIRECT3DSWAPCHAIN9 iface, CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion, DWORD dwFlags) { + ICOM_THIS(IDirect3DSwapChain9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DSwapChain9Impl_GetFrontBufferData(LPDIRECT3DSWAPCHAIN9 iface, IDirect3DSurface9* pDestSurface) { + ICOM_THIS(IDirect3DSwapChain9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DSwapChain9Impl_GetBackBuffer(LPDIRECT3DSWAPCHAIN9 iface, UINT iBackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface9** ppBackBuffer) { + ICOM_THIS(IDirect3DSwapChain9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DSwapChain9Impl_GetRasterStatus(LPDIRECT3DSWAPCHAIN9 iface, D3DRASTER_STATUS* pRasterStatus) { + ICOM_THIS(IDirect3DSwapChain9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DSwapChain9Impl_GetDisplayMode(LPDIRECT3DSWAPCHAIN9 iface, D3DDISPLAYMODE* pMode) { + ICOM_THIS(IDirect3DSwapChain9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DSwapChain9Impl_GetDevice(LPDIRECT3DSWAPCHAIN9 iface, IDirect3DDevice9** ppDevice) { + ICOM_THIS(IDirect3DSwapChain9Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE9) This->Device; + + /* Note Calling this method will increase the internal reference count + on the IDirect3DDevice9 interface. */ + IDirect3DDevice9Impl_AddRef(*ppDevice); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DSwapChain9Impl_GetPresentParameters(LPDIRECT3DSWAPCHAIN9 iface, D3DPRESENT_PARAMETERS* pPresentationParameters) { + ICOM_THIS(IDirect3DSwapChain9Impl,iface); + FIXME("(%p) : copy\n", This); + memcpy(pPresentationParameters, &This->PresentParms, sizeof(D3DPRESENT_PARAMETERS)); + return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DSwapChain9) Direct3DSwapChain9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + 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) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetSwapChain(LPDIRECT3DDEVICE9 iface, UINT iSwapChain, IDirect3DSwapChain9** pSwapChain) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +UINT WINAPI IDirect3DDevice9Impl_GetNumberOfSwapChains(LPDIRECT3DDEVICE9 iface) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return 1; +} diff --git a/dlls/d3d9/texture.c b/dlls/d3d9/texture.c new file mode 100644 index 00000000000..c15e2ce543e --- /dev/null +++ b/dlls/d3d9/texture.c @@ -0,0 +1,248 @@ +/* + * IDirect3DTexture9 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DTexture9 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DTexture9Impl_QueryInterface(LPDIRECT3DTEXTURE9 iface, REFIID riid, LPVOID* ppobj) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9) + || IsEqualGUID(riid, &IID_IDirect3DTexture9)) { + IDirect3DTexture9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p) not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DTexture9Impl_AddRef(LPDIRECT3DTEXTURE9 iface) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DTexture9Impl_Release(LPDIRECT3DTEXTURE9 iface) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + ULONG ref = --This->ref; + int i; + + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + for (i = 0; i < This->levels; i++) { + if (NULL != This->surfaces[i]) { + TRACE("(%p) : Releasing surface %p\n", This, This->surfaces[i]); + IDirect3DSurface9Impl_Release((LPDIRECT3DSURFACE9) This->surfaces[i]); + } + } + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DTexture9 IDirect3DResource9 Interface follow: */ +HRESULT WINAPI IDirect3DTexture9Impl_GetDevice(LPDIRECT3DTEXTURE9 iface, IDirect3DDevice9** ppDevice) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + return IDirect3DResource9Impl_GetDevice((LPDIRECT3DRESOURCE9) This, ppDevice); +} + +HRESULT WINAPI IDirect3DTexture9Impl_SetPrivateData(LPDIRECT3DTEXTURE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DTexture9Impl_GetPrivateData(LPDIRECT3DTEXTURE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DTexture9Impl_FreePrivateData(LPDIRECT3DTEXTURE9 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +DWORD WINAPI IDirect3DTexture9Impl_SetPriority(LPDIRECT3DTEXTURE9 iface, DWORD PriorityNew) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + return IDirect3DResource9Impl_SetPriority((LPDIRECT3DRESOURCE9) This, PriorityNew); +} + +DWORD WINAPI IDirect3DTexture9Impl_GetPriority(LPDIRECT3DTEXTURE9 iface) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + return IDirect3DResource9Impl_GetPriority((LPDIRECT3DRESOURCE9) This); +} + +void WINAPI IDirect3DTexture9Impl_PreLoad(LPDIRECT3DTEXTURE9 iface) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return ; +} + +D3DRESOURCETYPE WINAPI IDirect3DTexture9Impl_GetType(LPDIRECT3DTEXTURE9 iface) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + return IDirect3DResource9Impl_GetType((LPDIRECT3DRESOURCE9) This); +} + +/* IDirect3DTexture9 IDirect3DBaseTexture9 Interface follow: */ +DWORD WINAPI IDirect3DTexture9Impl_SetLOD(LPDIRECT3DTEXTURE9 iface, DWORD LODNew) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + return IDirect3DBaseTexture9Impl_SetLOD((LPDIRECT3DBASETEXTURE9) This, LODNew); +} + +DWORD WINAPI IDirect3DTexture9Impl_GetLOD(LPDIRECT3DTEXTURE9 iface) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + return IDirect3DBaseTexture9Impl_GetLOD((LPDIRECT3DBASETEXTURE9) This); +} + +DWORD WINAPI IDirect3DTexture9Impl_GetLevelCount(LPDIRECT3DTEXTURE9 iface) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + return IDirect3DBaseTexture9Impl_GetLevelCount((LPDIRECT3DBASETEXTURE9) This); +} + +HRESULT WINAPI IDirect3DTexture9Impl_SetAutoGenFilterType(LPDIRECT3DTEXTURE9 iface, D3DTEXTUREFILTERTYPE FilterType) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + return IDirect3DBaseTexture9Impl_SetAutoGenFilterType((LPDIRECT3DBASETEXTURE9) This, FilterType); +} + +D3DTEXTUREFILTERTYPE WINAPI IDirect3DTexture9Impl_GetAutoGenFilterType(LPDIRECT3DTEXTURE9 iface) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + return IDirect3DBaseTexture9Impl_GetAutoGenFilterType((LPDIRECT3DBASETEXTURE9) This); +} + +void WINAPI IDirect3DTexture9Impl_GenerateMipSubLevels(LPDIRECT3DTEXTURE9 iface) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return ; +} + +/* IDirect3DTexture9 Interface follow: */ +HRESULT WINAPI IDirect3DTexture9Impl_GetLevelDesc(LPDIRECT3DTEXTURE9 iface, UINT Level, D3DSURFACE_DESC* pDesc) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + + if (Level < This->levels) { + TRACE("(%p) Level (%d)\n", This, Level); + return IDirect3DSurface9Impl_GetDesc((LPDIRECT3DSURFACE9) This->surfaces[Level], pDesc); + } else { + FIXME("(%p) level(%d) overflow Levels(%d)\n", This, Level, This->levels); + return D3DERR_INVALIDCALL; + } + return D3D_OK; +} + +HRESULT WINAPI IDirect3DTexture9Impl_GetSurfaceLevel(LPDIRECT3DTEXTURE9 iface, UINT Level, IDirect3DSurface9** ppSurfaceLevel) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + *ppSurfaceLevel = (LPDIRECT3DSURFACE9) This->surfaces[Level]; + IDirect3DSurface9Impl_AddRef((LPDIRECT3DSURFACE9) This->surfaces[Level]); + TRACE("(%p) : returning %p for level %d\n", This, *ppSurfaceLevel, Level); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DTexture9Impl_LockRect(LPDIRECT3DTEXTURE9 iface, UINT Level,D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) { + HRESULT hr; + ICOM_THIS(IDirect3DTexture9Impl,iface); + if (Level < This->levels) { + /** + * Not dirtified while Surfaces don't notify dirtification + * This->impl.parent.Dirty = TRUE; + */ + hr = IDirect3DSurface9Impl_LockRect((LPDIRECT3DSURFACE9) This->surfaces[Level], pLockedRect, pRect, Flags); + TRACE("(%p) Level (%d) success(%lu)\n", This, Level, hr); + } else { + FIXME("(%p) level(%d) overflow Levels(%d)\n", This, Level, This->levels); + return D3DERR_INVALIDCALL; + } + return hr; +} + +HRESULT WINAPI IDirect3DTexture9Impl_UnlockRect(LPDIRECT3DTEXTURE9 iface, UINT Level) { + HRESULT hr; + ICOM_THIS(IDirect3DTexture9Impl,iface); + if (Level < This->levels) { + hr = IDirect3DSurface9Impl_UnlockRect((LPDIRECT3DSURFACE9) This->surfaces[Level]); + TRACE("(%p) Level (%d) success(%lu)\n", This, Level, hr); + } else { + FIXME("(%p) level(%d) overflow Levels(%d)\n", This, Level, This->levels); + return D3DERR_INVALIDCALL; + } + return hr; +} + +HRESULT WINAPI IDirect3DTexture9Impl_AddDirtyRect(LPDIRECT3DTEXTURE9 iface, CONST RECT* pDirtyRect) { + ICOM_THIS(IDirect3DTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + This->Dirty = TRUE; + return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DTexture9) Direct3DTexture9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DTexture9Impl_QueryInterface, + IDirect3DTexture9Impl_AddRef, + IDirect3DTexture9Impl_Release, + IDirect3DTexture9Impl_GetDevice, + IDirect3DTexture9Impl_SetPrivateData, + IDirect3DTexture9Impl_GetPrivateData, + IDirect3DTexture9Impl_FreePrivateData, + IDirect3DTexture9Impl_SetPriority, + IDirect3DTexture9Impl_GetPriority, + IDirect3DTexture9Impl_PreLoad, + IDirect3DTexture9Impl_GetType, + IDirect3DTexture9Impl_SetLOD, + IDirect3DTexture9Impl_GetLOD, + IDirect3DTexture9Impl_GetLevelCount, + IDirect3DTexture9Impl_SetAutoGenFilterType, + IDirect3DTexture9Impl_GetAutoGenFilterType, + IDirect3DTexture9Impl_GenerateMipSubLevels, + 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) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} diff --git a/dlls/d3d9/version.rc b/dlls/d3d9/version.rc new file mode 100644 index 00000000000..61e3d1bdc77 --- /dev/null +++ b/dlls/d3d9/version.rc @@ -0,0 +1,27 @@ +/* + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#define WINE_FILEDESCRIPTION_STR "Wine Direct3D" +#define WINE_FILENAME_STR "d3d9.dll" +#define WINE_FILEVERSION 4,8,1,881 +#define WINE_FILEVERSION_STR "4.8.1.881" +#define WINE_PRODUCTVERSION 4,8,1,881 +#define WINE_PRODUCTVERSION_STR "4.8" +#define WINE_PRODUCTNAME_STR "DirectX" + +#include "wine/wine_common_ver.rc" diff --git a/dlls/d3d9/vertexbuffer.c b/dlls/d3d9/vertexbuffer.c new file mode 100644 index 00000000000..849690690b5 --- /dev/null +++ b/dlls/d3d9/vertexbuffer.c @@ -0,0 +1,182 @@ +/* + * IDirect3DResource9 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DVertexBuffer9 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DVertexBuffer9Impl_QueryInterface(LPDIRECT3DVERTEXBUFFER9 iface, REFIID riid, LPVOID* ppobj) { + ICOM_THIS(IDirect3DVertexBuffer9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IDirect3DVertexBuffer9)) { + IDirect3DVertexBuffer9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DVertexBuffer9Impl_AddRef(LPDIRECT3DVERTEXBUFFER9 iface) { + ICOM_THIS(IDirect3DVertexBuffer9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DVertexBuffer9Impl_Release(LPDIRECT3DVERTEXBUFFER9 iface) { + ICOM_THIS(IDirect3DVertexBuffer9Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + if (NULL != This->allocatedMemory) HeapFree(GetProcessHeap(), 0, This->allocatedMemory); + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DVertexBuffer9 IDirect3DResource9 Interface follow: */ +HRESULT WINAPI IDirect3DVertexBuffer9Impl_GetDevice(LPDIRECT3DVERTEXBUFFER9 iface, IDirect3DDevice9** ppDevice) { + ICOM_THIS(IDirect3DVertexBuffer9Impl,iface); + return IDirect3DResource9Impl_GetDevice((LPDIRECT3DRESOURCE9) This, ppDevice); +} + +HRESULT WINAPI IDirect3DVertexBuffer9Impl_SetPrivateData(LPDIRECT3DVERTEXBUFFER9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DVertexBuffer9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DVertexBuffer9Impl_GetPrivateData(LPDIRECT3DVERTEXBUFFER9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DVertexBuffer9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DVertexBuffer9Impl_FreePrivateData(LPDIRECT3DVERTEXBUFFER9 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DVertexBuffer9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +DWORD WINAPI IDirect3DVertexBuffer9Impl_SetPriority(LPDIRECT3DVERTEXBUFFER9 iface, DWORD PriorityNew) { + ICOM_THIS(IDirect3DVertexBuffer9Impl,iface); + return IDirect3DResource9Impl_SetPriority((LPDIRECT3DRESOURCE9) This, PriorityNew); +} + +DWORD WINAPI IDirect3DVertexBuffer9Impl_GetPriority(LPDIRECT3DVERTEXBUFFER9 iface) { + ICOM_THIS(IDirect3DVertexBuffer9Impl,iface); + return IDirect3DResource9Impl_GetPriority((LPDIRECT3DRESOURCE9) This); +} + +void WINAPI IDirect3DVertexBuffer9Impl_PreLoad(LPDIRECT3DVERTEXBUFFER9 iface) { + ICOM_THIS(IDirect3DVertexBuffer9Impl,iface); + FIXME("(%p) : stub\n", This); + return ; +} + +D3DRESOURCETYPE WINAPI IDirect3DVertexBuffer9Impl_GetType(LPDIRECT3DVERTEXBUFFER9 iface) { + ICOM_THIS(IDirect3DVertexBuffer9Impl,iface); + return IDirect3DResource9Impl_GetType((LPDIRECT3DRESOURCE9) This); +} + +/* IDirect3DVertexBuffer9 Interface follow: */ +HRESULT WINAPI IDirect3DVertexBuffer9Impl_Lock(LPDIRECT3DVERTEXBUFFER9 iface, UINT OffsetToLock, UINT SizeToLock, void** ppbData, DWORD Flags) { + ICOM_THIS(IDirect3DVertexBuffer9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DVertexBuffer9Impl_Unlock(LPDIRECT3DVERTEXBUFFER9 iface) { + ICOM_THIS(IDirect3DVertexBuffer9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DVertexBuffer9Impl_GetDesc(LPDIRECT3DVERTEXBUFFER9 iface, D3DVERTEXBUFFER_DESC* pDesc) { + ICOM_THIS(IDirect3DVertexBuffer9Impl,iface); + TRACE("(%p) : copying into %p\n", This, pDesc); + memcpy(pDesc, &This->myDesc, sizeof(D3DVERTEXBUFFER_DESC)); + return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DVertexBuffer9) Direct3DVertexBuffer9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DVertexBuffer9Impl_QueryInterface, + IDirect3DVertexBuffer9Impl_AddRef, + IDirect3DVertexBuffer9Impl_Release, + IDirect3DVertexBuffer9Impl_GetDevice, + IDirect3DVertexBuffer9Impl_SetPrivateData, + IDirect3DVertexBuffer9Impl_GetPrivateData, + IDirect3DVertexBuffer9Impl_FreePrivateData, + IDirect3DVertexBuffer9Impl_SetPriority, + IDirect3DVertexBuffer9Impl_GetPriority, + IDirect3DVertexBuffer9Impl_PreLoad, + IDirect3DVertexBuffer9Impl_GetType, + 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; + + ICOM_THIS(IDirect3DDevice9Impl,iface); + + /* Allocate the storage for the device */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DVertexBuffer9Impl)); + object->lpVtbl = &Direct3DVertexBuffer9_Vtbl; + object->ref = 1; + object->Device = This; + + object->ResourceType = D3DRTYPE_VERTEXBUFFER; + + object->allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, Size); + object->myDesc.Usage = Usage; + object->myDesc.Pool = Pool; + object->myDesc.FVF = FVF; + object->myDesc.Size = Size; + + TRACE("(%p) : Size=%d, Usage=%ld, FVF=%lx, Pool=%d - Memory@%p, Iface@%p\n", This, Size, Usage, FVF, Pool, object->allocatedMemory, object); + + *ppVertexBuffer = (LPDIRECT3DVERTEXBUFFER9) object; + + return D3D_OK; +} diff --git a/dlls/d3d9/vertexdeclaration.c b/dlls/d3d9/vertexdeclaration.c new file mode 100644 index 00000000000..24679f073b4 --- /dev/null +++ b/dlls/d3d9/vertexdeclaration.c @@ -0,0 +1,113 @@ +/* + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DVertexDeclaration9 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DVertexDeclaration9Impl_QueryInterface(LPDIRECT3DVERTEXDECLARATION9 iface, REFIID riid, LPVOID* ppobj) { + ICOM_THIS(IDirect3DVertexDeclaration9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DVertexDeclaration9)) { + IDirect3DVertexDeclaration9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DVertexDeclaration9Impl_AddRef(LPDIRECT3DVERTEXDECLARATION9 iface) { + ICOM_THIS(IDirect3DVertexDeclaration9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DVertexDeclaration9Impl_Release(LPDIRECT3DVERTEXDECLARATION9 iface) { + ICOM_THIS(IDirect3DVertexDeclaration9Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DVertexDeclaration9 Interface follow: */ +HRESULT WINAPI IDirect3DVertexDeclaration9Impl_GetDevice(LPDIRECT3DVERTEXDECLARATION9 iface, IDirect3DDevice9** ppDevice) { + ICOM_THIS(IDirect3DVertexDeclaration9Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE9) This->Device; + IDirect3DDevice9Impl_AddRef(*ppDevice); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DVertexDeclaration9Impl_GetDeclaration(LPDIRECT3DVERTEXDECLARATION9 iface, D3DVERTEXELEMENT9* pDecl, UINT* pNumElements) { + ICOM_THIS(IDirect3DVertexDeclaration9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DVertexDeclaration9) Direct3DVertexDeclaration9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DVertexDeclaration9Impl_QueryInterface, + IDirect3DVertexDeclaration9Impl_AddRef, + IDirect3DVertexDeclaration9Impl_Release, + IDirect3DVertexDeclaration9Impl_GetDevice, + IDirect3DVertexDeclaration9Impl_GetDeclaration +}; + + +/* IDirect3DDevice9 IDirect3DVertexDeclaration9 Methods follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_CreateVertexDeclaration(LPDIRECT3DDEVICE9 iface, CONST D3DVERTEXELEMENT9* pVertexElements, IDirect3DVertexDeclaration9** ppDecl) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetVertexDeclaration(LPDIRECT3DDEVICE9 iface, IDirect3DVertexDeclaration9* pDecl) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetVertexDeclaration(LPDIRECT3DDEVICE9 iface, IDirect3DVertexDeclaration9** ppDecl) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} diff --git a/dlls/d3d9/vertexshader.c b/dlls/d3d9/vertexshader.c new file mode 100644 index 00000000000..38bedef8260 --- /dev/null +++ b/dlls/d3d9/vertexshader.c @@ -0,0 +1,242 @@ +/* + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader); + +/* IDirect3DVertexShader9 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DVertexShader9Impl_QueryInterface(LPDIRECT3DVERTEXSHADER9 iface, REFIID riid, LPVOID* ppobj) { + ICOM_THIS(IDirect3DVertexShader9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DVertexShader9)) { + IDirect3DVertexShader9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DVertexShader9Impl_AddRef(LPDIRECT3DVERTEXSHADER9 iface) { + ICOM_THIS(IDirect3DVertexShader9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DVertexShader9Impl_Release(LPDIRECT3DVERTEXSHADER9 iface) { + ICOM_THIS(IDirect3DVertexShader9Impl,iface); + ULONG ref = --This->ref; + + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DVertexShader9 Interface follow: */ +HRESULT WINAPI IDirect3DVertexShader9Impl_GetDevice(LPDIRECT3DVERTEXSHADER9 iface, IDirect3DDevice9** ppDevice) { + ICOM_THIS(IDirect3DVertexShader9Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE9) This->Device; + IDirect3DDevice9Impl_AddRef(*ppDevice); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DVertexShader9Impl_GetFunction(LPDIRECT3DVERTEXSHADER9 iface, VOID* pData, UINT* pSizeOfData) { + ICOM_THIS(IDirect3DVertexShader9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DVertexShader9) Direct3DVertexShader9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DVertexShader9Impl_QueryInterface, + IDirect3DVertexShader9Impl_AddRef, + IDirect3DVertexShader9Impl_Release, + IDirect3DVertexShader9Impl_GetDevice, + IDirect3DVertexShader9Impl_GetFunction +}; + + +/* IDirect3DDevice9 IDirect3DVertexShader9 Methods follow: */ +HRESULT WINAPI IDirect3DDevice9Impl_CreateVertexShader(LPDIRECT3DDEVICE9 iface, CONST DWORD* pFunction, IDirect3DVertexShader9** ppShader) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetVertexShader(LPDIRECT3DDEVICE9 iface, IDirect3DVertexShader9* pShader) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + + This->UpdateStateBlock->VertexShader = pShader; + This->UpdateStateBlock->Changed.vertexShader = TRUE; + This->UpdateStateBlock->Set.vertexShader = TRUE; + + /* Handle recording of state blocks */ + if (This->isRecordingState) { + TRACE("Recording... not performing anything\n"); + return D3D_OK; + } + /** + * TODO: merge HAL shaders context switching from prototype + */ + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetVertexShader(LPDIRECT3DDEVICE9 iface, IDirect3DVertexShader9** ppShader) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + TRACE("(%p) : GetVertexShader returning %p\n", This, This->StateBlock->VertexShader); + *ppShader = This->StateBlock->VertexShader; + IDirect3DVertexShader9Impl_AddRef(*ppShader); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetVertexShaderConstantF(LPDIRECT3DDEVICE9 iface, UINT Register, CONST float* pConstantData, UINT Vector4fCount) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + + if (Register + Vector4fCount > D3D_VSHADER_MAX_CONSTANTS) { + ERR("(%p) : SetVertexShaderConstant C[%u] invalid\n", This, Register); + return D3DERR_INVALIDCALL; + } + if (NULL == pConstantData) { + return D3DERR_INVALIDCALL; + } + if (Vector4fCount > 1) { + CONST FLOAT* f = pConstantData; + UINT i; + TRACE("(%p) : SetVertexShaderConstant C[%u..%u]=\n", This, Register, Register + Vector4fCount - 1); + for (i = 0; i < Vector4fCount; ++i) { + TRACE("{%f, %f, %f, %f}\n", f[0], f[1], f[2], f[3]); + f += 4; + } + } else { + FLOAT* f = (FLOAT*) pConstantData; + TRACE("(%p) : SetVertexShaderConstant, C[%u]={%f, %f, %f, %f}\n", This, Register, f[0], f[1], f[2], f[3]); + } + This->UpdateStateBlock->Changed.vertexShaderConstant = TRUE; + memcpy(&This->UpdateStateBlock->vertexShaderConstantF[Register], pConstantData, Vector4fCount * 4 * sizeof(FLOAT)); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetVertexShaderConstantF(LPDIRECT3DDEVICE9 iface, UINT Register, float* pConstantData, UINT Vector4fCount) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + + TRACE("(%p) : C[%u] count=%u\n", This, Register, Vector4fCount); + if (Register + Vector4fCount > D3D_VSHADER_MAX_CONSTANTS) { + return D3DERR_INVALIDCALL; + } + if (NULL == pConstantData) { + return D3DERR_INVALIDCALL; + } + memcpy(pConstantData, &This->UpdateStateBlock->vertexShaderConstantF[Register], Vector4fCount * 4 * sizeof(FLOAT)); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetVertexShaderConstantI(LPDIRECT3DDEVICE9 iface, UINT Register, CONST int* pConstantData, UINT Vector4iCount) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + + if (Register + Vector4iCount > D3D_VSHADER_MAX_CONSTANTS) { + ERR("(%p) : SetVertexShaderConstantI C[%u] invalid\n", This, Register); + return D3DERR_INVALIDCALL; + } + if (NULL == pConstantData) { + return D3DERR_INVALIDCALL; + } + if (Vector4iCount > 1) { + CONST int* f = pConstantData; + UINT i; + TRACE("(%p) : SetVertexShaderConstantI C[%u..%u]=\n", This, Register, Register + Vector4iCount - 1); + for (i = 0; i < Vector4iCount; ++i) { + TRACE("{%d, %d, %d, %d}\n", f[0], f[1], f[2], f[3]); + f += 4; + } + } else { + CONST int* f = pConstantData; + TRACE("(%p) : SetVertexShaderConstantI, C[%u]={%i, %i, %i, %i}\n", This, Register, f[0], f[1], f[2], f[3]); + } + This->UpdateStateBlock->Changed.vertexShaderConstant = TRUE; + memcpy(&This->UpdateStateBlock->vertexShaderConstantI[Register], pConstantData, Vector4iCount * 4 * sizeof(int)); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetVertexShaderConstantI(LPDIRECT3DDEVICE9 iface, UINT Register, int* pConstantData, UINT Vector4iCount) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + + TRACE("(%p) : C[%u] count=%u\n", This, Register, Vector4iCount); + if (Register + Vector4iCount > D3D_VSHADER_MAX_CONSTANTS) { + return D3DERR_INVALIDCALL; + } + if (NULL == pConstantData) { + return D3DERR_INVALIDCALL; + } + memcpy(pConstantData, &This->UpdateStateBlock->vertexShaderConstantI[Register], Vector4iCount * 4 * sizeof(FLOAT)); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetVertexShaderConstantB(LPDIRECT3DDEVICE9 iface, UINT Register, CONST BOOL* pConstantData, UINT BoolCount) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + UINT i; + + if (Register + BoolCount > D3D_VSHADER_MAX_CONSTANTS) { + ERR("(%p) : SetVertexShaderConstantB C[%u] invalid\n", This, Register); + return D3DERR_INVALIDCALL; + } + if (NULL == pConstantData) { + return D3DERR_INVALIDCALL; + } + if (BoolCount > 1) { + CONST BOOL* f = pConstantData; + TRACE("(%p) : SetVertexShaderConstantB C[%u..%u]=\n", This, Register, Register + BoolCount - 1); + for (i = 0; i < BoolCount; ++i) { + TRACE("{%u}\n", f[i]); + } + } else { + CONST BOOL* f = pConstantData; + TRACE("(%p) : SetVertexShaderConstantB, C[%u]={%u}\n", This, Register, f[0]); + } + This->UpdateStateBlock->Changed.vertexShaderConstant = TRUE; + for (i = 0; i < BoolCount; ++i) { + This->UpdateStateBlock->vertexShaderConstantB[Register] = pConstantData[i]; + } + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetVertexShaderConstantB(LPDIRECT3DDEVICE9 iface, UINT Register, BOOL* pConstantData, UINT BoolCount) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} diff --git a/dlls/d3d9/volume.c b/dlls/d3d9/volume.c new file mode 100644 index 00000000000..677a227f4fe --- /dev/null +++ b/dlls/d3d9/volume.c @@ -0,0 +1,141 @@ +/* + * IDirect3DVolume9 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DVolume9 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DVolume9Impl_QueryInterface(LPDIRECT3DVOLUME9 iface, REFIID riid, LPVOID* ppobj) { + ICOM_THIS(IDirect3DVolume9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DVolume9)) { + IDirect3DVolume9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DVolume9Impl_AddRef(LPDIRECT3DVOLUME9 iface) { + ICOM_THIS(IDirect3DVolume9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DVolume9Impl_Release(LPDIRECT3DVOLUME9 iface) { + ICOM_THIS(IDirect3DVolume9Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + HeapFree(GetProcessHeap(), 0, This->allocatedMemory); + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DVolume9 Interface follow: */ +HRESULT WINAPI IDirect3DVolume9Impl_GetDevice(LPDIRECT3DVOLUME9 iface, IDirect3DDevice9** ppDevice) { + ICOM_THIS(IDirect3DVolume9Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE9) This->Device; + + /* Note Calling this method will increase the internal reference count + on the IDirect3DDevice9 interface. */ + IDirect3DDevice9Impl_AddRef(*ppDevice); + + return D3D_OK; +} + +HRESULT WINAPI IDirect3DVolume9Impl_SetPrivateData(LPDIRECT3DVOLUME9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DVolume9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DVolume9Impl_GetPrivateData(LPDIRECT3DVOLUME9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DVolume9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DVolume9Impl_FreePrivateData(LPDIRECT3DVOLUME9 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DVolume9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DVolume9Impl_GetContainer(LPDIRECT3DVOLUME9 iface, REFIID riid, void** ppContainer) { + ICOM_THIS(IDirect3DVolume9Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Container); + *ppContainer = This->Container; + IUnknown_AddRef(This->Container); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DVolume9Impl_GetDesc(LPDIRECT3DVOLUME9 iface, D3DVOLUME_DESC* pDesc) { + ICOM_THIS(IDirect3DVolume9Impl,iface); + TRACE("(%p) : copying into %p\n", This, pDesc); + memcpy(pDesc, &This->myDesc, sizeof(D3DVOLUME_DESC)); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DVolume9Impl_LockBox(LPDIRECT3DVOLUME9 iface, D3DLOCKED_BOX* pLockedVolume, CONST D3DBOX* pBox, DWORD Flags) { + ICOM_THIS(IDirect3DVolume9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DVolume9Impl_UnlockBox(LPDIRECT3DVOLUME9 iface) { + ICOM_THIS(IDirect3DVolume9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DVolume9) Direct3DVolume9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DVolume9Impl_QueryInterface, + IDirect3DVolume9Impl_AddRef, + IDirect3DVolume9Impl_Release, + IDirect3DVolume9Impl_GetDevice, + IDirect3DVolume9Impl_SetPrivateData, + IDirect3DVolume9Impl_GetPrivateData, + IDirect3DVolume9Impl_FreePrivateData, + IDirect3DVolume9Impl_GetContainer, + IDirect3DVolume9Impl_GetDesc, + IDirect3DVolume9Impl_LockBox, + IDirect3DVolume9Impl_UnlockBox +}; diff --git a/dlls/d3d9/volumetexture.c b/dlls/d3d9/volumetexture.c new file mode 100644 index 00000000000..c0e2e64efbd --- /dev/null +++ b/dlls/d3d9/volumetexture.c @@ -0,0 +1,255 @@ +/* + * IDirect3DVolumeTexture9 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DVolumeTexture9 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DVolumeTexture9Impl_QueryInterface(LPDIRECT3DVOLUMETEXTURE9 iface, REFIID riid, LPVOID* ppobj) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IDirect3DResource9) + || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9) + || IsEqualGUID(riid, &IID_IDirect3DVolumeTexture9)) { + IDirect3DVolumeTexture9Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DVolumeTexture9Impl_AddRef(LPDIRECT3DVOLUMETEXTURE9 iface) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DVolumeTexture9Impl_Release(LPDIRECT3DVOLUMETEXTURE9 iface) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + ULONG ref = --This->ref; + UINT i; + + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + for (i = 0; i < This->levels; i++) { + if (This->volumes[i] != NULL) { + TRACE("(%p) : Releasing volume %p\n", This, This->volumes[i]); + IDirect3DVolume9Impl_Release((LPDIRECT3DVOLUME9) This->volumes[i]); + } + } + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DVolumeTexture9 IDirect3DResource9 Interface follow: */ +HRESULT WINAPI IDirect3DVolumeTexture9Impl_GetDevice(LPDIRECT3DVOLUMETEXTURE9 iface, IDirect3DDevice9** ppDevice) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + return IDirect3DResource9Impl_GetDevice((LPDIRECT3DRESOURCE9) This, ppDevice); +} + +HRESULT WINAPI IDirect3DVolumeTexture9Impl_SetPrivateData(LPDIRECT3DVOLUMETEXTURE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DVolumeTexture9Impl_GetPrivateData(LPDIRECT3DVOLUMETEXTURE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DVolumeTexture9Impl_FreePrivateData(LPDIRECT3DVOLUMETEXTURE9 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +DWORD WINAPI IDirect3DVolumeTexture9Impl_SetPriority(LPDIRECT3DVOLUMETEXTURE9 iface, DWORD PriorityNew) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + return IDirect3DResource9Impl_SetPriority((LPDIRECT3DRESOURCE9) This, PriorityNew); +} + +DWORD WINAPI IDirect3DVolumeTexture9Impl_GetPriority(LPDIRECT3DVOLUMETEXTURE9 iface) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + return IDirect3DResource9Impl_GetPriority((LPDIRECT3DRESOURCE9) This); +} + +void WINAPI IDirect3DVolumeTexture9Impl_PreLoad(LPDIRECT3DVOLUMETEXTURE9 iface) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return ; +} + +D3DRESOURCETYPE WINAPI IDirect3DVolumeTexture9Impl_GetType(LPDIRECT3DVOLUMETEXTURE9 iface) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + return IDirect3DResource9Impl_GetType((LPDIRECT3DRESOURCE9) This); +} + +/* IDirect3DVolumeTexture9 IDirect3DBaseTexture9 Interface follow: */ +DWORD WINAPI IDirect3DVolumeTexture9Impl_SetLOD(LPDIRECT3DVOLUMETEXTURE9 iface, DWORD LODNew) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + return IDirect3DBaseTexture9Impl_SetLOD((LPDIRECT3DBASETEXTURE9) This, LODNew); +} + +DWORD WINAPI IDirect3DVolumeTexture9Impl_GetLOD(LPDIRECT3DVOLUMETEXTURE9 iface) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + return IDirect3DBaseTexture9Impl_GetLOD((LPDIRECT3DBASETEXTURE9) This); +} + +DWORD WINAPI IDirect3DVolumeTexture9Impl_GetLevelCount(LPDIRECT3DVOLUMETEXTURE9 iface) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + return IDirect3DBaseTexture9Impl_GetLevelCount((LPDIRECT3DBASETEXTURE9) This); +} + +HRESULT WINAPI IDirect3DVolumeTexture9Impl_SetAutoGenFilterType(LPDIRECT3DVOLUMETEXTURE9 iface, D3DTEXTUREFILTERTYPE FilterType) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + return IDirect3DBaseTexture9Impl_SetAutoGenFilterType((LPDIRECT3DBASETEXTURE9) This, FilterType); +} + +D3DTEXTUREFILTERTYPE WINAPI IDirect3DVolumeTexture9Impl_GetAutoGenFilterType(LPDIRECT3DVOLUMETEXTURE9 iface) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + return IDirect3DBaseTexture9Impl_GetAutoGenFilterType((LPDIRECT3DBASETEXTURE9) This); +} + +void WINAPI IDirect3DVolumeTexture9Impl_GenerateMipSubLevels(LPDIRECT3DVOLUMETEXTURE9 iface) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + return ; +} + +/* IDirect3DVolumeTexture9 Interface follow: */ +HRESULT WINAPI IDirect3DVolumeTexture9Impl_GetLevelDesc(LPDIRECT3DVOLUMETEXTURE9 iface, UINT Level, D3DVOLUME_DESC* pDesc) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + if (Level < This->levels) { + TRACE("(%p) Level (%d)\n", This, Level); + return IDirect3DVolume9Impl_GetDesc((LPDIRECT3DVOLUME9) This->volumes[Level], pDesc); + } else { + FIXME("(%p) level(%d) overflow Levels(%d)\n", This, Level, This->levels); + return D3DERR_INVALIDCALL; + } + return D3D_OK; +} + +HRESULT WINAPI IDirect3DVolumeTexture9Impl_GetVolumeLevel(LPDIRECT3DVOLUMETEXTURE9 iface, UINT Level, IDirect3DVolume9** ppVolumeLevel) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + if (Level < This->levels) { + *ppVolumeLevel = (LPDIRECT3DVOLUME9) This->volumes[Level]; + IDirect3DVolume9Impl_AddRef((LPDIRECT3DVOLUME9) *ppVolumeLevel); + TRACE("(%p) -> level(%d) returning volume@%p\n", This, Level, *ppVolumeLevel); + } else { + FIXME("(%p) Level(%d) overflow Levels(%d)\n", This, Level, This->levels); + return D3DERR_INVALIDCALL; + } + return D3D_OK; + +} +HRESULT WINAPI IDirect3DVolumeTexture9Impl_LockBox(LPDIRECT3DVOLUMETEXTURE9 iface, UINT Level, D3DLOCKED_BOX* pLockedVolume, CONST D3DBOX* pBox, DWORD Flags) { + HRESULT hr; + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + if (Level < This->levels) { + /** + * Not dirtified while Surfaces don't notify dirtification + * This->Dirty = TRUE; + */ + hr = IDirect3DVolume9Impl_LockBox((LPDIRECT3DVOLUME9) This->volumes[Level], pLockedVolume, pBox, Flags); + TRACE("(%p) Level (%d) success(%lu)\n", This, Level, hr); + } else { + FIXME("(%p) level(%d) overflow Levels(%d)\n", This, Level, This->levels); + return D3DERR_INVALIDCALL; + } + return hr; +} + +HRESULT WINAPI IDirect3DVolumeTexture9Impl_UnlockBox(LPDIRECT3DVOLUMETEXTURE9 iface, UINT Level) { + HRESULT hr; + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + if (Level < This->levels) { + hr = IDirect3DVolume9Impl_UnlockBox((LPDIRECT3DVOLUME9) This->volumes[Level]); + TRACE("(%p) -> level(%d) success(%lu)\n", This, Level, hr); + } else { + FIXME("(%p) level(%d) overflow Levels(%d)\n", This, Level, This->levels); + return D3DERR_INVALIDCALL; + } + return hr; +} + +HRESULT WINAPI IDirect3DVolumeTexture9Impl_AddDirtyBox(LPDIRECT3DVOLUMETEXTURE9 iface, CONST D3DBOX* pDirtyBox) { + ICOM_THIS(IDirect3DVolumeTexture9Impl,iface); + FIXME("(%p) : stub\n", This); + This->Dirty = TRUE; + return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DVolumeTexture9) Direct3DVolumeTexture9_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DVolumeTexture9Impl_QueryInterface, + IDirect3DVolumeTexture9Impl_AddRef, + IDirect3DVolumeTexture9Impl_Release, + IDirect3DVolumeTexture9Impl_GetDevice, + IDirect3DVolumeTexture9Impl_SetPrivateData, + IDirect3DVolumeTexture9Impl_GetPrivateData, + IDirect3DVolumeTexture9Impl_FreePrivateData, + IDirect3DVolumeTexture9Impl_SetPriority, + IDirect3DVolumeTexture9Impl_GetPriority, + IDirect3DVolumeTexture9Impl_PreLoad, + IDirect3DVolumeTexture9Impl_GetType, + IDirect3DVolumeTexture9Impl_SetLOD, + IDirect3DVolumeTexture9Impl_GetLOD, + IDirect3DVolumeTexture9Impl_GetLevelCount, + IDirect3DVolumeTexture9Impl_SetAutoGenFilterType, + IDirect3DVolumeTexture9Impl_GetAutoGenFilterType, + IDirect3DVolumeTexture9Impl_GenerateMipSubLevels, + 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) { + + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} diff --git a/dlls/d3d9/vshaderdeclaration.c b/dlls/d3d9/vshaderdeclaration.c new file mode 100644 index 00000000000..34139361229 --- /dev/null +++ b/dlls/d3d9/vshaderdeclaration.c @@ -0,0 +1,83 @@ +/* + * vertex declaration implementation + * + * Copyright 2002-2003 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include + +#include "d3d9_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader); + +/** + * DirectX9 SDK download + * http://msdn.microsoft.com/library/default.asp?url=/downloads/list/directx.asp + * + * Exploring D3DX + * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndrive/html/directx07162002.asp + * + * Using Vertex Shaders + * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndrive/html/directx02192001.asp + * + * Dx9 New + * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/whatsnew.asp + * + * Dx9 Shaders + * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/VertexShader2_0/VertexShader2_0.asp + * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/VertexShader2_0/Instructions/Instructions.asp + * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/programmingguide/GettingStarted/VertexDeclaration/VertexDeclaration.asp + * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/VertexShader3_0/VertexShader3_0.asp + * + * Dx9 D3DX + * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/programmingguide/advancedtopics/VertexPipe/matrixstack/matrixstack.asp + * + * FVF + * http://msdn.microsoft.com/library/en-us/directx9_c/directx/graphics/programmingguide/GettingStarted/VertexFormats/vformats.asp + * + * NVIDIA: DX8 Vertex Shader to NV Vertex Program + * http://developer.nvidia.com/view.asp?IO=vstovp + * + * NVIDIA: Memory Management with VAR + * http://developer.nvidia.com/view.asp?IO=var_memory_management + */ + +HRESULT WINAPI IDirect3DDevice9Impl_CreateVertexDeclaration(LPDIRECT3DDEVICE9 iface, CONST D3DVERTEXELEMENT9* pVertexElements, IDirect3DVertexDeclaration9** ppDecl) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_SetVertexDeclaration(LPDIRECT3DDEVICE9 iface, IDirect3DVertexDeclaration9* pDecl) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice9Impl_GetVertexDeclaration(LPDIRECT3DDEVICE9 iface, IDirect3DVertexDeclaration9** ppDecl) { + ICOM_THIS(IDirect3DDevice9Impl,iface); + FIXME("(%p) : stub\n", This); + return D3D_OK; +} diff --git a/include/d3d8.h b/include/d3d8.h index 2369cbbb110..58df5acf4d0 100644 --- a/include/d3d8.h +++ b/include/d3d8.h @@ -19,6 +19,10 @@ #ifndef __WINE_D3D8_H #define __WINE_D3D8_H +#ifndef DIRECT3D_VERSION +#define DIRECT3D_VERSION 0x0800 +#endif + #include "objbase.h" #include "d3d8types.h" diff --git a/include/d3d9.h b/include/d3d9.h index e1823a08859..3c3c9a45c8f 100644 --- a/include/d3d9.h +++ b/include/d3d9.h @@ -501,51 +501,6 @@ ICOM_DEFINE(IDirect3DSwapChain9,IUnknown) #define IDirect3DSwapChain9_GetPresentParameters(p,a) (p)->lpVtbl->GetPresentParameters(p,a) #endif -/***************************************************************************** - * IDirect3DSurface9 interface - */ -#define INTERFACE IDirect3DSurface9 -#define IDirect3DSurface9_METHODS \ - IUnknown_METHODS \ - STDMETHOD(GetDevice)(THIS_ IDirect3DDevice9** ppDevice) PURE; \ - STDMETHOD(SetPrivateData)(THIS_ REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) PURE; \ - STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid, void* pData, DWORD* pSizeOfData) PURE; \ - STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE; \ - STDMETHOD_(DWORD, SetPriority)(THIS_ DWORD PriorityNew) PURE; \ - STDMETHOD_(DWORD, GetPriority)(THIS) PURE; \ - STDMETHOD_(void, PreLoad)(THIS) PURE; \ - STDMETHOD_(D3DRESOURCETYPE, GetType)(THIS) PURE; \ - STDMETHOD(GetContainer)(THIS_ REFIID riid, void** ppContainer) PURE; \ - STDMETHOD(GetDesc)(THIS_ D3DSURFACE_DESC* pDesc) PURE; \ - STDMETHOD(LockRect)(THIS_ D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) PURE; \ - STDMETHOD(UnlockRect)(THIS) PURE; \ - STDMETHOD(GetDC)(THIS_ HDC* phdc) PURE; \ - STDMETHOD(ReleaseDC)(THIS_ HDC hdc) PURE; -ICOM_DEFINE(IDirect3DSurface9,IUnknown) -#undef INTERFACE - -#ifdef COBJMACROS -/*** IUnknown methods ***/ -#define IDirect3DSurface9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IDirect3DSurface9_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IDirect3DSurface9_Release(p) (p)->lpVtbl->Release(p) -/*** IDirect3DSurface9 methods ***/ -#define IDirect3DSurface9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) -#define IDirect3DSurface9_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) -#define IDirect3DSurface9_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) -#define IDirect3DSurface9_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) -#define IDirect3DSurface9_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) -#define IDirect3DSurface9_GetPriority(p) (p)->lpVtbl->GetPriority(p) -#define IDirect3DSurface9_PreLoad(p) (p)->lpVtbl->PreLoad(p) -#define IDirect3DSurface9_GetType(p) (p)->lpVtbl->GetType(p) -#define IDirect3DSurface9_GetContainer(p,a,b) (p)->lpVtbl->GetContainer(p,a,b) -#define IDirect3DSurface9_GetDesc(p,a) (p)->lpVtbl->GetDesc(p,a) -#define IDirect3DSurface9_LockRect(p,a,b,c) (p)->lpVtbl->LockRect(p,a,b,c) -#define IDirect3DSurface9_UnlockRect(p) (p)->lpVtbl->UnlockRect(p) -#define IDirect3DSurface9_GetDC(p,a) (p)->lpVtbl->GetDC(p,a) -#define IDirect3DSurface9_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a) -#endif - /***************************************************************************** * IDirect3DResource9 interface */ @@ -579,6 +534,44 @@ ICOM_DEFINE(IDirect3DResource9,IUnknown) #define IDirect3DResource9_GetType(p) (p)->lpVtbl->GetType(p) #endif +/***************************************************************************** + * IDirect3DSurface9 interface + */ +#define INTERFACE IDirect3DSurface9 +#define IDirect3DSurface9_METHODS \ + IDirect3DResource9_METHODS \ + STDMETHOD(GetContainer)(THIS_ REFIID riid, void** ppContainer) PURE; \ + STDMETHOD(GetDesc)(THIS_ D3DSURFACE_DESC* pDesc) PURE; \ + STDMETHOD(LockRect)(THIS_ D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) PURE; \ + STDMETHOD(UnlockRect)(THIS) PURE; \ + STDMETHOD(GetDC)(THIS_ HDC* phdc) PURE; \ + STDMETHOD(ReleaseDC)(THIS_ HDC hdc) PURE; +ICOM_DEFINE(IDirect3DSurface9,IDirect3DResource9) +#undef INTERFACE + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IDirect3DSurface9_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DSurface9_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DSurface9_Release(p) (p)->lpVtbl->Release(p) +/*** IDirect3DSurface9 methods: IDirect3DResource9 ***/ +#define IDirect3DSurface9_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IDirect3DSurface9_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirect3DSurface9_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirect3DSurface9_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirect3DSurface9_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirect3DSurface9_GetPriority(p) (p)->lpVtbl->GetPriority(p) +#define IDirect3DSurface9_PreLoad(p) (p)->lpVtbl->PreLoad(p) +#define IDirect3DSurface9_GetType(p) (p)->lpVtbl->GetType(p) +/*** IDirect3DSurface9 methods ***/ +#define IDirect3DSurface9_GetContainer(p,a,b) (p)->lpVtbl->GetContainer(p,a,b) +#define IDirect3DSurface9_GetDesc(p,a) (p)->lpVtbl->GetDesc(p,a) +#define IDirect3DSurface9_LockRect(p,a,b,c) (p)->lpVtbl->LockRect(p,a,b,c) +#define IDirect3DSurface9_UnlockRect(p) (p)->lpVtbl->UnlockRect(p) +#define IDirect3DSurface9_GetDC(p,a) (p)->lpVtbl->GetDC(p,a) +#define IDirect3DSurface9_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a) +#endif + /***************************************************************************** * IDirect3DVertexBuffer9 interface */ @@ -773,10 +766,10 @@ ICOM_DEFINE(IDirect3DTexture9,IDirect3DBaseTexture9) #define INTERFACE IDirect3DVolumeTexture9 #define IDirect3DVolumeTexture9_METHODS \ IDirect3DBaseTexture9_METHODS \ - STDMETHOD(GetLevelDesc)(THIS_ UINT Level, D3DVOLUME_DESC *pDesc) PURE; - STDMETHOD(GetVolumeLevel)(THIS_ UINT Level, IDirect3DVolume9** ppVolumeLevel) PURE; - STDMETHOD(LockBox)(THIS_ UINT Level, D3DLOCKED_BOX* pLockedVolume, CONST D3DBOX* pBox, DWORD Flags) PURE; - STDMETHOD(UnlockBox)(THIS_ UINT Level) PURE; + STDMETHOD(GetLevelDesc)(THIS_ UINT Level, D3DVOLUME_DESC *pDesc) PURE; \ + STDMETHOD(GetVolumeLevel)(THIS_ UINT Level, IDirect3DVolume9** ppVolumeLevel) PURE; \ + STDMETHOD(LockBox)(THIS_ UINT Level, D3DLOCKED_BOX* pLockedVolume, CONST D3DBOX* pBox, DWORD Flags) PURE; \ + STDMETHOD(UnlockBox)(THIS_ UINT Level) PURE; \ STDMETHOD(AddDirtyBox)(THIS_ CONST D3DBOX* pDirtyBox) PURE; ICOM_DEFINE(IDirect3DVolumeTexture9,IDirect3DBaseTexture9) #undef INTERFACE diff --git a/include/d3d9types.h b/include/d3d9types.h index 48774a1ba40..dfff03962a6 100644 --- a/include/d3d9types.h +++ b/include/d3d9types.h @@ -200,7 +200,7 @@ typedef enum _D3DDECLUSAGE { #define MAXD3DDECLUSAGE D3DDECLUSAGE_SAMPLE #define MAXD3DDECLUSAGEINDEX 15 -#define MAXD3DDECLLENGTH 64 /* does not include "end" marker vertex element */ +#define MAXD3DDECLLENGTH 64 typedef enum _D3DDECLMETHOD { D3DDECLMETHOD_DEFAULT = 0,