From 26258ce06a452c72598e2638662f2482683ef4da Mon Sep 17 00:00:00 2001 From: Jason Edmeades Date: Fri, 27 Sep 2002 22:46:16 +0000 Subject: [PATCH] Initial D3D8 implementation. --- dlls/Makefile.in | 2 +- dlls/d3d8/Makefile.in | 16 +- dlls/d3d8/basetexture.c | 130 ++ dlls/d3d8/cubetexture.c | 182 +++ dlls/d3d8/d3d8.spec | 2 + dlls/d3d8/d3d8_main.c | 36 +- dlls/d3d8/d3d8_private.h | 824 +++++++++++++ dlls/d3d8/device.c | 2928 +++++++++++++++++++++++++++++++++++++++++++++ dlls/d3d8/directx.c | 549 +++++++++ dlls/d3d8/indexbuffer.c | 143 +++ dlls/d3d8/resource.c | 113 ++ dlls/d3d8/surface.c | 148 +++ dlls/d3d8/swapchain.c | 81 ++ dlls/d3d8/texture.c | 188 +++ dlls/d3d8/vertexbuffer.c | 144 +++ dlls/d3d8/volume.c | 115 ++ dlls/d3d8/volumetexture.c | 160 +++ 17 files changed, 5757 insertions(+), 4 deletions(-) create mode 100644 dlls/d3d8/basetexture.c create mode 100644 dlls/d3d8/cubetexture.c create mode 100644 dlls/d3d8/d3d8_private.h create mode 100644 dlls/d3d8/device.c create mode 100644 dlls/d3d8/directx.c create mode 100644 dlls/d3d8/indexbuffer.c create mode 100644 dlls/d3d8/resource.c create mode 100644 dlls/d3d8/surface.c create mode 100644 dlls/d3d8/swapchain.c create mode 100644 dlls/d3d8/texture.c create mode 100644 dlls/d3d8/vertexbuffer.c create mode 100644 dlls/d3d8/volume.c create mode 100644 dlls/d3d8/volumetexture.c diff --git a/dlls/Makefile.in b/dlls/Makefile.in index 20f1a5f8280..b7b653f1851 100644 --- a/dlls/Makefile.in +++ b/dlls/Makefile.in @@ -769,7 +769,7 @@ commdlg: shell32.dll$(DLLEXT) shlwapi.dll$(DLLEXT) comctl32.dll$(DLLEXT) winspo user32.dll$(DLLEXT) gdi32.dll$(DLLEXT) kernel32.dll$(DLLEXT) crtdll: msvcrt.dll$(DLLEXT) kernel32.dll$(DLLEXT) crypt32: advapi32.dll$(DLLEXT) kernel32.dll$(DLLEXT) -d3d8: kernel32.dll$(DLLEXT) +d3d8: user32.dll$(DLLEXT) gdi32.dll$(DLLEXT) kernel32.dll$(DLLEXT) dciman32: kernel32.dll$(DLLEXT) ddraw: user32.dll$(DLLEXT) gdi32.dll$(DLLEXT) kernel32.dll$(DLLEXT) devenum: kernel32.dll$(DLLEXT) diff --git a/dlls/d3d8/Makefile.in b/dlls/d3d8/Makefile.in index 12719487cf3..aadd444d05a 100644 --- a/dlls/d3d8/Makefile.in +++ b/dlls/d3d8/Makefile.in @@ -3,12 +3,26 @@ TOPOBJDIR = ../.. SRCDIR = @srcdir@ VPATH = @srcdir@ MODULE = d3d8.dll +IMPORTS = user32 gdi32 kernel32 +EXTRALIBS = $(LIBUUID) $(X_LIBS) $(XLIB) LDDLLFLAGS = @LDDLLFLAGS@ SYMBOLFILE = $(MODULE).tmp.o C_SRCS = \ - d3d8_main.c + basetexture.c \ + cubetexture.c \ + d3d8_main.c \ + device.c \ + directx.c \ + indexbuffer.c \ + resource.c \ + surface.c \ + swapchain.c \ + texture.c \ + vertexbuffer.c \ + volume.c \ + volumetexture.c \ @MAKE_DLL_RULES@ diff --git a/dlls/d3d8/basetexture.c b/dlls/d3d8/basetexture.c new file mode 100644 index 00000000000..e9def5a750f --- /dev/null +++ b/dlls/d3d8/basetexture.c @@ -0,0 +1,130 @@ +/* + * IDirect3DBaseTexture8 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 "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d8_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DBaseTexture8 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DBaseTexture8Impl_QueryInterface(LPDIRECT3DBASETEXTURE8 iface,REFIID riid,LPVOID *ppobj) +{ + ICOM_THIS(IDirect3DBaseTexture8Impl,iface); + TRACE("(%p) : QueryInterface\n", This); + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IClassFactory)) { + IDirect3DBaseTexture8Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DBaseTexture8Impl_AddRef(LPDIRECT3DBASETEXTURE8 iface) { + ICOM_THIS(IDirect3DBaseTexture8Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DBaseTexture8Impl_Release(LPDIRECT3DBASETEXTURE8 iface) { + ICOM_THIS(IDirect3DBaseTexture8Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) + HeapFree(GetProcessHeap(), 0, This); + return ref; +} + +/* IDirect3DBaseTexture8 IDirect3DResource8 Interface follow: */ +HRESULT WINAPI IDirect3DBaseTexture8Impl_GetDevice(LPDIRECT3DBASETEXTURE8 iface, IDirect3DDevice8** ppDevice) { + ICOM_THIS(IDirect3DBaseTexture8Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE8) This->Device; + return D3D_OK; +} +HRESULT WINAPI IDirect3DBaseTexture8Impl_SetPrivateData(LPDIRECT3DBASETEXTURE8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DBaseTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DBaseTexture8Impl_GetPrivateData(LPDIRECT3DBASETEXTURE8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DBaseTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DBaseTexture8Impl_FreePrivateData(LPDIRECT3DBASETEXTURE8 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DBaseTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DBaseTexture8Impl_SetPriority(LPDIRECT3DBASETEXTURE8 iface, DWORD PriorityNew) { + ICOM_THIS(IDirect3DBaseTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DBaseTexture8Impl_GetPriority(LPDIRECT3DBASETEXTURE8 iface) { + ICOM_THIS(IDirect3DBaseTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +void WINAPI IDirect3DBaseTexture8Impl_PreLoad(LPDIRECT3DBASETEXTURE8 iface) { + ICOM_THIS(IDirect3DBaseTexture8Impl,iface); + FIXME("(%p) : stub\n", This); +} +D3DRESOURCETYPE WINAPI IDirect3DBaseTexture8Impl_GetType(LPDIRECT3DBASETEXTURE8 iface) { + ICOM_THIS(IDirect3DBaseTexture8Impl,iface); + TRACE("(%p) : returning %d\n", This, This->ResourceType); + return This->ResourceType; +} + +/* IDirect3DBaseTexture8 */ +DWORD WINAPI IDirect3DBaseTexture8Impl_SetLOD(LPDIRECT3DBASETEXTURE8 iface, DWORD LODNew) { + ICOM_THIS(IDirect3DBaseTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DBaseTexture8Impl_GetLOD(LPDIRECT3DBASETEXTURE8 iface) { + ICOM_THIS(IDirect3DBaseTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DBaseTexture8Impl_GetLevelCount(LPDIRECT3DBASETEXTURE8 iface) { + ICOM_THIS(IDirect3DBaseTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} + +ICOM_VTABLE(IDirect3DBaseTexture8) Direct3DBaseTexture8_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DBaseTexture8Impl_QueryInterface, + IDirect3DBaseTexture8Impl_AddRef, + IDirect3DBaseTexture8Impl_Release, + IDirect3DBaseTexture8Impl_GetDevice, + IDirect3DBaseTexture8Impl_SetPrivateData, + IDirect3DBaseTexture8Impl_GetPrivateData, + IDirect3DBaseTexture8Impl_FreePrivateData, + IDirect3DBaseTexture8Impl_SetPriority, + IDirect3DBaseTexture8Impl_GetPriority, + IDirect3DBaseTexture8Impl_PreLoad, + IDirect3DBaseTexture8Impl_GetType, + IDirect3DBaseTexture8Impl_SetLOD, + IDirect3DBaseTexture8Impl_GetLOD, + IDirect3DBaseTexture8Impl_GetLevelCount, +}; diff --git a/dlls/d3d8/cubetexture.c b/dlls/d3d8/cubetexture.c new file mode 100644 index 00000000000..1012b1a73b0 --- /dev/null +++ b/dlls/d3d8/cubetexture.c @@ -0,0 +1,182 @@ +/* + * IDirect3DCubeTexture8 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 "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d8_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DCubeTexture8 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DCubeTexture8Impl_QueryInterface(LPDIRECT3DCUBETEXTURE8 iface,REFIID riid,LPVOID *ppobj) +{ + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + TRACE("(%p) : QueryInterface\n", This); + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IClassFactory)) { + IDirect3DCubeTexture8Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DCubeTexture8Impl_AddRef(LPDIRECT3DCUBETEXTURE8 iface) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DCubeTexture8Impl_Release(LPDIRECT3DCUBETEXTURE8 iface) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + ULONG ref = --This->ref; + int i; + + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + for (i=0; ilevels; i++) { + if (This->surfaces[i] != NULL) { + TRACE("(%p) : Releasing surface %p\n", This, This->surfaces[i]); + IDirect3DSurface8Impl_Release((LPDIRECT3DSURFACE8) This->surfaces[i]); + } + } + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DCubeTexture8 IDirect3DResource8 Interface follow: */ +HRESULT WINAPI IDirect3DCubeTexture8Impl_GetDevice(LPDIRECT3DCUBETEXTURE8 iface, IDirect3DDevice8** ppDevice) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE8) This->Device; + return D3D_OK; +} +HRESULT WINAPI IDirect3DCubeTexture8Impl_SetPrivateData(LPDIRECT3DCUBETEXTURE8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DCubeTexture8Impl_GetPrivateData(LPDIRECT3DCUBETEXTURE8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DCubeTexture8Impl_FreePrivateData(LPDIRECT3DCUBETEXTURE8 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DCubeTexture8Impl_SetPriority(LPDIRECT3DCUBETEXTURE8 iface, DWORD PriorityNew) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DCubeTexture8Impl_GetPriority(LPDIRECT3DCUBETEXTURE8 iface) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +void WINAPI IDirect3DCubeTexture8Impl_PreLoad(LPDIRECT3DCUBETEXTURE8 iface) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); +} + +D3DRESOURCETYPE WINAPI IDirect3DCubeTexture8Impl_GetType(LPDIRECT3DCUBETEXTURE8 iface) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + TRACE("(%p) : returning %d\n", This, This->ResourceType); + return This->ResourceType; +} + +/* IDirect3DCubeTexture8 (Inherited from IDirect3DBaseTexture8) */ +DWORD WINAPI IDirect3DCubeTexture8Impl_SetLOD(LPDIRECT3DCUBETEXTURE8 iface, DWORD LODNew) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DCubeTexture8Impl_GetLOD(LPDIRECT3DCUBETEXTURE8 iface) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} + +DWORD WINAPI IDirect3DCubeTexture8Impl_GetLevelCount(LPDIRECT3DCUBETEXTURE8 iface) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + TRACE("(%p) : returning %d\n", This, This->levels); + return This->levels; +} + +/* IDirect3DCubeTexture8 */ +HRESULT WINAPI IDirect3DCubeTexture8Impl_GetLevelDesc(LPDIRECT3DCUBETEXTURE8 iface,UINT Level,D3DSURFACE_DESC *pDesc) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + if (Level < This->levels) { + TRACE("(%p) Level (%d)\n", This, Level); + return IDirect3DSurface8Impl_GetDesc((LPDIRECT3DSURFACE8)This->surfaces[Level], pDesc); + } else { + FIXME("(%p) Level (%d)\n", This, Level); + } + return D3D_OK; +} + +HRESULT WINAPI IDirect3DCubeTexture8Impl_GetCubeMapSurface(LPDIRECT3DCUBETEXTURE8 iface,D3DCUBEMAP_FACES FaceType,UINT Level,IDirect3DSurface8** ppCubeMapSurface) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + TRACE("(%p) : returning %p\n", This, This->surfaces[FaceType][Level]); + *ppCubeMapSurface = (LPDIRECT3DSURFACE8) This->surfaces[FaceType][Level]; + IDirect3DSurface8Impl_AddRef((LPDIRECT3DSURFACE8)This->surfaces[FaceType][Level]); + return D3D_OK; +} +HRESULT WINAPI IDirect3DCubeTexture8Impl_LockRect(LPDIRECT3DCUBETEXTURE8 iface,D3DCUBEMAP_FACES FaceType,UINT Level,D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DCubeTexture8Impl_UnlockRect(LPDIRECT3DCUBETEXTURE8 iface,D3DCUBEMAP_FACES FaceType,UINT Level) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + This->Dirty = TRUE; + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DCubeTexture8Impl_AddDirtyRect(LPDIRECT3DCUBETEXTURE8 iface,D3DCUBEMAP_FACES FaceType,CONST RECT* pDirtyRect) { + ICOM_THIS(IDirect3DCubeTexture8Impl,iface); + This->Dirty = TRUE; + FIXME("(%p) : stub\n", This); return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DCubeTexture8) Direct3DCubeTexture8_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DCubeTexture8Impl_QueryInterface, + IDirect3DCubeTexture8Impl_AddRef, + IDirect3DCubeTexture8Impl_Release, + IDirect3DCubeTexture8Impl_GetDevice, + IDirect3DCubeTexture8Impl_SetPrivateData, + IDirect3DCubeTexture8Impl_GetPrivateData, + IDirect3DCubeTexture8Impl_FreePrivateData, + IDirect3DCubeTexture8Impl_SetPriority, + IDirect3DCubeTexture8Impl_GetPriority, + IDirect3DCubeTexture8Impl_PreLoad, + IDirect3DCubeTexture8Impl_GetType, + IDirect3DCubeTexture8Impl_SetLOD, + IDirect3DCubeTexture8Impl_GetLOD, + IDirect3DCubeTexture8Impl_GetLevelCount, + IDirect3DCubeTexture8Impl_GetLevelDesc, + IDirect3DCubeTexture8Impl_GetCubeMapSurface, + IDirect3DCubeTexture8Impl_LockRect, + IDirect3DCubeTexture8Impl_UnlockRect, + IDirect3DCubeTexture8Impl_AddDirtyRect +}; diff --git a/dlls/d3d8/d3d8.spec b/dlls/d3d8/d3d8.spec index 645eb5602ad..7c6b0c1ffc4 100644 --- a/dlls/d3d8/d3d8.spec +++ b/dlls/d3d8/d3d8.spec @@ -1,3 +1,5 @@ +init D3D8_DllMain + @ stdcall D3D8GetSWInfo() D3D8GetSWInfo @ stdcall DebugSetMute() DebugSetMute @ stdcall Direct3DCreate8(long) Direct3DCreate8 diff --git a/dlls/d3d8/d3d8_main.c b/dlls/d3d8/d3d8_main.c index eaa5816dc1e..68e6fb45bc2 100644 --- a/dlls/d3d8/d3d8_main.c +++ b/dlls/d3d8/d3d8_main.c @@ -18,10 +18,17 @@ #include "windef.h" #include "winbase.h" +#include "wingdi.h" +#include "winuser.h" #include "wine/debug.h" +#include "d3d8_private.h" + WINE_DEFAULT_DEBUG_CHANNEL(d3d); +void (*wine_tsx11_lock_ptr)(void) = NULL; +void (*wine_tsx11_unlock_ptr)(void) = NULL; + HRESULT WINAPI ValidatePixelShader(void) { FIXME("(void): stub\n"); @@ -48,7 +55,32 @@ HRESULT WINAPI DebugSetMute(void) LPVOID WINAPI Direct3DCreate8(UINT SDKVersion) { - FIXME("(0x%08x): stub\n", SDKVersion); - return NULL; + IDirect3D8Impl *object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3D8Impl)); + + object->lpVtbl = &Direct3D8_Vtbl; + object->ref = 1; + + TRACE("SDKVersion = %x, Created Direct3D object at %p\n", SDKVersion, object); + + /* Dump out the gl supported features + TRACE("GL_Extensions reported: %s\n", glGetString(GL_EXTENSIONS)); */ + + return object; +} + +/* At process attach */ +BOOL WINAPI D3D8_DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv) +{ + TRACE("fdwReason=%ld\n", fdwReason); + if (fdwReason == DLL_PROCESS_ATTACH) + { + HMODULE 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; } diff --git a/dlls/d3d8/d3d8_private.h b/dlls/d3d8/d3d8_private.h new file mode 100644 index 00000000000..c89714df576 --- /dev/null +++ b/dlls/d3d8/d3d8_private.h @@ -0,0 +1,824 @@ +/* + * Direct3D 8 private include file + * + * 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 + */ + +#ifndef __WINE_D3DX8_PRIVATE_H +#define __WINE_D3DX8_PRIVATE_H + +/* THIS FILE MUST NOT CONTAIN X11 or MESA DEFINES */ +#include "config.h" +#define XMD_H /* This is to prevent the Xmd.h inclusion bug :-/ */ +#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 "d3d8.h" + +/* Device caps */ +#define MAX_STREAMS 1 +#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 + +/* Direct38 Interfaces: */ +typedef struct IDirect3DBaseTexture8Impl IDirect3DBaseTexture8Impl; +typedef struct IDirect3DVolumeTexture8Impl IDirect3DVolumeTexture8Impl; +typedef struct IDirect3D8Impl IDirect3D8Impl; +typedef struct IDirect3DDevice8Impl IDirect3DDevice8Impl; +typedef struct IDirect3DTexture8Impl IDirect3DTexture8Impl; +typedef struct IDirect3DCubeTexture8Impl IDirect3DCubeTexture8Impl; +typedef struct IDirect3DIndexBuffer8Impl IDirect3DIndexBuffer8Impl; +typedef struct IDirect3DSurface8Impl IDirect3DSurface8Impl; +typedef struct IDirect3DSwapChain8Impl IDirect3DSwapChain8Impl; +typedef struct IDirect3DResource8Impl IDirect3DResource8Impl; +typedef struct IDirect3DVolume8Impl IDirect3DVolume8Impl; +typedef struct IDirect3DVertexBuffer8Impl IDirect3DVertexBuffer8Impl; + +/* 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 pixelShader; + BOOL renderstate[HIGHEST_RENDER_STATE]; + BOOL texture_state[8][HIGHEST_TEXTURE_STATE]; + BOOL clipplane[MAX_CLIPPLANES]; +} SAVEDSTATES; + +typedef struct STATEBLOCK { + + D3DSTATEBLOCKTYPE blockType; + + SAVEDSTATES Changed; + SAVEDSTATES Set; + + /* Light Enable */ + BOOL lightEnable[MAX_ACTIVE_LIGHTS]; + + /* ClipPlane */ + double clipplane[MAX_CLIPPLANES][4]; + + /* Indices */ + IDirect3DIndexBuffer8* pIndexData; + UINT baseVertexIndex; + + /* Lights */ + D3DLIGHT8 lights[MAX_ACTIVE_LIGHTS]; + + /* Material */ + D3DMATERIAL8 material; + + /* Pixel Shader */ + DWORD PixelShader; + + /* TODO: Pixel Shader Constant */ + + /* RenderState */ + DWORD renderstate[HIGHEST_RENDER_STATE]; + + /* Stream Source */ + UINT stream_stride[MAX_STREAMS]; + IDirect3DVertexBuffer8 *stream_source[MAX_STREAMS]; + + /* Texture */ + IDirect3DBaseTexture8 *textures[8]; + + /* Texture State Stage */ + DWORD texture_state[8][HIGHEST_TEXTURE_STATE]; + + /* Transform */ + D3DMATRIX transforms[HIGHEST_TRANSFORMSTATE]; + + /* ViewPort */ + D3DVIEWPORT8 viewport; + + /* Vertex Shader */ + DWORD VertexShader; + + + /* TODO: Vertex Shader Constant */ + +} STATEBLOCK; + +/* + * External prototypes + */ +/*BOOL D3DRAW_HAL_Init(HINSTANCE, DWORD, LPVOID); */ +void CreateStateBlock(LPDIRECT3DDEVICE8 iface); + +/* + * Macros + */ +#define checkGLcall(A) \ +{ \ + GLint err = glGetError(); \ + if (err != GL_NO_ERROR) { \ + FIXME(">>>>>>>>>>>>>>>>> %x from %s @ %s / %d\n", err, A, __FILE__, __LINE__); \ + } else { \ + TRACE("%s call ok %s / %d\n", A, __FILE__, __LINE__); \ + } \ +} + +/* =========================================================================== + The interfactes themselves + =========================================================================== */ + +/* ---------- */ +/* IDirect3D8 */ +/* ---------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3D8) Direct3D8_Vtbl; +extern ICOM_VTABLE(IDirect3D8) mesa_d3d8vt; + +/***************************************************************************** + * IDirect3D implementation structure + */ +struct IDirect3D8Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3D8); + DWORD ref; + + /* IDirect3D8 fields */ +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3D8Impl_QueryInterface(LPDIRECT3D8 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3D8Impl_AddRef(LPDIRECT3D8 iface); +extern ULONG WINAPI IDirect3D8Impl_Release(LPDIRECT3D8 iface); + +/* IDirect3d8:*/ +extern HRESULT WINAPI IDirect3D8Impl_RegisterSoftwareDevice(LPDIRECT3D8 iface, void* pInitializeFunction); +extern UINT WINAPI IDirect3D8Impl_GetAdapterCount(LPDIRECT3D8 iface); +extern HRESULT WINAPI IDirect3D8Impl_GetAdapterIdentifier(LPDIRECT3D8 iface, UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER8* pIdentifier); +extern UINT WINAPI IDirect3D8Impl_GetAdapterModeCount(LPDIRECT3D8 iface, UINT Adapter); +extern HRESULT WINAPI IDirect3D8Impl_EnumAdapterModes(LPDIRECT3D8 iface, UINT Adapter, UINT Mode, D3DDISPLAYMODE* pMode); +extern HRESULT WINAPI IDirect3D8Impl_GetAdapterDisplayMode(LPDIRECT3D8 iface, UINT Adapter, D3DDISPLAYMODE* pMode); +extern HRESULT WINAPI IDirect3D8Impl_CheckDeviceType(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat, + D3DFORMAT BackBufferFormat, BOOL Windowed); +extern HRESULT WINAPI IDirect3D8Impl_CheckDeviceFormat(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, + DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat); +extern HRESULT WINAPI IDirect3D8Impl_CheckDeviceMultiSampleType(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, + BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType); +extern HRESULT WINAPI IDirect3D8Impl_CheckDepthStencilMatch(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, + D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat); +extern HRESULT WINAPI IDirect3D8Impl_GetDeviceCaps(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS8* pCaps); +extern HMONITOR WINAPI IDirect3D8Impl_GetAdapterMonitor(LPDIRECT3D8 iface, UINT Adapter); +extern HRESULT WINAPI IDirect3D8Impl_CreateDevice(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow, + DWORD BehaviorFlags, D3DPRESENT_PARAMETERS* pPresentationParameters, + IDirect3DDevice8** ppReturnedDeviceInterface); +/* --------------------- */ +/* IDirect3DBaseTexture8 */ +/* --------------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DBaseTexture8) Direct3DBaseTexture8_Vtbl; + +/***************************************************************************** + * IDirect3DBaseTexture8 implementation structure + */ +struct IDirect3DBaseTexture8Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DBaseTexture8); + DWORD ref; + + /* IDirect3DBaseTexture8 fields */ + IDirect3DDevice8Impl *Device; + D3DRESOURCETYPE ResourceType; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DBaseTexture8Impl_QueryInterface(LPDIRECT3DBASETEXTURE8 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DBaseTexture8Impl_AddRef(LPDIRECT3DBASETEXTURE8 iface); +extern ULONG WINAPI IDirect3DBaseTexture8Impl_Release(LPDIRECT3DBASETEXTURE8 iface); + +/* IDirect3DBaseTexture8 (Inherited from IDirect3DResource8) */ +extern HRESULT WINAPI IDirect3DBaseTexture8Impl_GetDevice(LPDIRECT3DBASETEXTURE8 iface, IDirect3DDevice8** ppDevice); +extern HRESULT WINAPI IDirect3DBaseTexture8Impl_SetPrivateData(LPDIRECT3DBASETEXTURE8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DBaseTexture8Impl_GetPrivateData(LPDIRECT3DBASETEXTURE8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DBaseTexture8Impl_FreePrivateData(LPDIRECT3DBASETEXTURE8 iface, REFGUID refguid); +extern DWORD WINAPI IDirect3DBaseTexture8Impl_SetPriority(LPDIRECT3DBASETEXTURE8 iface, DWORD PriorityNew); +extern DWORD WINAPI IDirect3DBaseTexture8Impl_GetPriority(LPDIRECT3DBASETEXTURE8 iface); +extern void WINAPI IDirect3DBaseTexture8Impl_PreLoad(LPDIRECT3DBASETEXTURE8 iface); +extern D3DRESOURCETYPE WINAPI IDirect3DBaseTexture8Impl_GetType(LPDIRECT3DBASETEXTURE8 iface); + +/* IDirect3DBaseTexture8 */ +extern DWORD WINAPI IDirect3DBaseTexture8Impl_SetLOD(LPDIRECT3DBASETEXTURE8 iface, DWORD LODNew); +extern DWORD WINAPI IDirect3DBaseTexture8Impl_GetLOD(LPDIRECT3DBASETEXTURE8 iface); +extern DWORD WINAPI IDirect3DBaseTexture8Impl_GetLevelCount(LPDIRECT3DBASETEXTURE8 iface); + +/* ---------------- */ +/* IDirect3DDevice8 */ +/* ---------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DDevice8) Direct3DDevice8_Vtbl; + + +/***************************************************************************** + * IDirect3DDevice8 implementation structure + */ +struct IDirect3DDevice8Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DDevice8); + DWORD ref; + + /* IDirect3DDevice8 fields */ + IDirect3D8Impl *direct3d8; + IDirect3DSurface8Impl *backBuffer; + D3DPRESENT_PARAMETERS PresentParms; + + UINT adapterNo; + D3DDEVTYPE devType; + + UINT srcBlend; + UINT dstBlend; + + /* State block related */ + BOOL isRecordingState; + STATEBLOCK StateBlock; + STATEBLOCK *UpdateStateBlock; + + /* OpenGL related */ + GLXContext glCtx; + XVisualInfo *visInfo; + Display *display; + Window win; + +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DDevice8Impl_QueryInterface(LPDIRECT3DDEVICE8 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DDevice8Impl_AddRef(LPDIRECT3DDEVICE8 iface); +extern ULONG WINAPI IDirect3DDevice8Impl_Release(LPDIRECT3DDEVICE8 iface); + +/* IDirect3DDevice8:*/ +extern HRESULT WINAPI IDirect3DDevice8Impl_TestCooperativeLevel(LPDIRECT3DDEVICE8 iface); +extern UINT WINAPI IDirect3DDevice8Impl_GetAvailableTextureMem(LPDIRECT3DDEVICE8 iface); +extern HRESULT WINAPI IDirect3DDevice8Impl_ResourceManagerDiscardBytes(LPDIRECT3DDEVICE8 iface, DWORD Bytes); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetDirect3D(LPDIRECT3DDEVICE8 iface, IDirect3D8** ppD3D8); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetDeviceCaps(LPDIRECT3DDEVICE8 iface, D3DCAPS8* pCaps); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetDisplayMode(LPDIRECT3DDEVICE8 iface, D3DDISPLAYMODE* pMode); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetCreationParameters(LPDIRECT3DDEVICE8 iface, D3DDEVICE_CREATION_PARAMETERS* pParameters); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetCursorProperties(LPDIRECT3DDEVICE8 iface, UINT XHotSpot, UINT YHotSpot, IDirect3DSurface8* pCursorBitmap); +extern void WINAPI IDirect3DDevice8Impl_SetCursorPosition(LPDIRECT3DDEVICE8 iface, UINT XScreenSpace, UINT YScreenSpace,DWORD Flags); +extern BOOL WINAPI IDirect3DDevice8Impl_ShowCursor(LPDIRECT3DDEVICE8 iface, BOOL bShow); +extern HRESULT WINAPI IDirect3DDevice8Impl_CreateAdditionalSwapChain(LPDIRECT3DDEVICE8 iface, D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain8** pSwapChain); +extern HRESULT WINAPI IDirect3DDevice8Impl_Reset(LPDIRECT3DDEVICE8 iface, D3DPRESENT_PARAMETERS* pPresentationParameters); +extern HRESULT WINAPI IDirect3DDevice8Impl_Present(LPDIRECT3DDEVICE8 iface, CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetBackBuffer(LPDIRECT3DDEVICE8 iface, UINT BackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface8** ppBackBuffer); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetRasterStatus(LPDIRECT3DDEVICE8 iface, D3DRASTER_STATUS* pRasterStatus); +extern void WINAPI IDirect3DDevice8Impl_SetGammaRamp(LPDIRECT3DDEVICE8 iface, DWORD Flags,CONST D3DGAMMARAMP* pRamp); +extern void WINAPI IDirect3DDevice8Impl_GetGammaRamp(LPDIRECT3DDEVICE8 iface, D3DGAMMARAMP* pRamp); +extern HRESULT WINAPI IDirect3DDevice8Impl_CreateTexture(LPDIRECT3DDEVICE8 iface, UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture8** ppTexture); +extern HRESULT WINAPI IDirect3DDevice8Impl_CreateVolumeTexture(LPDIRECT3DDEVICE8 iface, UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture8** ppVolumeTexture); +extern HRESULT WINAPI IDirect3DDevice8Impl_CreateCubeTexture(LPDIRECT3DDEVICE8 iface, UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture8** ppCubeTexture); +extern HRESULT WINAPI IDirect3DDevice8Impl_CreateVertexBuffer(LPDIRECT3DDEVICE8 iface, UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer8** ppVertexBuffer); +extern HRESULT WINAPI IDirect3DDevice8Impl_CreateIndexBuffer(LPDIRECT3DDEVICE8 iface, UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer8** ppIndexBuffer); +extern HRESULT WINAPI IDirect3DDevice8Impl_CreateRenderTarget(LPDIRECT3DDEVICE8 iface, UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,BOOL Lockable,IDirect3DSurface8** ppSurface); +extern HRESULT WINAPI IDirect3DDevice8Impl_CreateDepthStencilSurface(LPDIRECT3DDEVICE8 iface, UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,IDirect3DSurface8** ppSurface); +extern HRESULT WINAPI IDirect3DDevice8Impl_CreateImageSurface(LPDIRECT3DDEVICE8 iface, UINT Width,UINT Height,D3DFORMAT Format,IDirect3DSurface8** ppSurface); +extern HRESULT WINAPI IDirect3DDevice8Impl_CopyRects(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pSourceSurface,CONST RECT* pSourceRectsArray,UINT cRects,IDirect3DSurface8* pDestinationSurface,CONST POINT* pDestPointsArray); +extern HRESULT WINAPI IDirect3DDevice8Impl_UpdateTexture(LPDIRECT3DDEVICE8 iface, IDirect3DBaseTexture8* pSourceTexture,IDirect3DBaseTexture8* pDestinationTexture); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetFrontBuffer(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pDestSurface); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetRenderTarget(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pRenderTarget,IDirect3DSurface8* pNewZStencil); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetRenderTarget(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8** ppRenderTarget); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetDepthStencilSurface(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8** ppZStencilSurface); +extern HRESULT WINAPI IDirect3DDevice8Impl_BeginScene(LPDIRECT3DDEVICE8 iface); +extern HRESULT WINAPI IDirect3DDevice8Impl_EndScene(LPDIRECT3DDEVICE8 iface); +extern HRESULT WINAPI IDirect3DDevice8Impl_Clear(LPDIRECT3DDEVICE8 iface, DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix); +extern HRESULT WINAPI IDirect3DDevice8Impl_MultiplyTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetViewport(LPDIRECT3DDEVICE8 iface, CONST D3DVIEWPORT8* pViewport); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetViewport(LPDIRECT3DDEVICE8 iface, D3DVIEWPORT8* pViewport); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetMaterial(LPDIRECT3DDEVICE8 iface, CONST D3DMATERIAL8* pMaterial); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetMaterial(LPDIRECT3DDEVICE8 iface, D3DMATERIAL8* pMaterial); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetLight(LPDIRECT3DDEVICE8 iface, DWORD Index,CONST D3DLIGHT8* pLight); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetLight(LPDIRECT3DDEVICE8 iface, DWORD Index,D3DLIGHT8* pLight); +extern HRESULT WINAPI IDirect3DDevice8Impl_LightEnable(LPDIRECT3DDEVICE8 iface, DWORD Index,BOOL Enable); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetLightEnable(LPDIRECT3DDEVICE8 iface, DWORD Index,BOOL* pEnable); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetClipPlane(LPDIRECT3DDEVICE8 iface, DWORD Index,CONST float* pPlane); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetClipPlane(LPDIRECT3DDEVICE8 iface, DWORD Index,float* pPlane); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetRenderState(LPDIRECT3DDEVICE8 iface, D3DRENDERSTATETYPE State,DWORD Value); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetRenderState(LPDIRECT3DDEVICE8 iface, D3DRENDERSTATETYPE State,DWORD* pValue); +extern HRESULT WINAPI IDirect3DDevice8Impl_BeginStateBlock(LPDIRECT3DDEVICE8 iface); +extern HRESULT WINAPI IDirect3DDevice8Impl_EndStateBlock(LPDIRECT3DDEVICE8 iface, DWORD* pToken); +extern HRESULT WINAPI IDirect3DDevice8Impl_ApplyStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token); +extern HRESULT WINAPI IDirect3DDevice8Impl_CaptureStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token); +extern HRESULT WINAPI IDirect3DDevice8Impl_DeleteStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token); +extern HRESULT WINAPI IDirect3DDevice8Impl_CreateStateBlock(LPDIRECT3DDEVICE8 iface, D3DSTATEBLOCKTYPE Type,DWORD* pToken); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetClipStatus(LPDIRECT3DDEVICE8 iface, CONST D3DCLIPSTATUS8* pClipStatus); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetClipStatus(LPDIRECT3DDEVICE8 iface, D3DCLIPSTATUS8* pClipStatus); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetTexture(LPDIRECT3DDEVICE8 iface, DWORD Stage,IDirect3DBaseTexture8** ppTexture); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetTexture(LPDIRECT3DDEVICE8 iface, DWORD Stage,IDirect3DBaseTexture8* pTexture); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetTextureStageState(LPDIRECT3DDEVICE8 iface, DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetTextureStageState(LPDIRECT3DDEVICE8 iface, DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value); +extern HRESULT WINAPI IDirect3DDevice8Impl_ValidateDevice(LPDIRECT3DDEVICE8 iface, DWORD* pNumPasses); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetInfo(LPDIRECT3DDEVICE8 iface, DWORD DevInfoID,void* pDevInfoStruct,DWORD DevInfoStructSize); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetPaletteEntries(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber,CONST PALETTEENTRY* pEntries); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetPaletteEntries(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber,PALETTEENTRY* pEntries); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetCurrentTexturePalette(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetCurrentTexturePalette(LPDIRECT3DDEVICE8 iface, UINT *PaletteNumber); +extern HRESULT WINAPI IDirect3DDevice8Impl_DrawPrimitive(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount); +extern HRESULT WINAPI IDirect3DDevice8Impl_DrawIndexedPrimitive(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,UINT minIndex,UINT NumVertices,UINT startIndex,UINT primCount); +extern HRESULT WINAPI IDirect3DDevice8Impl_DrawPrimitiveUP(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride); +extern HRESULT WINAPI IDirect3DDevice8Impl_DrawIndexedPrimitiveUP(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertexIndices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride); +extern HRESULT WINAPI IDirect3DDevice8Impl_ProcessVertices(LPDIRECT3DDEVICE8 iface, UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer8* pDestBuffer,DWORD Flags); +extern HRESULT WINAPI IDirect3DDevice8Impl_CreateVertexShader(LPDIRECT3DDEVICE8 iface, CONST DWORD* pDeclaration,CONST DWORD* pFunction,DWORD* pHandle,DWORD Usage); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShader(LPDIRECT3DDEVICE8 iface, DWORD Handle); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShader(LPDIRECT3DDEVICE8 iface, DWORD* pHandle); +extern HRESULT WINAPI IDirect3DDevice8Impl_DeleteVertexShader(LPDIRECT3DDEVICE8 iface, DWORD Handle); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register,CONST void* pConstantData,DWORD ConstantCount); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register,void* pConstantData,DWORD ConstantCount); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderDeclaration(LPDIRECT3DDEVICE8 iface, DWORD Handle,void* pData,DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderFunction(LPDIRECT3DDEVICE8 iface, DWORD Handle,void* pData,DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetStreamSource(LPDIRECT3DDEVICE8 iface, UINT StreamNumber,IDirect3DVertexBuffer8* pStreamData,UINT Stride); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetStreamSource(LPDIRECT3DDEVICE8 iface, UINT StreamNumber,IDirect3DVertexBuffer8** ppStreamData,UINT* pStride); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetIndices(LPDIRECT3DDEVICE8 iface, IDirect3DIndexBuffer8* pIndexData,UINT BaseVertexIndex); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetIndices(LPDIRECT3DDEVICE8 iface, IDirect3DIndexBuffer8** ppIndexData,UINT* pBaseVertexIndex); +extern HRESULT WINAPI IDirect3DDevice8Impl_CreatePixelShader(LPDIRECT3DDEVICE8 iface, CONST DWORD* pFunction,DWORD* pHandle); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetPixelShader(LPDIRECT3DDEVICE8 iface, DWORD Handle); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShader(LPDIRECT3DDEVICE8 iface, DWORD* pHandle); +extern HRESULT WINAPI IDirect3DDevice8Impl_DeletePixelShader(LPDIRECT3DDEVICE8 iface, DWORD Handle); +extern HRESULT WINAPI IDirect3DDevice8Impl_SetPixelShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register,CONST void* pConstantData,DWORD ConstantCount); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register,void* pConstantData,DWORD ConstantCount); +extern HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShaderFunction(LPDIRECT3DDEVICE8 iface, DWORD Handle,void* pData,DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DDevice8Impl_DrawRectPatch(LPDIRECT3DDEVICE8 iface, UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo); +extern HRESULT WINAPI IDirect3DDevice8Impl_DrawTriPatch(LPDIRECT3DDEVICE8 iface, UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo); +extern HRESULT WINAPI IDirect3DDevice8Impl_DeletePatch(LPDIRECT3DDEVICE8 iface, UINT Handle); + +/* ------------------ */ +/* IDirect3DResource8 */ +/* ------------------ */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DResource8) Direct3DResource8_Vtbl; + +/***************************************************************************** + * IDirect3DResource8 implementation structure + */ +struct IDirect3DResource8Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DResource8); + DWORD ref; + + /* IDirect3DResource8 fields */ + IDirect3DDevice8Impl *Device; + D3DRESOURCETYPE ResourceType; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DResource8Impl_QueryInterface(LPDIRECT3DRESOURCE8 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DResource8Impl_AddRef(LPDIRECT3DRESOURCE8 iface); +extern ULONG WINAPI IDirect3DResource8Impl_Release(LPDIRECT3DRESOURCE8 iface); + +/* IDirect3DResource8 */ +extern HRESULT WINAPI IDirect3DResource8Impl_GetDevice(LPDIRECT3DRESOURCE8 iface, IDirect3DDevice8** ppDevice); +extern HRESULT WINAPI IDirect3DResource8Impl_SetPrivateData(LPDIRECT3DRESOURCE8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DResource8Impl_GetPrivateData(LPDIRECT3DRESOURCE8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DResource8Impl_FreePrivateData(LPDIRECT3DRESOURCE8 iface, REFGUID refguid); +extern DWORD WINAPI IDirect3DResource8Impl_SetPriority(LPDIRECT3DRESOURCE8 iface, DWORD PriorityNew); +extern DWORD WINAPI IDirect3DResource8Impl_GetPriority(LPDIRECT3DRESOURCE8 iface); +extern void WINAPI IDirect3DResource8Impl_PreLoad(LPDIRECT3DRESOURCE8 iface); +extern D3DRESOURCETYPE WINAPI IDirect3DResource8Impl_GetType(LPDIRECT3DRESOURCE8 iface); + +/* ---------------------- */ +/* IDirect3DVertexBuffer8 */ +/* ---------------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DVertexBuffer8) Direct3DVertexBuffer8_Vtbl; + +/***************************************************************************** + * IDirect3DVertexBuffer8 implementation structure + */ +struct IDirect3DVertexBuffer8Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DVertexBuffer8); + DWORD ref; + + /* IDirect3DVertexBuffer8 fields */ + IDirect3DDevice8Impl *Device; + D3DRESOURCETYPE ResourceType; + BYTE *allocatedMemory; + D3DVERTEXBUFFER_DESC currentDesc; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DVertexBuffer8Impl_QueryInterface(LPDIRECT3DVERTEXBUFFER8 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DVertexBuffer8Impl_AddRef(LPDIRECT3DVERTEXBUFFER8 iface); +extern ULONG WINAPI IDirect3DVertexBuffer8Impl_Release(LPDIRECT3DVERTEXBUFFER8 iface); + +/* IDirect3DVertexBuffer8 (Inherited from IDirect3DResource8) */ +extern HRESULT WINAPI IDirect3DVertexBuffer8Impl_GetDevice(LPDIRECT3DVERTEXBUFFER8 iface, IDirect3DDevice8** ppDevice); +extern HRESULT WINAPI IDirect3DVertexBuffer8Impl_SetPrivateData(LPDIRECT3DVERTEXBUFFER8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DVertexBuffer8Impl_GetPrivateData(LPDIRECT3DVERTEXBUFFER8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DVertexBuffer8Impl_FreePrivateData(LPDIRECT3DVERTEXBUFFER8 iface, REFGUID refguid); +extern DWORD WINAPI IDirect3DVertexBuffer8Impl_SetPriority(LPDIRECT3DVERTEXBUFFER8 iface, DWORD PriorityNew); +extern DWORD WINAPI IDirect3DVertexBuffer8Impl_GetPriority(LPDIRECT3DVERTEXBUFFER8 iface); +extern void WINAPI IDirect3DVertexBuffer8Impl_PreLoad(LPDIRECT3DVERTEXBUFFER8 iface); +extern D3DRESOURCETYPE WINAPI IDirect3DVertexBuffer8Impl_GetType(LPDIRECT3DVERTEXBUFFER8 iface); + +/* IDirect3DVertexBuffer8 */ +extern HRESULT WINAPI IDirect3DVertexBuffer8Impl_Lock(LPDIRECT3DVERTEXBUFFER8 iface, UINT OffsetToLock, UINT SizeToLock, BYTE** ppbData, DWORD Flags); +extern HRESULT WINAPI IDirect3DVertexBuffer8Impl_Unlock(LPDIRECT3DVERTEXBUFFER8 iface); +extern HRESULT WINAPI IDirect3DVertexBuffer8Impl_GetDesc(LPDIRECT3DVERTEXBUFFER8 iface, D3DVERTEXBUFFER_DESC *pDesc); + +/* IDirect3DVolume8 private include file + */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DVolume8) Direct3DVolume8_Vtbl; + +/***************************************************************************** + * IDirect3DVolume8 implementation structure + */ +struct IDirect3DVolume8Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DVolume8); + DWORD ref; + + /* IDirect3DVolume8 fields */ + IDirect3DDevice8Impl *Device; + D3DRESOURCETYPE ResourceType; + + void *Container; + +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DVolume8Impl_QueryInterface(LPDIRECT3DVOLUME8 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DVolume8Impl_AddRef(LPDIRECT3DVOLUME8 iface); +extern ULONG WINAPI IDirect3DVolume8Impl_Release(LPDIRECT3DVOLUME8 iface); + +/* IDirect3DVolume8 */ +extern HRESULT WINAPI IDirect3DVolume8Impl_GetDevice(LPDIRECT3DVOLUME8 iface, IDirect3DDevice8** ppDevice); +extern HRESULT WINAPI IDirect3DVolume8Impl_SetPrivateData(LPDIRECT3DVOLUME8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DVolume8Impl_GetPrivateData(LPDIRECT3DVOLUME8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DVolume8Impl_FreePrivateData(LPDIRECT3DVOLUME8 iface, REFGUID refguid); +extern HRESULT WINAPI IDirect3DVolume8Impl_GetContainer(LPDIRECT3DVOLUME8 iface, REFIID riid, void** ppContainer); +extern HRESULT WINAPI IDirect3DVolume8Impl_GetDesc(LPDIRECT3DVOLUME8 iface, D3DVOLUME_DESC* pDesc); +extern HRESULT WINAPI IDirect3DVolume8Impl_LockBox(LPDIRECT3DVOLUME8 iface, D3DLOCKED_BOX* pLockedVolume,CONST D3DBOX* pBox, DWORD Flags); +extern HRESULT WINAPI IDirect3DVolume8Impl_UnlockBox(LPDIRECT3DVOLUME8 iface); + +/* ------------------- */ +/* IDirect3DSwapChain8 */ +/* ------------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DSwapChain8) Direct3DSwapChain8_Vtbl; + +/***************************************************************************** + * IDirect3DSwapChain8 implementation structure + */ +struct IDirect3DSwapChain8Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DSwapChain8); + DWORD ref; + + /* IDirect3DSwapChain8 fields */ +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DSwapChain8Impl_QueryInterface(LPDIRECT3DSWAPCHAIN8 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DSwapChain8Impl_AddRef(LPDIRECT3DSWAPCHAIN8 iface); +extern ULONG WINAPI IDirect3DSwapChain8Impl_Release(LPDIRECT3DSWAPCHAIN8 iface); + +/* IDirect3DSwapChain8 */ +extern HRESULT WINAPI IDirect3DSwapChain8Impl_Present(LPDIRECT3DSWAPCHAIN8 iface, CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion); +extern HRESULT WINAPI IDirect3DSwapChain8Impl_GetBackBuffer(LPDIRECT3DSWAPCHAIN8 iface, UINT BackBuffer, D3DBACKBUFFER_TYPE Type,IDirect3DSurface8** ppBackBuffer); + +/* ----------------- */ +/* IDirect3DSurface8 */ +/* ----------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DSurface8) Direct3DSurface8_Vtbl; + +/***************************************************************************** + * IDirect3DSurface8 implementation structure + */ +struct IDirect3DSurface8Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DSurface8); + DWORD ref; + + /* IDirect3DSurface8 fields */ + IDirect3DDevice8Impl *Device; + D3DRESOURCETYPE ResourceType; + + void *Container; + + D3DSURFACE_DESC myDesc; + BYTE *allocatedMemory; + UINT textureName; + UINT bytesPerPixel; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DSurface8Impl_QueryInterface(LPDIRECT3DSURFACE8 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DSurface8Impl_AddRef(LPDIRECT3DSURFACE8 iface); +extern ULONG WINAPI IDirect3DSurface8Impl_Release(LPDIRECT3DSURFACE8 iface); + +/* IDirect3DSurface8 */ +extern HRESULT WINAPI IDirect3DSurface8Impl_GetDevice(LPDIRECT3DSURFACE8 iface, IDirect3DDevice8** ppDevice); +extern HRESULT WINAPI IDirect3DSurface8Impl_SetPrivateData(LPDIRECT3DSURFACE8 iface, REFGUID refguid,CONST void* pData,DWORD SizeOfData,DWORD Flags); +extern HRESULT WINAPI IDirect3DSurface8Impl_GetPrivateData(LPDIRECT3DSURFACE8 iface, REFGUID refguid,void* pData,DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DSurface8Impl_FreePrivateData(LPDIRECT3DSURFACE8 iface, REFGUID refguid); +extern HRESULT WINAPI IDirect3DSurface8Impl_GetContainer(LPDIRECT3DSURFACE8 iface, REFIID riid,void** ppContainer); +extern HRESULT WINAPI IDirect3DSurface8Impl_GetDesc(LPDIRECT3DSURFACE8 iface, D3DSURFACE_DESC *pDesc); +extern HRESULT WINAPI IDirect3DSurface8Impl_LockRect(LPDIRECT3DSURFACE8 iface, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect,DWORD Flags); +extern HRESULT WINAPI IDirect3DSurface8Impl_UnlockRect(LPDIRECT3DSURFACE8 iface); + +/* --------------------- */ +/* IDirect3DIndexBuffer8 */ +/* --------------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DIndexBuffer8) Direct3DIndexBuffer8_Vtbl; + +/***************************************************************************** + * IDirect3DIndexBuffer8 implementation structure + */ +struct IDirect3DIndexBuffer8Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DIndexBuffer8); + DWORD ref; + + /* IDirect3DIndexBuffer8 fields */ + IDirect3DDevice8Impl *Device; + D3DRESOURCETYPE ResourceType; + + D3DINDEXBUFFER_DESC currentDesc; + void *allocatedMemory; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DIndexBuffer8Impl_QueryInterface(LPDIRECT3DINDEXBUFFER8 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DIndexBuffer8Impl_AddRef(LPDIRECT3DINDEXBUFFER8 iface); +extern ULONG WINAPI IDirect3DIndexBuffer8Impl_Release(LPDIRECT3DINDEXBUFFER8 iface); + +/* IDirect3DIndexBuffer8 (Inherited from IDirect3DResource8) */ +extern HRESULT WINAPI IDirect3DIndexBuffer8Impl_GetDevice(LPDIRECT3DINDEXBUFFER8 iface, IDirect3DDevice8** ppDevice); +extern HRESULT WINAPI IDirect3DIndexBuffer8Impl_SetPrivateData(LPDIRECT3DINDEXBUFFER8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DIndexBuffer8Impl_GetPrivateData(LPDIRECT3DINDEXBUFFER8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DIndexBuffer8Impl_FreePrivateData(LPDIRECT3DINDEXBUFFER8 iface, REFGUID refguid); +extern DWORD WINAPI IDirect3DIndexBuffer8Impl_SetPriority(LPDIRECT3DINDEXBUFFER8 iface, DWORD PriorityNew); +extern DWORD WINAPI IDirect3DIndexBuffer8Impl_GetPriority(LPDIRECT3DINDEXBUFFER8 iface); +extern void WINAPI IDirect3DIndexBuffer8Impl_PreLoad(LPDIRECT3DINDEXBUFFER8 iface); +extern D3DRESOURCETYPE WINAPI IDirect3DIndexBuffer8Impl_GetType(LPDIRECT3DINDEXBUFFER8 iface); + +/* IDirect3DIndexBuffer8 */ +extern HRESULT WINAPI IDirect3DIndexBuffer8Impl_Lock(LPDIRECT3DINDEXBUFFER8 iface, UINT OffsetToLock, UINT SizeToLock, BYTE** ppbData, DWORD Flags); +extern HRESULT WINAPI IDirect3DIndexBuffer8Impl_Unlock(LPDIRECT3DINDEXBUFFER8 iface); +extern HRESULT WINAPI IDirect3DIndexBuffer8Impl_GetDesc(LPDIRECT3DINDEXBUFFER8 iface, D3DINDEXBUFFER_DESC *pDesc); + +/* --------------------- */ +/* IDirect3DCubeTexture8 */ +/* --------------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DCubeTexture8) Direct3DCubeTexture8_Vtbl; + +/***************************************************************************** + * IDirect3DCubeTexture8 implementation structure + */ +struct IDirect3DCubeTexture8Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DCubeTexture8); + DWORD ref; + + /* IDirect3DCubeTexture8 fields */ + IDirect3DDevice8Impl *Device; + D3DRESOURCETYPE ResourceType; + + UINT edgeLength; + DWORD usage; + UINT levels; + D3DFORMAT format; + + IDirect3DDevice8Impl *device; + IDirect3DSurface8Impl *surfaces[6][MAX_LEVELS]; + BOOL Dirty; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DCubeTexture8Impl_QueryInterface(LPDIRECT3DCUBETEXTURE8 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DCubeTexture8Impl_AddRef(LPDIRECT3DCUBETEXTURE8 iface); +extern ULONG WINAPI IDirect3DCubeTexture8Impl_Release(LPDIRECT3DCUBETEXTURE8 iface); + +/* IDirect3DCubeTexture8 (Inherited from IDirect3DResource8) */ +extern HRESULT WINAPI IDirect3DCubeTexture8Impl_GetDevice(LPDIRECT3DCUBETEXTURE8 iface, IDirect3DDevice8** ppDevice); +extern HRESULT WINAPI IDirect3DCubeTexture8Impl_SetPrivateData(LPDIRECT3DCUBETEXTURE8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DCubeTexture8Impl_GetPrivateData(LPDIRECT3DCUBETEXTURE8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DCubeTexture8Impl_FreePrivateData(LPDIRECT3DCUBETEXTURE8 iface, REFGUID refguid); +extern DWORD WINAPI IDirect3DCubeTexture8Impl_SetPriority(LPDIRECT3DCUBETEXTURE8 iface, DWORD PriorityNew); +extern DWORD WINAPI IDirect3DCubeTexture8Impl_GetPriority(LPDIRECT3DCUBETEXTURE8 iface); +extern void WINAPI IDirect3DCubeTexture8Impl_PreLoad(LPDIRECT3DCUBETEXTURE8 iface); +extern D3DRESOURCETYPE WINAPI IDirect3DCubeTexture8Impl_GetType(LPDIRECT3DCUBETEXTURE8 iface); + +/* IDirect3DCubeTexture8 (Inherited from IDirect3DBaseTexture8) */ +extern DWORD WINAPI IDirect3DCubeTexture8Impl_SetLOD(LPDIRECT3DCUBETEXTURE8 iface, DWORD LODNew); +extern DWORD WINAPI IDirect3DCubeTexture8Impl_GetLOD(LPDIRECT3DCUBETEXTURE8 iface); +extern DWORD WINAPI IDirect3DCubeTexture8Impl_GetLevelCount(LPDIRECT3DCUBETEXTURE8 iface); + +/* IDirect3DCubeTexture8 */ +extern HRESULT WINAPI IDirect3DCubeTexture8Impl_GetLevelDesc(LPDIRECT3DCUBETEXTURE8 iface,UINT Level,D3DSURFACE_DESC *pDesc); +extern HRESULT WINAPI IDirect3DCubeTexture8Impl_GetCubeMapSurface(LPDIRECT3DCUBETEXTURE8 iface,D3DCUBEMAP_FACES FaceType,UINT Level,IDirect3DSurface8** ppCubeMapSurface); +extern HRESULT WINAPI IDirect3DCubeTexture8Impl_LockRect(LPDIRECT3DCUBETEXTURE8 iface,D3DCUBEMAP_FACES FaceType,UINT Level,D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags); +extern HRESULT WINAPI IDirect3DCubeTexture8Impl_UnlockRect(LPDIRECT3DCUBETEXTURE8 iface,D3DCUBEMAP_FACES FaceType,UINT Level); +extern HRESULT WINAPI IDirect3DCubeTexture8Impl_AddDirtyRect(LPDIRECT3DCUBETEXTURE8 iface,D3DCUBEMAP_FACES FaceType,CONST RECT* pDirtyRect); + +/* ----------------- */ +/* IDirect3DTexture8 */ +/* ----------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DTexture8) Direct3DTexture8_Vtbl; + +/***************************************************************************** + * IDirect3DTexture8 implementation structure + */ +struct IDirect3DTexture8Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DTexture8); + DWORD ref; + + /* IDirect3DTexture8 fields */ + IDirect3DDevice8Impl *Device; + D3DRESOURCETYPE ResourceType; + UINT width; + UINT height; + UINT levels; + DWORD usage; + D3DFORMAT format; + + IDirect3DDevice8Impl *device; + IDirect3DSurface8Impl *surfaces[MAX_LEVELS]; + BOOL Dirty; + +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DTexture8Impl_QueryInterface(LPDIRECT3DTEXTURE8 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DTexture8Impl_AddRef(LPDIRECT3DTEXTURE8 iface); +extern ULONG WINAPI IDirect3DTexture8Impl_Release(LPDIRECT3DTEXTURE8 iface); + +/* IDirect3DTexture8 (Inherited from IDirect3DResource8) */ +extern HRESULT WINAPI IDirect3DTexture8Impl_GetDevice(LPDIRECT3DTEXTURE8 iface, IDirect3DDevice8** ppDevice); +extern HRESULT WINAPI IDirect3DTexture8Impl_SetPrivateData(LPDIRECT3DTEXTURE8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DTexture8Impl_GetPrivateData(LPDIRECT3DTEXTURE8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DTexture8Impl_FreePrivateData(LPDIRECT3DTEXTURE8 iface, REFGUID refguid); +extern DWORD WINAPI IDirect3DTexture8Impl_SetPriority(LPDIRECT3DTEXTURE8 iface, DWORD PriorityNew); +extern DWORD WINAPI IDirect3DTexture8Impl_GetPriority(LPDIRECT3DTEXTURE8 iface); +extern void WINAPI IDirect3DTexture8Impl_PreLoad(LPDIRECT3DTEXTURE8 iface); +extern D3DRESOURCETYPE WINAPI IDirect3DTexture8Impl_GetType(LPDIRECT3DTEXTURE8 iface); + +/* IDirect3DTexture8 (Inherited from IDirect3DBaseTexture8) */ +extern DWORD WINAPI IDirect3DTexture8Impl_SetLOD(LPDIRECT3DTEXTURE8 iface, DWORD LODNew); +extern DWORD WINAPI IDirect3DTexture8Impl_GetLOD(LPDIRECT3DTEXTURE8 iface); +extern DWORD WINAPI IDirect3DTexture8Impl_GetLevelCount(LPDIRECT3DTEXTURE8 iface); + +/* IDirect3DTexture8 */ +extern HRESULT WINAPI IDirect3DTexture8Impl_GetLevelDesc(LPDIRECT3DTEXTURE8 iface, UINT Level,D3DSURFACE_DESC* pDesc); +extern HRESULT WINAPI IDirect3DTexture8Impl_GetSurfaceLevel(LPDIRECT3DTEXTURE8 iface, UINT Level,IDirect3DSurface8** ppSurfaceLevel); +extern HRESULT WINAPI IDirect3DTexture8Impl_LockRect(LPDIRECT3DTEXTURE8 iface, UINT Level,D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags); +extern HRESULT WINAPI IDirect3DTexture8Impl_UnlockRect(LPDIRECT3DTEXTURE8 iface, UINT Level); +extern HRESULT WINAPI IDirect3DTexture8Impl_AddDirtyRect(LPDIRECT3DTEXTURE8 iface, CONST RECT* pDirtyRect); + +/* ----------------------- */ +/* IDirect3DVolumeTexture8 */ +/* ----------------------- */ + +/***************************************************************************** + * Predeclare the interface implementation structures + */ +extern ICOM_VTABLE(IDirect3DVolumeTexture8) Direct3DVolumeTexture8_Vtbl; + +/***************************************************************************** + * IDirect3DVolumeTexture8 implementation structure + */ +struct IDirect3DVolumeTexture8Impl +{ + /* IUnknown fields */ + ICOM_VFIELD(IDirect3DVolumeTexture8); + DWORD ref; + + /* IDirect3DVolumeTexture8 fields */ + IDirect3DDevice8Impl *Device; + D3DRESOURCETYPE ResourceType; +}; + +/* IUnknown: */ +extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_QueryInterface(LPDIRECT3DVOLUMETEXTURE8 iface,REFIID refiid,LPVOID *obj); +extern ULONG WINAPI IDirect3DVolumeTexture8Impl_AddRef(LPDIRECT3DVOLUMETEXTURE8 iface); +extern ULONG WINAPI IDirect3DVolumeTexture8Impl_Release(LPDIRECT3DVOLUMETEXTURE8 iface); + +/* IDirect3DVolumeTexture8 (Inherited from IDirect3DResource8) */ +extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_GetDevice(LPDIRECT3DVOLUMETEXTURE8 iface, IDirect3DDevice8** ppDevice); +extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_SetPrivateData(LPDIRECT3DVOLUMETEXTURE8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags); +extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_GetPrivateData(LPDIRECT3DVOLUMETEXTURE8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData); +extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_FreePrivateData(LPDIRECT3DVOLUMETEXTURE8 iface, REFGUID refguid); +extern DWORD WINAPI IDirect3DVolumeTexture8Impl_SetPriority(LPDIRECT3DVOLUMETEXTURE8 iface, DWORD PriorityNew); +extern DWORD WINAPI IDirect3DVolumeTexture8Impl_GetPriority(LPDIRECT3DVOLUMETEXTURE8 iface); +extern void WINAPI IDirect3DVolumeTexture8Impl_PreLoad(LPDIRECT3DVOLUMETEXTURE8 iface); +extern D3DRESOURCETYPE WINAPI IDirect3DVolumeTexture8Impl_GetType(LPDIRECT3DVOLUMETEXTURE8 iface); + +/* IDirect3DVolumeTexture8 (Inherited from IDirect3DBaseTexture8) */ +extern DWORD WINAPI IDirect3DVolumeTexture8Impl_SetLOD(LPDIRECT3DVOLUMETEXTURE8 iface, DWORD LODNew); +extern DWORD WINAPI IDirect3DVolumeTexture8Impl_GetLOD(LPDIRECT3DVOLUMETEXTURE8 iface); +extern DWORD WINAPI IDirect3DVolumeTexture8Impl_GetLevelCount(LPDIRECT3DVOLUMETEXTURE8 iface); + +/* IDirect3DVolumeTexture8 */ +extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_GetLevelDesc(LPDIRECT3DVOLUMETEXTURE8 iface, UINT Level,D3DVOLUME_DESC *pDesc); +extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_GetVolumeLevel(LPDIRECT3DVOLUMETEXTURE8 iface, UINT Level,IDirect3DVolume8** ppVolumeLevel); +extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_LockBox(LPDIRECT3DVOLUMETEXTURE8 iface, UINT Level,D3DLOCKED_BOX* pLockedVolume,CONST D3DBOX* pBox,DWORD Flags); +extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_UnlockBox(LPDIRECT3DVOLUMETEXTURE8 iface, UINT Level); +extern HRESULT WINAPI IDirect3DVolumeTexture8Impl_AddDirtyBox(LPDIRECT3DVOLUMETEXTURE8 iface, CONST D3DBOX* pDirtyBox); + +#endif /* __WINE_D3DX8_PRIVATE_H */ diff --git a/dlls/d3d8/device.c b/dlls/d3d8/device.c new file mode 100644 index 00000000000..27849366794 --- /dev/null +++ b/dlls/d3d8/device.c @@ -0,0 +1,2928 @@ +/* + * IDirect3DDevice8 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 "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d8_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* CreateVertexShader can return > 0xFFFF */ +#define VS_HIGHESTFIXEDFXF 0xFFFF + +/* Used for CreateStateBlock */ +#define NUM_SAVEDPIXELSTATES_R 38 +#define NUM_SAVEDPIXELSTATES_T 27 +#define NUM_SAVEDVERTEXSTATES_R 33 +#define NUM_SAVEDVERTEXSTATES_T 2 + +/* + * Utility functions or macros + */ +#define conv_mat(mat,gl_mat) \ +{ \ + TRACE("%f %f %f %f\n", (mat)->u.s._11, (mat)->u.s._12, (mat)->u.s._13, (mat)->u.s._14); \ + TRACE("%f %f %f %f\n", (mat)->u.s._21, (mat)->u.s._22, (mat)->u.s._23, (mat)->u.s._24); \ + TRACE("%f %f %f %f\n", (mat)->u.s._31, (mat)->u.s._32, (mat)->u.s._33, (mat)->u.s._34); \ + TRACE("%f %f %f %f\n", (mat)->u.s._41, (mat)->u.s._42, (mat)->u.s._43, (mat)->u.s._44); \ + memcpy(gl_mat, (mat), 16 * sizeof(float)); \ +}; + +/* + * Globals + */ +extern DWORD SavedPixelStates_R[NUM_SAVEDPIXELSTATES_R]; +extern DWORD SavedPixelStates_T[NUM_SAVEDPIXELSTATES_T]; +extern DWORD SavedVertexStates_R[NUM_SAVEDVERTEXSTATES_R]; +extern DWORD SavedVertexStates_T[NUM_SAVEDVERTEXSTATES_T]; + +/* Routine common to the draw primitive and draw indexed primitive routines + Doesnt use gl pointer arrays as I dont believe we can support the blending + coordinates that way. */ + +void DrawPrimitiveI(LPDIRECT3DDEVICE8 iface, + int PrimitiveType, + long NumPrimitives, + BOOL isIndexed, + + /* For Both:*/ + D3DFORMAT fvf, + const void *vertexBufData, + + /* for Indexed: */ + long StartVertexIndex, + long StartIdx, + short idxBytes, + const void *idxData) { + + int vx_index; + int NumVertexes = NumPrimitives; + + ICOM_THIS(IDirect3DDevice8Impl,iface); + + /* Dont understand how to handle multiple streams, but if a fixed + FVF is passed in rather than a handle, it must use stream 0 */ + + if (This->StateBlock.VertexShader > VS_HIGHESTFIXEDFXF) { + FIXME("Cant handle created shaders yet\n"); + return; + } else { + + int skip = This->StateBlock.stream_stride[0]; + + BOOL normal; + BOOL isRHW; + BOOL isPtSize; + BOOL isDiffuse; + BOOL isSpecular; + int numTextures; + int textureNo; + const void *curVtx = NULL; + const short *pIdxBufS = NULL; + const long *pIdxBufL = NULL; + const void *curPos; + + float x=0.0, y=0.0, z=0.0; /* x,y,z coordinates */ + float nx=0.0, ny=0.0, nz=0.0; /* normal x,y,z coordinates */ + float rhw=0.0; /* rhw */ + float ptSize=0.0; /* Point size */ + DWORD diffuseColor=0; /* Diffusre Color */ + DWORD specularColor=0; /* Specular Color */ + + ENTER_GL(); + + if (isIndexed) { + if (idxBytes == 2) pIdxBufS = (short *) idxData; + else pIdxBufL = (long *) idxData; + } + + /* Check vertex formats expected ? */ + normal = fvf & D3DFVF_NORMAL; + isRHW = fvf & D3DFVF_XYZRHW; + /*numBlends = 5 - ((~fvf) & 0xe);*/ /* There must be a simpler way? */ + isPtSize = fvf & D3DFVF_PSIZE; + isDiffuse = fvf & D3DFVF_DIFFUSE; + isSpecular = fvf & D3DFVF_SPECULAR; + numTextures = (fvf & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT; + + TRACE("Drawing with FVF = %x, (n?%d, rhw?%d, ptSize(%d), diffuse?%d, specular?%d, numTextures=%d)\n", + fvf, normal, isRHW, isPtSize, isDiffuse, isSpecular, numTextures); + + /* Only add lighting for unlit vertices */ + if (normal && !isRHW) { + glEnable(GL_LIGHTING); + checkGLcall("enable lighting"); + } else { + glDisable(GL_LIGHTING); + checkGLcall("disable lighting"); + } + + if (isRHW) { + + double height, width, minZ, maxZ; + + /* + * Already transformed vertex do not need transform + * matrices. Reset all matrices to identity. + * Leave the default matrix in world mode. + */ + glMatrixMode(GL_PROJECTION); + checkGLcall("glMatrixMode"); + glLoadIdentity(); + checkGLcall("glLoadIdentity"); + glMatrixMode(GL_MODELVIEW); + checkGLcall("glMatrixMode"); + glLoadIdentity(); + checkGLcall("glLoadIdentity"); + height = This->StateBlock.viewport.Height; + width = This->StateBlock.viewport.Width; + minZ = This->StateBlock.viewport.MinZ; + maxZ = This->StateBlock.viewport.MaxZ; + TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, -minZ, -maxZ); + glOrtho(0.0, width, height, 0.0, -minZ, -maxZ); + checkGLcall("glOrtho"); +#if 1 + } else { + glMatrixMode(GL_PROJECTION); + checkGLcall("glMatrixMode"); + glLoadMatrixf((float *) &This->StateBlock.transforms[D3DTS_PROJECTION].u.m[0][0]); + checkGLcall("glLoadMatrixf"); + + glMatrixMode(GL_MODELVIEW); + checkGLcall("glMatrixMode"); + glLoadMatrixf((float *) &This->StateBlock.transforms[D3DTS_VIEW].u.m[0][0]); + checkGLcall("glLoadMatrixf"); + glMultMatrixf((float *) &This->StateBlock.transforms[D3DTS_WORLDMATRIX(0)].u.m[0][0]); + checkGLcall("glMultMatrixf"); +#endif + } + + /* Set OpenGL to the appropriate Primitive Type */ + switch (PrimitiveType) { + case D3DPT_POINTLIST: + TRACE("glBegin, Start POINTS\n"); + glBegin(GL_POINTS); + NumVertexes = NumPrimitives; + break; + + case D3DPT_LINELIST: + TRACE("glBegin, Start LINES\n"); + glBegin(GL_LINES); + NumVertexes = NumPrimitives * 2; + break; + + case D3DPT_LINESTRIP: + TRACE("glBegin, Start LINE_STRIP\n"); + glBegin(GL_LINE_STRIP); + NumVertexes = NumPrimitives + 1; + break; + + case D3DPT_TRIANGLELIST: + TRACE("glBegin, Start TRIANGLES\n"); + glBegin(GL_TRIANGLES); + NumVertexes = NumPrimitives * 3; + break; + + case D3DPT_TRIANGLESTRIP: + TRACE("glBegin, Start TRIANGLE_STRIP\n"); + glBegin(GL_TRIANGLE_STRIP); + NumVertexes = NumPrimitives + 2; + break; + + case D3DPT_TRIANGLEFAN: + TRACE("glBegin, Start TRIANGLE_FAN\n"); + glBegin(GL_TRIANGLE_FAN); + NumVertexes = NumPrimitives + 2; + break; + + default: + FIXME("Unhandled primitive\n"); + break; + } + + + /* Draw the primitives */ + curVtx = vertexBufData + (StartVertexIndex * skip); + + for (vx_index = 0; vx_index < NumVertexes; vx_index++) { + + if (!isIndexed) { + curPos = curVtx; + } else { + if (idxBytes == 2) { + TRACE("Idx for vertex %d = %d = %d\n", vx_index, pIdxBufS[StartIdx+vx_index], (pIdxBufS[StartIdx+vx_index])); + curPos = curVtx + ((pIdxBufS[StartIdx+vx_index]) * skip); + } else { + TRACE("Idx for vertex %d = %ld = %d\n", vx_index, pIdxBufL[StartIdx+vx_index], (pIdxBufS[StartIdx+vx_index])); + curPos = curVtx + ((pIdxBufL[StartIdx+vx_index]) * skip); + } + } + + /* Work through the vertex buffer */ + x = *(float *)curPos; + curPos = curPos + sizeof(float); + y = *(float *)curPos; + curPos = curPos + sizeof(float); + z = *(float *)curPos; + curPos = curPos + sizeof(float); + TRACE("x,y,z=%f,%f,%f\n", x,y,z); + + /* RHW follows, only if transformed */ + if (isRHW) { + rhw = *(float *)curPos; + curPos = curPos + sizeof(float); + TRACE("rhw=%f\n", rhw); + } + + + /* FIXME: Skip Blending data */ + + /* Vertex Normal Data (untransformed only) */ + if (normal) { + nx = *(float *)curPos; + curPos = curPos + sizeof(float); + ny = *(float *)curPos; + curPos = curPos + sizeof(float); + nz = *(float *)curPos; + curPos = curPos + sizeof(float); + TRACE("nx,ny,nz=%f,%f,%f\n", nx,ny,nz); + } + + if (isPtSize) { + ptSize = *(float *)curPos; + curPos = curPos + sizeof(float); + TRACE("ptSize=%f\n", ptSize); + } + if (isDiffuse) { + diffuseColor = *(DWORD *)curPos; + TRACE("diffuseColor=%lx\n", diffuseColor); + curPos = curPos + sizeof(DWORD); + } + if (isSpecular) { + specularColor = *(DWORD *)curPos; + TRACE("specularColor=%lx\n", specularColor); + curPos = curPos + sizeof(DWORD); + } + + /* ToDo: Texture coords */ + for (textureNo = 0;textureNoStateBlock.textures[0])) { + case D3DRTYPE_TEXTURE: + s = *(float *)curPos; + curPos = curPos + sizeof(float); + t = *(float *)curPos; + curPos = curPos + sizeof(float); + TRACE("tex:%d, s,t=%f,%f\n", textureNo, s,t); + glMultiTexCoord2fARB(GL_TEXTURE0_ARB + textureNo, s, t); + break; + default: + r=0;q=0; /* Avoid compiler warnings, need these vars later for other textures */ + FIXME("Unhandled texture type\n"); + } + + } + + /* Handle these vertexes */ + if (isDiffuse) { + glColor4f(((diffuseColor >> 16) & 0xFF) / 255.0, + ((diffuseColor >> 8) & 0xFF) / 255.0, + ((diffuseColor >> 0) & 0xFF) / 255.0, + ((diffuseColor >> 24) & 0xFF) / 255.0); + TRACE("glColor4f: r,g,b,a=%f,%f,%f,%f\n", ((diffuseColor >> 16) & 0xFF) / 255.0, ((diffuseColor >> 8) & 0xFF) / 255.0, + ((diffuseColor >> 0) & 0xFF) / 255.0, ((diffuseColor >> 24) & 0xFF) / 255.0); + } + + if (normal) { + TRACE("Vertex: glVertex:x,y,z=%f,%f,%f / glNormal:nx,ny,nz=%f,%f,%f\n", x,y,z,nx,ny,nz); + glNormal3f(nx, ny, nz); + glVertex3f(x, y, z); + + } else { + if (rhw < 0.01) { + TRACE("Vertex: glVertex:x,y,z=%f,%f,%f\n", x,y,z); + glVertex3f(x, y, z); + } else { + TRACE("Vertex: glVertex:x,y,z=%f,%f,%f / rhw=%f\n", x,y,z,rhw); + glVertex4f(x / rhw, y / rhw, z / rhw, 1.0 / rhw); + } + } + + if (!isIndexed) { + curVtx = curVtx + skip; + } + } + } + glEnd(); + checkGLcall("glEnd and previous calls"); + LEAVE_GL(); + + TRACE("glEnd\n"); +} + +/* + Simple utility routines used for dx -> gl mapping of byte formats + */ +SHORT bytesPerPixel(D3DFORMAT fmt) { + SHORT retVal; + + switch (fmt) { + case D3DFMT_A4R4G4B4: retVal = 2; break; + case D3DFMT_A8R8G8B8: retVal = 4; break; + case D3DFMT_X8R8G8B8: retVal = 4; break; + case D3DFMT_R8G8B8: retVal = 3; break; + case D3DFMT_R5G6B5: retVal = 2; break; + default: + FIXME("Unhandled fmt %d\n", fmt); + retVal = 4; + } + + + TRACE("bytes/Pxl for fmt %d = %d\n", fmt, retVal); + return retVal; +} + +GLint fmt2glintFmt(D3DFORMAT fmt) { + GLint retVal; + + switch (fmt) { + case D3DFMT_A4R4G4B4: retVal = GL_RGBA4; break; + case D3DFMT_A8R8G8B8: retVal = GL_RGBA8; break; + case D3DFMT_X8R8G8B8: retVal = GL_RGB8; break; + case D3DFMT_R8G8B8: retVal = GL_RGB8; break; + case D3DFMT_R5G6B5: retVal = GL_RGB5; break; /* fixme: internal format 6 for g? */ + default: + FIXME("Unhandled fmt %d\n", fmt); + retVal = 4; + } + TRACE("fmt2glintFmt for fmt %d = %x\n", fmt, retVal); + return retVal; +} +GLenum fmt2glFmt(D3DFORMAT fmt) { + GLenum retVal; + + switch (fmt) { + case D3DFMT_A4R4G4B4: retVal = GL_BGRA; break; + case D3DFMT_A8R8G8B8: retVal = GL_BGRA; break; + case D3DFMT_X8R8G8B8: retVal = GL_BGRA; break; + case D3DFMT_R8G8B8: retVal = GL_BGR; break; + case D3DFMT_R5G6B5: retVal = GL_BGR; break; + default: + FIXME("Unhandled fmt %d\n", fmt); + retVal = 4; + } + TRACE("fmt2glFmt for fmt %d = %x\n", fmt, retVal); + return retVal; +} +DWORD fmt2glType(D3DFORMAT fmt) { + GLenum retVal; + + switch (fmt) { + case D3DFMT_A4R4G4B4: retVal = GL_UNSIGNED_SHORT_4_4_4_4_REV; break; + case D3DFMT_A8R8G8B8: retVal = GL_UNSIGNED_BYTE; break; + case D3DFMT_X8R8G8B8: retVal = GL_UNSIGNED_BYTE; break; + case D3DFMT_R5G6B5: retVal = GL_UNSIGNED_SHORT_5_6_5_REV; break; + case D3DFMT_R8G8B8: retVal = GL_UNSIGNED_BYTE; break; + default: + FIXME("Unhandled fmt %d\n", fmt); + retVal = 4; + } + + + TRACE("fmt2glType for fmt %d = %x\n", fmt, retVal); + return retVal; +} + +int SOURCEx_RGB_EXT(DWORD arg) { + switch(arg) { + case D3DTSS_COLORARG0: return GL_SOURCE2_RGB_EXT; + case D3DTSS_COLORARG1: return GL_SOURCE0_RGB_EXT; + case D3DTSS_COLORARG2: return GL_SOURCE1_RGB_EXT; + case D3DTSS_ALPHAARG0: + case D3DTSS_ALPHAARG1: + case D3DTSS_ALPHAARG2: + default: + FIXME("Invalid arg %ld\n", arg); + return GL_SOURCE0_RGB_EXT; + } +} +int OPERANDx_RGB_EXT(DWORD arg) { + switch(arg) { + case D3DTSS_COLORARG0: return GL_OPERAND2_RGB_EXT; + case D3DTSS_COLORARG1: return GL_OPERAND0_RGB_EXT; + case D3DTSS_COLORARG2: return GL_OPERAND1_RGB_EXT; + case D3DTSS_ALPHAARG0: + case D3DTSS_ALPHAARG1: + case D3DTSS_ALPHAARG2: + default: + FIXME("Invalid arg %ld\n", arg); + return GL_OPERAND0_RGB_EXT; + } +} +int SOURCEx_ALPHA_EXT(DWORD arg) { + switch(arg) { + case D3DTSS_ALPHAARG0: return GL_SOURCE2_ALPHA_EXT; + case D3DTSS_ALPHAARG1: return GL_SOURCE0_ALPHA_EXT; + case D3DTSS_ALPHAARG2: return GL_SOURCE1_ALPHA_EXT; + case D3DTSS_COLORARG0: + case D3DTSS_COLORARG1: + case D3DTSS_COLORARG2: + default: + FIXME("Invalid arg %ld\n", arg); + return GL_SOURCE0_ALPHA_EXT; + } +} +int OPERANDx_ALPHA_EXT(DWORD arg) { + switch(arg) { + case D3DTSS_ALPHAARG0: return GL_OPERAND2_ALPHA_EXT; + case D3DTSS_ALPHAARG1: return GL_OPERAND0_ALPHA_EXT; + case D3DTSS_ALPHAARG2: return GL_OPERAND1_ALPHA_EXT; + case D3DTSS_COLORARG0: + case D3DTSS_COLORARG1: + case D3DTSS_COLORARG2: + default: + FIXME("Invalid arg %ld\n", arg); + return GL_OPERAND0_ALPHA_EXT; + } +} + + +/* IDirect3D IUnknown parts follow: */ +HRESULT WINAPI IDirect3DDevice8Impl_QueryInterface(LPDIRECT3DDEVICE8 iface,REFIID riid,LPVOID *ppobj) +{ + ICOM_THIS(IDirect3DDevice8Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IClassFactory)) { + IDirect3DDevice8Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DDevice8Impl_AddRef(LPDIRECT3DDEVICE8 iface) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DDevice8Impl_Release(LPDIRECT3DDEVICE8 iface) { + ICOM_THIS(IDirect3DDevice8Impl,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 IDirect3DDevice8Impl_TestCooperativeLevel(LPDIRECT3DDEVICE8 iface) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : stub\n", This); /* No way of notifying yet! */ + return D3D_OK; +} + + +UINT WINAPI IDirect3DDevice8Impl_GetAvailableTextureMem(LPDIRECT3DDEVICE8 iface) { + ICOM_THIS(IDirect3DDevice8Impl,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 IDirect3DDevice8Impl_ResourceManagerDiscardBytes(LPDIRECT3DDEVICE8 iface, DWORD Bytes) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetDirect3D(LPDIRECT3DDEVICE8 iface, IDirect3D8** ppD3D8) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : returning %p\n", This, This->direct3d8); + + /* Inc ref count */ + IDirect3D8_AddRef((LPDIRECT3D8) This->direct3d8); + + *ppD3D8 = (IDirect3D8 *)This->direct3d8; + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetDeviceCaps(LPDIRECT3DDEVICE8 iface, D3DCAPS8* pCaps) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub, calling idirect3d for now\n", This); + IDirect3D8Impl_GetDeviceCaps((LPDIRECT3D8) This->direct3d8, This->adapterNo, This->devType, pCaps); + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetDisplayMode(LPDIRECT3DDEVICE8 iface, D3DDISPLAYMODE* pMode) { + + HDC hdc; + int bpp = 0; + + ICOM_THIS(IDirect3DDevice8Impl,iface); + pMode->Width = GetSystemMetrics(SM_CXSCREEN); + pMode->Height = GetSystemMetrics(SM_CYSCREEN); + pMode->RefreshRate = 85; /*FIXME: How to identify? */ + + hdc = CreateDCA("DISPLAY", NULL, NULL, NULL); + bpp = GetDeviceCaps(hdc, BITSPIXEL); + DeleteDC(hdc); + + switch (bpp) { + case 8: pMode->Format = D3DFMT_R8G8B8; break; + case 16: pMode->Format = D3DFMT_R5G6B5; break; + case 24: pMode->Format = D3DFMT_R8G8B8; break; + case 32: pMode->Format = D3DFMT_A8R8G8B8; break; + default: pMode->Format = D3DFMT_UNKNOWN; + } + + FIXME("(%p) : returning w(%d) h(%d) rr(%d) fmt(%d)\n", This, pMode->Width, pMode->Height, pMode->RefreshRate, pMode->Format); + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetCreationParameters(LPDIRECT3DDEVICE8 iface, D3DDEVICE_CREATION_PARAMETERS *pParameters) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_SetCursorProperties(LPDIRECT3DDEVICE8 iface, UINT XHotSpot, UINT YHotSpot, IDirect3DSurface8* pCursorBitmap) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +void WINAPI IDirect3DDevice8Impl_SetCursorPosition(LPDIRECT3DDEVICE8 iface, UINT XScreenSpace, UINT YScreenSpace,DWORD Flags) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return; +} +BOOL WINAPI IDirect3DDevice8Impl_ShowCursor(LPDIRECT3DDEVICE8 iface, BOOL bShow) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_CreateAdditionalSwapChain(LPDIRECT3DDEVICE8 iface, D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain8** pSwapChain) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_Reset(LPDIRECT3DDEVICE8 iface, D3DPRESENT_PARAMETERS* pPresentationParameters) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_Present(LPDIRECT3DDEVICE8 iface, CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : complete stub!\n", This); + + ENTER_GL(); + + glXSwapBuffers(This->display, This->win); + checkGLcall("glXSwapBuffers"); + + LEAVE_GL(); + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetBackBuffer(LPDIRECT3DDEVICE8 iface, UINT BackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface8** ppBackBuffer) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + *ppBackBuffer = (LPDIRECT3DSURFACE8) This->backBuffer; + TRACE("(%p) : BackBuf %d Type %d returning %p\n", This, BackBuffer, Type, *ppBackBuffer); + + /* Note inc ref on returned surface */ + IDirect3DSurface8Impl_AddRef((LPDIRECT3DSURFACE8) *ppBackBuffer); + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetRasterStatus(LPDIRECT3DDEVICE8 iface, D3DRASTER_STATUS* pRasterStatus) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +void WINAPI IDirect3DDevice8Impl_SetGammaRamp(LPDIRECT3DDEVICE8 iface, DWORD Flags,CONST D3DGAMMARAMP* pRamp) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return; +} +void WINAPI IDirect3DDevice8Impl_GetGammaRamp(LPDIRECT3DDEVICE8 iface, D3DGAMMARAMP* pRamp) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return; +} +HRESULT WINAPI IDirect3DDevice8Impl_CreateTexture(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, UINT Levels, DWORD Usage, + D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture8** ppTexture) { + IDirect3DTexture8Impl *object; + int i; + UINT tmpW; + UINT tmpH; + + ICOM_THIS(IDirect3DDevice8Impl,iface); + + /* Allocate the storage for the device */ + TRACE("(%p) : W(%d) H(%d), Lvl(%d) Usage(%ld), Fmt(%d), Pool(%d)\n", This, Width, Height, Levels, Usage, Format, Pool); + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DTexture8Impl)); + object->lpVtbl = &Direct3DTexture8_Vtbl; + object->Device = This; + object->ResourceType = D3DRTYPE_TEXTURE; + object->ref = 1; + object->width = Width; + object->height = Height; + object->levels = Levels; + object->usage = Usage; + object->format = Format; + object->device = This; + + /* Calculate levels for mip mapping */ + if (Levels == 0) { + object->levels++; + tmpW = Width; + tmpH = Height; + while (tmpW > 1 && tmpH > 1) { + tmpW = max(1,tmpW / 2); + tmpH = max(1, tmpH / 2); + object->levels++; + } + TRACE("Calculated levels = %d\n", object->levels); + } + + /* Generate all the surfaces */ + tmpW = Width; + tmpH = Height; + /*for (i=0; ilevels; i++) { */ + i=0; + { + IDirect3DDevice8Impl_CreateImageSurface(iface, tmpW, tmpH, Format, (LPDIRECT3DSURFACE8*) &object->surfaces[i]); + object->surfaces[i]->Container = object; + object->surfaces[i]->myDesc.Usage = Usage; + object->surfaces[i]->myDesc.Pool = Pool ; + + TRACE("Created surface level %d @ %p, memory at %p\n", i, object->surfaces[i], object->surfaces[i]->allocatedMemory); + tmpW = max(1,tmpW / 2); + tmpH = max(1, tmpH / 2); + } + + *ppTexture = (LPDIRECT3DTEXTURE8)object; + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_CreateVolumeTexture(LPDIRECT3DDEVICE8 iface, UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture8** ppVolumeTexture) { + + IDirect3DVolumeTexture8Impl *object; + ICOM_THIS(IDirect3DDevice8Impl,iface); + + /* Allocate the storage for it */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DVolumeTexture8Impl)); + object->lpVtbl = &Direct3DVolumeTexture8_Vtbl; + object->ref = 1; + object->Device = This; + object->ResourceType = D3DRTYPE_VOLUMETEXTURE; + TRACE("(%p) : Iface@%p\n", This, object); + *ppVolumeTexture = (LPDIRECT3DVOLUMETEXTURE8)object; + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_CreateCubeTexture(LPDIRECT3DDEVICE8 iface, UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture8** ppCubeTexture) { + + IDirect3DCubeTexture8Impl *object; + ICOM_THIS(IDirect3DDevice8Impl,iface); + int i,j; + UINT tmpW; + + /* Allocate the storage for it */ + TRACE("(%p) : Len(%d), Lvl(%d) Usage(%ld), Fmt(%d), Pool(%d)\n", This, EdgeLength, Levels, Usage, Format, Pool); + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DCubeTexture8Impl)); + object->lpVtbl = &Direct3DCubeTexture8_Vtbl; + object->ref = 1; + object->Device = This; + object->ResourceType = D3DRTYPE_CUBETEXTURE; + + object->edgeLength = EdgeLength; + object->levels = Levels; + object->usage = Usage; + object->format = Format; + object->device = This; + + /* Calculate levels for mip mapping */ + if (Levels == 0) { + object->levels++; + tmpW = EdgeLength; + while (tmpW > 1) { + tmpW = max(1,tmpW / 2); + object->levels++; + } + TRACE("Calculated levels = %d\n", object->levels); + } + + /* Generate all the surfaces */ + tmpW = EdgeLength; + /*for (i=0; ilevels; i++) { */ + i=0; + { + /* Create the 6 faces */ + for (j=0;j<6;j++) { + IDirect3DDevice8Impl_CreateImageSurface(iface, tmpW, tmpW, Format, (LPDIRECT3DSURFACE8*) &object->surfaces[j][i]); + object->surfaces[j][i]->Container = object; + object->surfaces[j][i]->myDesc.Usage = Usage; + object->surfaces[j][i]->myDesc.Pool = Pool ; + + TRACE("Created surface level %d @ %p, memory at %p\n", i, object->surfaces[j][i], object->surfaces[j][i]->allocatedMemory); + tmpW = max(1,tmpW / 2); + } + } + + TRACE("(%p) : Iface@%p\n", This, object); + *ppCubeTexture = (LPDIRECT3DCUBETEXTURE8)object; + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_CreateVertexBuffer(LPDIRECT3DDEVICE8 iface, UINT Size,DWORD Usage, + DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer8** ppVertexBuffer) { + IDirect3DVertexBuffer8Impl *object; + + ICOM_THIS(IDirect3DDevice8Impl,iface); + + /* Allocate the storage for the device */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DVertexBuffer8Impl)); + object->lpVtbl = &Direct3DVertexBuffer8_Vtbl; + object->Device = This; + object->ResourceType = D3DRTYPE_VERTEXBUFFER; + object->ref = 1; + object->allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, Size); + object->currentDesc.Usage = Usage; + object->currentDesc.Pool = Pool; + object->currentDesc.FVF = FVF; + object->currentDesc.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 = (LPDIRECT3DVERTEXBUFFER8)object; + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_CreateIndexBuffer(LPDIRECT3DDEVICE8 iface, UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer8** ppIndexBuffer) { + + IDirect3DIndexBuffer8Impl *object; + + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : Len=%d, Use=%lx, Format=%x, Pool=%d\n", This, Length, Usage, Format, Pool); + + /* Allocate the storage for the device */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DIndexBuffer8Impl)); + object->lpVtbl = &Direct3DIndexBuffer8_Vtbl; + object->ref = 1; + object->Device = This; + object->ResourceType = D3DRTYPE_INDEXBUFFER; + + object->currentDesc.Type = D3DRTYPE_INDEXBUFFER; + object->currentDesc.Usage = Usage; + object->currentDesc.Pool = Pool; + object->currentDesc.Format = Format; + object->currentDesc.Size = Length; + + object->allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, Length); + + TRACE("(%p) : Iface@%p allocatedMem @ %p\n", This, object, object->allocatedMemory); + + *ppIndexBuffer = (LPDIRECT3DINDEXBUFFER8)object; + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_CreateRenderTarget(LPDIRECT3DDEVICE8 iface, UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,BOOL Lockable,IDirect3DSurface8** ppSurface) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + /* up ref count on surface */ + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_CreateDepthStencilSurface(LPDIRECT3DDEVICE8 iface, UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,IDirect3DSurface8** ppSurface) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_CreateImageSurface(LPDIRECT3DDEVICE8 iface, UINT Width,UINT Height,D3DFORMAT Format,IDirect3DSurface8** ppSurface) { + IDirect3DSurface8Impl *object; + + ICOM_THIS(IDirect3DDevice8Impl,iface); + + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DSurface8Impl)); + *ppSurface = (LPDIRECT3DSURFACE8) object; + object->lpVtbl = &Direct3DSurface8_Vtbl; + object->Device = This; + object->ResourceType = D3DRTYPE_SURFACE; + object->Container = object; + + object->ref = 1; + object->myDesc.Width = Width; + object->myDesc.Height= Height; + object->myDesc.Format= Format; + object->myDesc.Type = D3DRTYPE_SURFACE; + /*object->myDesc.Usage */ + object->myDesc.Pool = D3DPOOL_SYSTEMMEM ; + object->bytesPerPixel = bytesPerPixel(Format); + object->myDesc.Size = (Width * object->bytesPerPixel) * Height; + object->allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, object->myDesc.Size); + + TRACE("(%p) : w(%d) h(%d) fmt(%d) surf@%p, surfmem@%p, %d bytes\n", This, Width, Height, Format, *ppSurface, object->allocatedMemory, object->myDesc.Size); + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_CopyRects(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pSourceSurface,CONST RECT* pSourceRectsArray,UINT cRects, + IDirect3DSurface8* pDestinationSurface,CONST POINT* pDestPointsArray) { + + HRESULT rc = D3D_OK; + + IDirect3DSurface8Impl *src = (IDirect3DSurface8Impl*) pSourceSurface; + IDirect3DSurface8Impl *dst = (IDirect3DSurface8Impl*) pDestinationSurface; + + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) srcsur=%p, pSourceRects=%p, cRects=%d, pDstSur=%p, pDestPtsArr=%p\n", This, + pSourceSurface, pSourceRectsArray, cRects, pDestinationSurface, pDestPointsArray); + + if (src->myDesc.Format != dst->myDesc.Format) { + TRACE("Formats do not match %x / %x\n", src->myDesc.Format, dst->myDesc.Format); + rc = D3DERR_INVALIDCALL; + } + + /* Quick if complete copy ... */ + if (rc == D3D_OK && (cRects == 0 && pSourceRectsArray==NULL && pDestPointsArray==NULL && + src->myDesc.Width == dst->myDesc.Width && + src->myDesc.Height == dst->myDesc.Height)) { + TRACE("Direct copy as surfaces are equal, w=%d, h=%d\n", dst->myDesc.Width, dst->myDesc.Height); + memcpy(dst->allocatedMemory, src->allocatedMemory, src->myDesc.Size); + + } else { + FIXME("(%p) : stub\n", This); + } + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_UpdateTexture(LPDIRECT3DDEVICE8 iface, IDirect3DBaseTexture8* pSourceTexture,IDirect3DBaseTexture8* pDestinationTexture) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetFrontBuffer(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pDestSurface) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_SetRenderTarget(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pRenderTarget,IDirect3DSurface8* pNewZStencil) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetRenderTarget(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8** ppRenderTarget) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + /*TRACE("(%p) : returning %p\n", This, This->renderTarget); */ + FIXME("(%p) : stub\n", This); + + /* + **ppRenderTarget = (LPDIRECT3DSURFACE8) This->renderTarget; + *IDirect3DSurface8Impl_AddRef((LPDIRECT3DSURFACE8) *ppRenderTarget); + */ + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetDepthStencilSurface(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8** ppZStencilSurface) { + + ICOM_THIS(IDirect3DDevice8Impl,iface); + + /* Note inc ref on returned surface * + IDirect3DSurface8Impl_AddRef((LPDIRECT3DSURFACE8) *ppBackBuffer); */ + + FIXME("(%p) : stub\n", This); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice8Impl_BeginScene(LPDIRECT3DDEVICE8 iface) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : stub\n", This); + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_EndScene(LPDIRECT3DDEVICE8 iface) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p)\n", This); + + ENTER_GL(); + + glFlush(); + checkGLcall("glFlush"); + + /* Useful for debugging sometimes! + printf("Hit Enter ...\n"); + getchar(); */ + + LEAVE_GL(); + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_Clear(LPDIRECT3DDEVICE8 iface, DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + + /* TODO: From MSDN This method fails if you specify the D3DCLEAR_ZBUFFER or D3DCLEAR_STENCIL flags when the + render target does not have an attached depth buffer. Similarly, if you specify the D3DCLEAR_STENCIL flag + when the depth-buffer format does not contain stencil buffer information, this method fails. */ + GLbitfield glMask = 0; + int i; + CONST D3DRECT *curRect; + + TRACE("(%p) Count (%ld), pRects (%p), Flags (%lx), Z (%f), Stencil (%ld)\n", This, + Count, pRects, Flags, Z, Stencil); + + ENTER_GL(); + if (Count > 0 && pRects) { + glEnable(GL_SCISSOR_TEST); + checkGLcall("glEnable GL_SCISSOR_TEST"); + curRect = pRects; + } else { + curRect = NULL; + } + + for (i=0;i(%ld,%ld) glRect=(%ld,%ld), len=%ld, hei=%ld\n", This, curRect, + curRect->x1, curRect->y1, curRect->x2, curRect->y2, + curRect->x1, curRect->y2, curRect->x2 - curRect->x1, curRect->y2 - curRect->y1); + glScissor(curRect->x1, curRect->y2, curRect->x2 - curRect->x1, curRect->y2 - curRect->y1); + checkGLcall("glScissor"); + } else { + TRACE("Clearing screen with glClear to color %lx\n", Color); + } + + /* Clear the whole screen */ + if (Flags & D3DCLEAR_STENCIL) { + glClearStencil(Stencil); + checkGLcall("glClearStencil"); + glMask = glMask | GL_STENCIL_BUFFER_BIT; + } + + if (Flags & D3DCLEAR_ZBUFFER) { + glClearDepth(Z); + checkGLcall("glClearDepth"); + glMask = glMask | GL_DEPTH_BUFFER_BIT; + } + + if (Flags & D3DCLEAR_TARGET) { + glClearColor(((Color >> 16) & 0xFF) / 255.0, ((Color >> 8) & 0xFF) / 255.0, + ((Color >> 0) & 0xFF) / 255.0, ((Color >> 24) & 0xFF) / 255.0); + checkGLcall("glClearColor"); + glMask = glMask | GL_COLOR_BUFFER_BIT; + } + + glClear(glMask); + checkGLcall("glClear"); + + if (curRect) curRect = curRect + sizeof(D3DRECT); + } + + if (Count > 0 && pRects) { + glDisable(GL_SCISSOR_TEST); + checkGLcall("glDisable"); + } + LEAVE_GL(); + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_SetTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE d3dts,CONST D3DMATRIX* lpmatrix) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + + /* Most of this routine, comments included copied from ddraw tree initially: */ + TRACE("(%p) : State=%d\n", This, d3dts); + + This->UpdateStateBlock->Changed.transform[d3dts] = TRUE; + This->UpdateStateBlock->Set.transform[d3dts] = TRUE; + memcpy(&This->UpdateStateBlock->transforms[d3dts], lpmatrix, sizeof(D3DMATRIX)); + + /* Handle recording of state blocks */ + if (This->isRecordingState) { + TRACE("Recording... not performing anything\n"); + return D3D_OK; + } + + /* + ScreenCoord = ProjectionMat * ViewMat * WorldMat * ObjectCoord + + where ViewMat = Camera space, WorldMat = world space. + + In OpenGL, camera and world space is combined into GL_MODELVIEW + matrix. The Projection matrix stay projection matrix. */ + + /* After reading through both OpenGL and Direct3D documentations, I + thought that D3D matrices were written in 'line major mode' transposed + from OpenGL's 'column major mode'. But I found out that a simple memcpy + works fine to transfer one matrix format to the other (it did not work + when transposing).... + + So : + 1) are the documentations wrong + 2) does the matrix work even if they are not read correctly + 3) is Mesa's implementation of OpenGL not compliant regarding Matrix + loading using glLoadMatrix ? + + Anyway, I always use 'conv_mat' to transfer the matrices from one format + to the other so that if I ever find out that I need to transpose them, I + will able to do it quickly, only by changing the macro conv_mat. */ + + switch (d3dts) { + case D3DTS_WORLDMATRIX(0): { + conv_mat(lpmatrix, &This->StateBlock.transforms[D3DTS_WORLDMATRIX(0)]); + } break; + + case D3DTS_VIEW: { + conv_mat(lpmatrix, &This->StateBlock.transforms[D3DTS_VIEW]); + } break; + + case D3DTS_PROJECTION: { + conv_mat(lpmatrix, &This->StateBlock.transforms[D3DTS_PROJECTION]); + } break; + + default: + break; + } + + /* + * Move the GL operation to outside of switch to make it work + * regardless of transform set order. Optimize later. + */ + ENTER_GL(); + glMatrixMode(GL_PROJECTION); + checkGLcall("glMatrixMode"); + glLoadMatrixf((float *) &This->StateBlock.transforms[D3DTS_PROJECTION].u.m[0][0]); + checkGLcall("glLoadMatrixf"); + + glMatrixMode(GL_MODELVIEW); + checkGLcall("glMatrixMode"); + glLoadMatrixf((float *) &This->StateBlock.transforms[D3DTS_VIEW].u.m[0][0]); + checkGLcall("glLoadMatrixf"); + glMultMatrixf((float *) &This->StateBlock.transforms[D3DTS_WORLDMATRIX(0)].u.m[0][0]); + checkGLcall("glMultMatrixf"); + + LEAVE_GL(); + + return D3D_OK; + +} +HRESULT WINAPI IDirect3DDevice8Impl_GetTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : for State %d\n", This, State); + memcpy(pMatrix, &This->StateBlock.transforms[State], sizeof(D3DMATRIX)); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice8Impl_MultiplyTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_SetViewport(LPDIRECT3DDEVICE8 iface, CONST D3DVIEWPORT8* pViewport) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + + TRACE("(%p)\n", This); + This->UpdateStateBlock->Changed.viewport = TRUE; + This->UpdateStateBlock->Set.viewport = TRUE; + memcpy(&This->UpdateStateBlock->viewport, pViewport, sizeof(D3DVIEWPORT8)); + + /* Handle recording of state blocks */ + if (This->isRecordingState) { + TRACE("Recording... not performing anything\n"); + return D3D_OK; + } + + TRACE("(%p) : x=%ld, y=%ld, wid=%ld, hei=%ld, minz=%f, maxz=%f\n", This, + pViewport->X, pViewport->Y, pViewport->Width, pViewport->Height, pViewport->MinZ, pViewport->MaxZ); + + glDepthRange(pViewport->MinZ, pViewport->MaxZ); + checkGLcall("glDepthRange"); + /* Fixme? Note GL requires lower left, DirectX supplies upper left */ + glViewport(pViewport->X, pViewport->Y, pViewport->Width, pViewport->Height); + checkGLcall("glViewport"); + + + return D3D_OK; + +} +HRESULT WINAPI IDirect3DDevice8Impl_GetViewport(LPDIRECT3DDEVICE8 iface, D3DVIEWPORT8* pViewport) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p)\n", This); + memcpy(pViewport, &This->StateBlock.viewport, sizeof(D3DVIEWPORT8)); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice8Impl_SetMaterial(LPDIRECT3DDEVICE8 iface, CONST D3DMATERIAL8* pMaterial) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + + This->UpdateStateBlock->Changed.material = TRUE; + This->UpdateStateBlock->Set.material = TRUE; + memcpy(&This->UpdateStateBlock->material, pMaterial, sizeof(D3DMATERIAL8)); + + /* Handle recording of state blocks */ + if (This->isRecordingState) { + TRACE("Recording... not performing anything\n"); + return D3D_OK; + } + + ENTER_GL(); + 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); + + glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float *)&This->UpdateStateBlock->material.Ambient); + checkGLcall("glMaterialfv"); + glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float *)&This->UpdateStateBlock->material.Diffuse); + checkGLcall("glMaterialfv"); + + glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float *)&This->UpdateStateBlock->material.Specular); + checkGLcall("glMaterialfv"); + glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float *)&This->UpdateStateBlock->material.Emissive); + checkGLcall("glMaterialfv"); + glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, This->UpdateStateBlock->material.Power); + checkGLcall("glMaterialf"); + + LEAVE_GL(); + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetMaterial(LPDIRECT3DDEVICE8 iface, D3DMATERIAL8* pMaterial) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + memcpy(pMaterial, &This->UpdateStateBlock->material, sizeof (D3DMATERIAL8)); + 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 IDirect3DDevice8Impl_SetLight(LPDIRECT3DDEVICE8 iface, DWORD Index,CONST D3DLIGHT8* pLight) { + float colRGBA[] = {0.0, 0.0, 0.0, 0.0}; + float coords[] = {0.0, 0.0, 0.0, 0.0}; + + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : Idx(%ld), pLight(%p)\n", This, Index, pLight); + + TRACE("Light %ld setting to type %d, Diffuse(%f,%f,%f,%f), Specular(%f,%f,%f,%f), Ambient(%f,%f,%f,%f)\n", Index, pLight->Type, + pLight->Diffuse.r, pLight->Diffuse.g, pLight->Diffuse.b, pLight->Diffuse.a, + pLight->Specular.r, pLight->Specular.g, pLight->Specular.b, pLight->Specular.a, + pLight->Ambient.r, pLight->Ambient.g, pLight->Ambient.b, pLight->Ambient.a); + TRACE("... Pos(%f,%f,%f), Dirn(%f,%f,%f)\n", pLight->Position.x, pLight->Position.y, pLight->Position.z, + pLight->Direction.x, pLight->Direction.y, pLight->Direction.z); + TRACE("... Range(%f), Falloff(%f), Theta(%f), Phi(%f)\n", pLight->Range, pLight->Falloff, pLight->Theta, pLight->Phi); + + This->UpdateStateBlock->Changed.lights[Index] = TRUE; + This->UpdateStateBlock->Set.lights[Index] = TRUE; + memcpy(&This->UpdateStateBlock->lights[Index], pLight, sizeof(D3DLIGHT8)); + + /* Handle recording of state blocks */ + if (This->isRecordingState) { + TRACE("Recording... not performing anything\n"); + return D3D_OK; + } + + /* Diffuse: */ + colRGBA[0] = pLight->Diffuse.r; + colRGBA[1] = pLight->Diffuse.g; + colRGBA[2] = pLight->Diffuse.b; + colRGBA[3] = pLight->Diffuse.a; + glLightfv(GL_LIGHT0+Index, GL_DIFFUSE, colRGBA); + checkGLcall("glLightfv"); + + /* Specular */ + colRGBA[0] = pLight->Specular.r; + colRGBA[1] = pLight->Specular.g; + colRGBA[2] = pLight->Specular.b; + colRGBA[3] = pLight->Specular.a; + glLightfv(GL_LIGHT0+Index, GL_SPECULAR, colRGBA); + checkGLcall("glLightfv"); + + /* Ambient */ + colRGBA[0] = pLight->Ambient.r; + colRGBA[1] = pLight->Ambient.g; + colRGBA[2] = pLight->Ambient.b; + colRGBA[3] = pLight->Ambient.a; + glLightfv(GL_LIGHT0+Index, GL_AMBIENT, colRGBA); + checkGLcall("glLightfv"); + + /* Attenuation - Are these right? guessing... */ + glLightf(GL_LIGHT0+Index, GL_CONSTANT_ATTENUATION, pLight->Attenuation0); + checkGLcall("glLightf"); + glLightf(GL_LIGHT0+Index, GL_LINEAR_ATTENUATION, pLight->Attenuation1); + checkGLcall("glLightf"); + glLightf(GL_LIGHT0+Index, GL_QUADRATIC_ATTENUATION, pLight->Attenuation2); + checkGLcall("glLightf"); + + switch (pLight->Type) { + case D3DLIGHT_POINT: + /* Position */ + coords[0] = pLight->Position.x; + coords[1] = pLight->Position.y; + coords[2] = pLight->Position.z; + coords[3] = 1.0; + glLightfv(GL_LIGHT0+Index, GL_POSITION, coords); + checkGLcall("glLightfv"); + + /* FIXME: Range */ + break; + case D3DLIGHT_SPOT: + /* Position */ + coords[0] = pLight->Position.x; + coords[1] = pLight->Position.y; + coords[2] = pLight->Position.z; + coords[3] = 0.0; + glLightfv(GL_LIGHT0+Index, GL_POSITION, coords); + checkGLcall("glLightfv"); + + /* Direction */ + coords[0] = pLight->Direction.x; + coords[1] = pLight->Direction.y; + coords[2] = pLight->Direction.z; + coords[3] = 1.0; + glLightfv(GL_LIGHT0+Index, GL_SPOT_DIRECTION, coords); + checkGLcall("glLightfv"); + + /* FIXME: Range */ + break; + case D3DLIGHT_DIRECTIONAL: + /* Direction */ + coords[0] = -pLight->Direction.x; + coords[1] = pLight->Direction.y; + coords[2] = -pLight->Direction.z; + coords[3] = 0.0; + glLightfv(GL_LIGHT0+Index, GL_POSITION, coords); /* Note gl uses w position of 0 for direction! */ + checkGLcall("glLightfv"); + + glLightf(GL_LIGHT0+Index, GL_SPOT_CUTOFF, 180.0f); + glLightf(GL_LIGHT0+Index, GL_SPOT_EXPONENT, 0.0f); + + + break; + default: + FIXME("Unrecognized light type %d\n", pLight->Type); + } + + /* FIXME: Falloff, Theta, Phi; */ + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetLight(LPDIRECT3DDEVICE8 iface, DWORD Index,D3DLIGHT8* pLight) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : Idx(%ld), pLight(%p)\n", This, Index, pLight); + memcpy(pLight, &This->StateBlock.lights[Index], sizeof(D3DLIGHT8)); + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_LightEnable(LPDIRECT3DDEVICE8 iface, DWORD Index,BOOL Enable) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : Idx(%ld), enable? %d\n", This, Index, Enable); + + This->UpdateStateBlock->Changed.lightEnable[Index] = TRUE; + This->UpdateStateBlock->Set.lightEnable[Index] = TRUE; + This->UpdateStateBlock->lightEnable[Index] = Enable; + + /* Handle recording of state blocks */ + if (This->isRecordingState) { + TRACE("Recording... not performing anything\n"); + return D3D_OK; + } + + if (Enable) { + glEnable(GL_LIGHT0+Index); + checkGLcall("glEnable GL_LIGHT0+Index"); + } else { + glDisable(GL_LIGHT0+Index); + checkGLcall("glDisable GL_LIGHT0+Index"); + } + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetLightEnable(LPDIRECT3DDEVICE8 iface, DWORD Index,BOOL* pEnable) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : for idx(%ld)\n", This, Index); + *pEnable = This->StateBlock.lightEnable[Index]; + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_SetClipPlane(LPDIRECT3DDEVICE8 iface, DWORD Index,CONST float* pPlane) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : for idx %ld, %p\n", This, Index, pPlane); + + This->UpdateStateBlock->Changed.clipplane[Index] = TRUE; + This->UpdateStateBlock->Set.clipplane[Index] = TRUE; + This->UpdateStateBlock->clipplane[Index][0] = pPlane[0]; + This->UpdateStateBlock->clipplane[Index][1] = pPlane[1]; + This->UpdateStateBlock->clipplane[Index][2] = pPlane[2]; + This->UpdateStateBlock->clipplane[Index][3] = pPlane[3]; + + /* Handle recording of state blocks */ + if (This->isRecordingState) { + TRACE("Recording... not performing anything\n"); + return D3D_OK; + } + + /* Apply it */ + TRACE("Clipplane [%f,%f,%f,%f]\n", This->UpdateStateBlock->clipplane[Index][0], This->UpdateStateBlock->clipplane[Index][1], + This->UpdateStateBlock->clipplane[Index][2], This->UpdateStateBlock->clipplane[Index][3]); + glClipPlane(GL_CLIP_PLANE0+Index, This->UpdateStateBlock->clipplane[Index]); + checkGLcall("glClipPlane"); + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetClipPlane(LPDIRECT3DDEVICE8 iface, DWORD Index,float* pPlane) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : for idx %ld\n", This, Index); + pPlane[0] = This->StateBlock.clipplane[Index][0]; + pPlane[1] = This->StateBlock.clipplane[Index][0]; + pPlane[2] = This->StateBlock.clipplane[Index][0]; + pPlane[3] = This->StateBlock.clipplane[Index][0]; + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_SetRenderState(LPDIRECT3DDEVICE8 iface, D3DRENDERSTATETYPE State,DWORD Value) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p)->state = %d, value = %ld\n", This, State, Value); + + This->UpdateStateBlock->Changed.renderstate[State] = TRUE; + This->UpdateStateBlock->Set.renderstate[State] = TRUE; + This->UpdateStateBlock->renderstate[State] = Value; + + /* Handle recording of state blocks */ + if (This->isRecordingState) { + TRACE("Recording... not performing anything\n"); + return D3D_OK; + } + + switch (State) { + case D3DRS_FILLMODE : + switch ((D3DFILLMODE) Value) { + case D3DFILL_POINT : glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); break; + case D3DFILL_WIREFRAME : glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); break; + case D3DFILL_SOLID : glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); break; + default: + FIXME("Unrecognized D3DRS_FILLMODE value %ld\n", Value); + } + checkGLcall("glPolygonMode (fillmode)"); + break; + + case D3DRS_LIGHTING : + if (Value) { + glEnable(GL_LIGHTING); + checkGLcall("glEnable GL_LIGHTING"); + } else { + glDisable(GL_LIGHTING); + checkGLcall("glDisable GL_LIGHTING"); + } + break; + + case D3DRS_ZENABLE : + switch ((D3DZBUFFERTYPE) Value) { + case D3DZB_FALSE: + glDisable(GL_DEPTH_TEST); + checkGLcall("glDisable GL_DEPTH_TEST"); + break; + case D3DZB_TRUE: + glEnable(GL_DEPTH_TEST); + checkGLcall("glEnable GL_DEPTH_TEST"); + break; + + case D3DZB_USEW: + default: + FIXME("Unrecognized/Unhandled D3DZBUFFERTYPE value %ld\n", Value); + } + break; + + case D3DRS_CULLMODE : + switch ((D3DCULL) Value) { + case D3DCULL_NONE: + glDisable(GL_CULL_FACE); + checkGLcall("glDisable GL_CULL_FACE"); + break; + case D3DCULL_CW: + glEnable(GL_CULL_FACE); + checkGLcall("glEnable GL_CULL_FACE"); + glFrontFace(GL_CW); + checkGLcall("glFrontFace"); + break; + case D3DCULL_CCW: + glEnable(GL_CULL_FACE); + checkGLcall("glEnable GL_CULL_FACE"); + glFrontFace(GL_CW); + checkGLcall("glFrontFace GL_CULL_FACE"); + break; + default: + FIXME("Unrecognized/Unhandled D3DCULL value %ld\n", Value); + } + break; + + case D3DRS_SHADEMODE : + switch ((D3DSHADEMODE) Value) { + case D3DSHADE_FLAT: + glShadeModel(GL_FLAT); + checkGLcall("glShadeModel"); + break; + case D3DSHADE_GOURAUD: + glShadeModel(GL_SMOOTH); + checkGLcall("glShadeModel"); + break; + case D3DSHADE_PHONG: + FIXME("D3DSHADE_PHONG isnt supported?\n"); + return D3DERR_INVALIDCALL; + default: + FIXME("Unrecognized/Unhandled D3DSHADEMODE value %ld\n", Value); + } + break; + + case D3DRS_DITHERENABLE : + if (Value) { + glEnable(GL_DITHER); + checkGLcall("glEnable GL_DITHER"); + } else { + glDisable(GL_DITHER); + checkGLcall("glDisable GL_DITHER"); + } + break; + + case D3DRS_ZWRITEENABLE : + if (Value) { + glDepthMask(1); + checkGLcall("glDepthMask"); + } else { + glDepthMask(0); + checkGLcall("glDepthMask"); + } + break; + + case D3DRS_ZFUNC : + { + int glParm = GL_LESS; + + switch ((D3DCMPFUNC) Value) { + case D3DCMP_NEVER: glParm=GL_NEVER; break; + case D3DCMP_LESS: glParm=GL_LESS; break; + case D3DCMP_EQUAL: glParm=GL_EQUAL; break; + case D3DCMP_LESSEQUAL: glParm=GL_LEQUAL; break; + case D3DCMP_GREATER: glParm=GL_GREATER; break; + case D3DCMP_NOTEQUAL: glParm=GL_NOTEQUAL; break; + case D3DCMP_GREATEREQUAL: glParm=GL_GEQUAL; break; + case D3DCMP_ALWAYS: glParm=GL_ALWAYS; break; + default: + FIXME("Unrecognized/Unhandled D3DCMPFUNC value %ld\n", Value); + } + glDepthFunc(glParm); + checkGLcall("glDepthFunc"); + } + break; + + case D3DRS_AMBIENT : + { + + float col[4]; + col[0] = ((Value >> 16) & 0xFF) / 255.0; + col[1] = ((Value >> 8 ) & 0xFF) / 255.0; + col[2] = ((Value >> 0 ) & 0xFF) / 255.0; + col[3] = ((Value >> 24 ) & 0xFF) / 255.0; + TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0],col[1],col[2],col[3]); + glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col); + checkGLcall("glLightModel for MODEL_AMBIENT"); + + } + break; + + case D3DRS_ALPHABLENDENABLE : + if (Value) { + glEnable(GL_BLEND); + checkGLcall("glEnable GL_BLEND"); + } else { + glDisable(GL_BLEND); + checkGLcall("glDisable GL_BLEND"); + }; + break; + + case D3DRS_SRCBLEND : + case D3DRS_DESTBLEND : + { + int newVal = GL_ZERO; + switch (Value) { + case D3DBLEND_ZERO : newVal = GL_ZERO; break; + case D3DBLEND_ONE : newVal = GL_ONE; break; + case D3DBLEND_SRCCOLOR : newVal = GL_SRC_COLOR; break; + case D3DBLEND_INVSRCCOLOR : newVal = GL_ONE_MINUS_SRC_COLOR; break; + case D3DBLEND_SRCALPHA : newVal = GL_SRC_ALPHA; break; + case D3DBLEND_INVSRCALPHA : newVal = GL_ONE_MINUS_SRC_ALPHA; break; + case D3DBLEND_DESTALPHA : newVal = GL_DST_ALPHA; break; + case D3DBLEND_INVDESTALPHA : newVal = GL_ONE_MINUS_DST_ALPHA; break; + case D3DBLEND_DESTCOLOR : newVal = GL_DST_COLOR; break; + case D3DBLEND_INVDESTCOLOR : newVal = GL_ONE_MINUS_DST_COLOR; break; + case D3DBLEND_SRCALPHASAT : newVal = GL_SRC_ALPHA_SATURATE; break; + + case D3DBLEND_BOTHSRCALPHA : newVal = GL_SRC_ALPHA; + This->srcBlend = newVal; + This->dstBlend = newVal; + break; + + case D3DBLEND_BOTHINVSRCALPHA : newVal = GL_ONE_MINUS_SRC_ALPHA; + This->srcBlend = newVal; + This->dstBlend = newVal; + break; + default: + FIXME("Unrecognized src/dest blend value %ld (%d)\n", Value, State); + } + + if (State == D3DRS_SRCBLEND) This->srcBlend = newVal; + if (State == D3DRS_DESTBLEND) This->dstBlend = newVal; + TRACE("glBlendFunc src=%x, dst=%x\n", This->srcBlend, This->dstBlend); + glBlendFunc(This->srcBlend, This->dstBlend); + + checkGLcall("glBlendFunc"); + } + break; + + case D3DRS_ALPHATESTENABLE : + if (Value) { + glEnable(GL_ALPHA_TEST); + checkGLcall("glEnable GL_ALPHA_TEST"); + } else { + glDisable(GL_ALPHA_TEST); + checkGLcall("glDisable GL_ALPHA_TEST"); + } + break; + + case D3DRS_ALPHAREF : + { + int glParm = GL_LESS; + float ref = 1.0; + + glGetFloatv(GL_ALPHA_TEST_REF, &ref); + checkGLcall("glGetFloatv(GL_ALPHA_TEST_REF, &ref);"); + + switch ((D3DCMPFUNC) Value) { + case D3DCMP_NEVER: glParm=GL_NEVER; break; + case D3DCMP_LESS: glParm=GL_LESS; break; + case D3DCMP_EQUAL: glParm=GL_EQUAL; break; + case D3DCMP_LESSEQUAL: glParm=GL_LEQUAL; break; + case D3DCMP_GREATER: glParm=GL_GREATER; break; + case D3DCMP_NOTEQUAL: glParm=GL_NOTEQUAL; break; + case D3DCMP_GREATEREQUAL: glParm=GL_GEQUAL; break; + case D3DCMP_ALWAYS: glParm=GL_ALWAYS; break; + default: + FIXME("Unrecognized/Unhandled D3DCMPFUNC value %ld\n", Value); + } + break; + glAlphaFunc(glParm, ref); + checkGLcall("glAlphaFunc"); + } + break; + + case D3DRS_ALPHAFUNC : + { + int glParm = GL_LESS; + float ref = 1.0; + + glGetIntegerv(GL_ALPHA_TEST_FUNC, &glParm); + checkGLcall("glGetFloatv(GL_ALPHA_TEST_FUNC, &glParm);"); + + ref = ((float) Value) / 255.0; + glAlphaFunc(glParm, ref); + checkGLcall("glAlphaFunc"); + } + break; + + case D3DRS_CLIPPLANEENABLE : + { + int i = GL_CLIP_PLANE0; + DWORD tmp = Value; + + while (tmp) { + TRACE("Value %lx, %%2 = %lx, i=%x\n", tmp, tmp%2, i); + if (tmp%2) glEnable(i); + else glDisable(i); + checkGLcall("Enable/Disable clip planes"); + tmp = tmp>>1; + i++; + } + } + break; + + case D3DRS_BLENDOP : + { + int glParm = GL_FUNC_ADD; + + switch ((D3DBLENDOP) Value) { + case D3DBLENDOP_ADD : glParm = GL_FUNC_ADD; break; + case D3DBLENDOP_SUBTRACT : glParm = GL_FUNC_SUBTRACT; break; + case D3DBLENDOP_REVSUBTRACT : glParm = GL_FUNC_REVERSE_SUBTRACT; break; + case D3DBLENDOP_MIN : glParm = GL_MIN; break; + case D3DBLENDOP_MAX : glParm = GL_MAX; break; + default: + FIXME("Unrecognized/Unhandled D3DBLENDOP value %ld\n", Value); + } + glBlendEquation(glParm); + checkGLcall("glBlendEquation"); + } + break; + + case D3DRS_TEXTUREFACTOR : + { + /* noop - Just save away the texture color for now as it applies + to all textures whereas GL_TEXTURE_ENV_COLOR applies to active only */ + } + break; + + case D3DRS_SPECULARENABLE : /* Can opengl do this? */ + { + if (Value) { + glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR); + checkGLcall("glLightModel (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR);"); + } else { + glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR); + checkGLcall("glLightModel (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR);"); + } + } + break; + + /* Unhandled yet...! */ + case D3DRS_LINEPATTERN : + case D3DRS_LASTPIXEL : + case D3DRS_FOGENABLE : + case D3DRS_ZVISIBLE : + case D3DRS_FOGCOLOR : + case D3DRS_FOGTABLEMODE : + case D3DRS_FOGSTART : + case D3DRS_FOGEND : + case D3DRS_FOGDENSITY : + case D3DRS_EDGEANTIALIAS : + case D3DRS_ZBIAS : + case D3DRS_RANGEFOGENABLE : + case D3DRS_STENCILENABLE : + case D3DRS_STENCILFAIL : + case D3DRS_STENCILZFAIL : + case D3DRS_STENCILPASS : + case D3DRS_STENCILFUNC : + case D3DRS_STENCILREF : + case D3DRS_STENCILMASK : + case D3DRS_STENCILWRITEMASK : + case D3DRS_WRAP0 : + case D3DRS_WRAP1 : + case D3DRS_WRAP2 : + case D3DRS_WRAP3 : + case D3DRS_WRAP4 : + case D3DRS_WRAP5 : + case D3DRS_WRAP6 : + case D3DRS_WRAP7 : + case D3DRS_CLIPPING : + case D3DRS_FOGVERTEXMODE : + case D3DRS_COLORVERTEX : + case D3DRS_LOCALVIEWER : + case D3DRS_NORMALIZENORMALS : + case D3DRS_DIFFUSEMATERIALSOURCE : + case D3DRS_SPECULARMATERIALSOURCE : + case D3DRS_AMBIENTMATERIALSOURCE : + case D3DRS_EMISSIVEMATERIALSOURCE : + case D3DRS_VERTEXBLEND : + case D3DRS_SOFTWAREVERTEXPROCESSING : + case D3DRS_POINTSIZE : + case D3DRS_POINTSIZE_MIN : + case D3DRS_POINTSPRITEENABLE : + case D3DRS_POINTSCALEENABLE : + case D3DRS_POINTSCALE_A : + case D3DRS_POINTSCALE_B : + case D3DRS_POINTSCALE_C : + case D3DRS_MULTISAMPLEANTIALIAS : + case D3DRS_MULTISAMPLEMASK : + case D3DRS_PATCHEDGESTYLE : + case D3DRS_PATCHSEGMENTS : + case D3DRS_DEBUGMONITORTOKEN : + case D3DRS_POINTSIZE_MAX : + case D3DRS_INDEXEDVERTEXBLENDENABLE : + case D3DRS_COLORWRITEENABLE : + case D3DRS_TWEENFACTOR : + FIXME("(%p)->(%d,%ld) not handled yet\n", This, State, Value); + break; + default: + FIXME("(%p)->(%d,%ld) unrecognized\n", This, State, Value); + } + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetRenderState(LPDIRECT3DDEVICE8 iface, D3DRENDERSTATETYPE State,DWORD* pValue) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) for State %d = %ld\n", This, State, This->UpdateStateBlock->renderstate[State]); + *pValue = This->StateBlock.renderstate[State]; + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_BeginStateBlock(LPDIRECT3DDEVICE8 iface) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + + void *memory; + + TRACE("(%p)\n", This); + if (This->isRecordingState) { + TRACE("(%p) already recording! returning error\n", This); + return D3DERR_INVALIDCALL; + } + + /* Allocate Storage */ + memory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(STATEBLOCK)); + This->isRecordingState = TRUE; + This->UpdateStateBlock = memory; + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_EndStateBlock(LPDIRECT3DDEVICE8 iface, DWORD* pToken) { + + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p)\n", This); + + if (!This->isRecordingState) { + TRACE("(%p) not recording! returning error\n", This); + return D3DERR_INVALIDCALL; + } + + This->UpdateStateBlock->blockType = D3DSBT_RECORDED; + *pToken = (DWORD) This->UpdateStateBlock; + This->isRecordingState = FALSE; + This->UpdateStateBlock = &This->StateBlock; + + TRACE("(%p) returning token (ptr to stateblock) of %lx\n", This, *pToken); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice8Impl_ApplyStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token) { + + STATEBLOCK *pSB = (STATEBLOCK *)Token; + int i,j; + + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : Applying state block %lx\n", This, Token); + + /* FIXME: Only apply applicable states not all states */ + + if (pSB->blockType == D3DSBT_RECORDED || pSB->blockType == D3DSBT_ALL || pSB->blockType == D3DSBT_VERTEXSTATE) { + + for (i=0; iSet.lightEnable[i] && pSB->Changed.lightEnable[i]) + IDirect3DDevice8Impl_LightEnable(iface, i, pSB->lightEnable[i]); + if (pSB->Set.lights[i] && pSB->Changed.lights[i]) + IDirect3DDevice8Impl_SetLight(iface, i, &pSB->lights[i]); + } + + if (pSB->Set.vertexShader && pSB->Changed.vertexShader) + IDirect3DDevice8Impl_SetVertexShader(iface, pSB->VertexShader); + + /* TODO: Vertex Shader Constants */ + } + + if (pSB->blockType == D3DSBT_RECORDED || pSB->blockType == D3DSBT_ALL || pSB->blockType == D3DSBT_PIXELSTATE) { + + if (pSB->Set.pixelShader && pSB->Changed.pixelShader) + IDirect3DDevice8Impl_SetVertexShader(iface, pSB->PixelShader); + + /* TODO: Pixel Shader Constants */ + } + + /* Others + Render & Texture */ + if (pSB->blockType == D3DSBT_RECORDED || pSB->blockType == D3DSBT_ALL) { + for (i=0; iSet.transform[i] && pSB->Changed.transform[i]) + IDirect3DDevice8Impl_SetTransform(iface, i, &pSB->transforms[i]); + } + + if (pSB->Set.Indices && pSB->Changed.Indices) + IDirect3DDevice8Impl_SetIndices(iface, pSB->pIndexData, pSB->baseVertexIndex); + + if (pSB->Set.material && pSB->Changed.material) + IDirect3DDevice8Impl_SetMaterial(iface, &pSB->material); + + if (pSB->Set.viewport && pSB->Changed.viewport) + IDirect3DDevice8Impl_SetViewport(iface, &pSB->viewport); + + for (i=0; iSet.stream_source[i] && pSB->Changed.stream_source[i]) + IDirect3DDevice8Impl_SetStreamSource(iface, i, pSB->stream_source[i], pSB->stream_stride[i]); + } + + for (i=0; iSet.clipplane[i] && pSB->Changed.clipplane[i]) { + float clip[4]; + + clip[0] = pSB->clipplane[i][0]; + clip[1] = pSB->clipplane[i][1]; + clip[2] = pSB->clipplane[i][2]; + clip[3] = pSB->clipplane[i][3]; + IDirect3DDevice8Impl_SetClipPlane(iface, i, clip); + } + } + + /* Render */ + for (i=0; iStateBlock.Set.renderstate[i] && pSB->Changed.renderstate[i]) + IDirect3DDevice8Impl_SetRenderState(iface, i, pSB->renderstate[i]); + + } + + /* Texture */ + for (j=0; j<8; j++) { + for (i=0; iStateBlock.Set.texture_state[j][i] && pSB->Changed.texture_state[j][i]) + IDirect3DDevice8Impl_SetTextureStageState(iface, j, i, pSB->texture_state[j][i]); + } + + } + + } else if (pSB->blockType == D3DSBT_PIXELSTATE) { + + for (i=0; iStateBlock.Set.renderstate[SavedPixelStates_R[i]] && pSB->Changed.renderstate[SavedPixelStates_R[i]]) + IDirect3DDevice8Impl_SetRenderState(iface, SavedPixelStates_R[i], pSB->renderstate[SavedPixelStates_R[i]]); + + } + + for (j=0; j<8; i++) { + for (i=0; iStateBlock.Set.texture_state[j][SavedPixelStates_T[i]] && + pSB->Changed.texture_state[j][SavedPixelStates_T[i]]) + IDirect3DDevice8Impl_SetTextureStageState(iface, j, SavedPixelStates_T[i], pSB->texture_state[j][SavedPixelStates_T[i]]); + } + } + + } else if (pSB->blockType == D3DSBT_VERTEXSTATE) { + + for (i=0; iStateBlock.Set.renderstate[SavedVertexStates_R[i]] && pSB->Changed.renderstate[SavedVertexStates_R[i]]) + IDirect3DDevice8Impl_SetRenderState(iface, SavedVertexStates_R[i], pSB->renderstate[SavedVertexStates_R[i]]); + + } + + for (j=0; j<8; i++) { + for (i=0; iStateBlock.Set.texture_state[j][SavedVertexStates_T[i]] && + pSB->Changed.texture_state[j][SavedVertexStates_T[i]]) + IDirect3DDevice8Impl_SetTextureStageState(iface, j, SavedVertexStates_T[i], pSB->texture_state[j][SavedVertexStates_T[i]]); + } + } + + + } else { + FIXME("Unrecognized state block type %d\n", pSB->blockType); + } + memcpy(&This->StateBlock.Changed, &pSB->Changed, sizeof(This->StateBlock.Changed)); + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_CaptureStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token) { + + STATEBLOCK *updateBlock = (STATEBLOCK *)Token; + + ICOM_THIS(IDirect3DDevice8Impl,iface); + + TRACE("(%p) : Updating state block %lx\n", This, Token); + + /* If not recorded, then update can just recapture */ + if (updateBlock->blockType != D3DSBT_RECORDED) { + DWORD tmpToken; + STATEBLOCK *tmpBlock; + IDirect3DDevice8Impl_CreateStateBlock(iface, updateBlock->blockType, &tmpToken); + tmpBlock = (STATEBLOCK *)tmpToken; + memcpy(updateBlock, tmpBlock, sizeof(STATEBLOCK)); + IDirect3DDevice8Impl_DeleteStateBlock(iface, tmpToken); + + /* FIXME: This will record states of new lights! May need to have and save set_lights + across this action */ + + } else { + + /* Recorded => Only update 'changed' values + FIXME: Currently implementation just copies the whole state block, because + then 'changed' flags were copied in when the block was applied, so the new state + block will just have more changed flags set! This will break if + state A is applied, then state B is applied, then state A is captured. */ + memcpy(updateBlock, &This->StateBlock, sizeof(STATEBLOCK)); + } + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_DeleteStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : freeing token %lx\n", This, Token); + HeapFree(GetProcessHeap(), 0, (void *)Token); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice8Impl_CreateStateBlock(LPDIRECT3DDEVICE8 iface, D3DSTATEBLOCKTYPE Type,DWORD* pToken) { + void *memory; + STATEBLOCK *s; + int i,j; + + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : for type %d\n", This, Type); + + /* Allocate Storage */ + memory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(STATEBLOCK)); + if (memory) memcpy(memory, &This->StateBlock, sizeof(STATEBLOCK)); + *pToken = (DWORD) memory; + s = memory; + s->blockType = Type; + + TRACE("Updating changed flags appropriate for type %d\n", Type); + + if (Type == D3DSBT_ALL) { + TRACE("ALL => Pretend everything has changed\n"); + memset(&s->Changed, TRUE, sizeof(This->StateBlock.Changed)); + + } else if (Type == D3DSBT_PIXELSTATE) { + + memset(&s->Changed, FALSE, sizeof(This->StateBlock.Changed)); + + /* TODO: Pixel Shader Constants */ + s->Changed.pixelShader = TRUE; + for (i=0; iChanged.renderstate[SavedPixelStates_R[i]] = TRUE; + } + for (j=0; j<8; i++) { + for (i=0; iChanged.texture_state[j][SavedPixelStates_T[i]] = TRUE; + } + } + + } else if (Type == D3DSBT_VERTEXSTATE) { + + memset(&s->Changed, FALSE, sizeof(This->StateBlock.Changed)); + + /* TODO: Vertex Shader Constants */ + s->Changed.vertexShader = TRUE; + + for (i=0; iChanged.renderstate[SavedVertexStates_R[i]] = TRUE; + } + for (j=0; j<8; i++) { + for (i=0; iChanged.texture_state[j][SavedVertexStates_T[i]] = TRUE; + } + } + + for (i=0; iChanged.lightEnable[i] = TRUE; + s->Changed.lights[i] = TRUE; + } + + } else { + FIXME("Unrecognized state block type %d\n", Type); + } + TRACE("(%p) returning token (ptr to stateblock) of %lx\n", This, *pToken); + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice8Impl_SetClipStatus(LPDIRECT3DDEVICE8 iface, CONST D3DCLIPSTATUS8* pClipStatus) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetClipStatus(LPDIRECT3DDEVICE8 iface, D3DCLIPSTATUS8* pClipStatus) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetTexture(LPDIRECT3DDEVICE8 iface, DWORD Stage,IDirect3DBaseTexture8** ppTexture) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : returning %p for stage %ld\n", This, This->StateBlock.textures[Stage], Stage); + *ppTexture = (LPDIRECT3DBASETEXTURE8)This->StateBlock.textures[Stage]; + IDirect3DBaseTexture8Impl_AddRef(*ppTexture); + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_SetTexture(LPDIRECT3DDEVICE8 iface, DWORD Stage,IDirect3DBaseTexture8* pTexture) { + + IDirect3DBaseTexture8 *oldTxt; + + ICOM_THIS(IDirect3DDevice8Impl,iface); + D3DRESOURCETYPE textureType; + + oldTxt = This->StateBlock.textures[Stage]; + TRACE("(%p) : Stage(%ld), Texture (%p)\n", This, Stage, pTexture); + + This->UpdateStateBlock->Set.textures[Stage] = TRUE; + This->UpdateStateBlock->Changed.textures[Stage] = TRUE; + This->UpdateStateBlock->textures[Stage] = pTexture; + + /* Handle recording of state blocks */ + if (This->isRecordingState) { + TRACE("Recording... not performing anything\n"); + return D3D_OK; + } + + /* Make appropriate texture active */ + glActiveTextureARB(GL_TEXTURE0_ARB + Stage); + checkGLcall("glActiveTextureARB"); + + /* Decrement the count of the previous texture */ + if (oldTxt != NULL) { + IDirect3DBaseTexture8Impl_Release(oldTxt); + } + + if (pTexture) { + IDirect3DBaseTexture8Impl_AddRef((LPDIRECT3DBASETEXTURE8)This->StateBlock.textures[Stage]); + + /* Now setup the texture appropraitly */ + textureType = IDirect3DBaseTexture8Impl_GetType(pTexture); + + if (textureType == D3DRTYPE_TEXTURE) { + IDirect3DTexture8Impl *pTexture2 = (IDirect3DTexture8Impl *) pTexture; + int i; + + /* Standard 2D texture */ + TRACE("Standard 2d texture\n"); +/* for (i=0; ilevels; i++) { */ + i=0; + { + + if (pTexture2->surfaces[i]->textureName != 0 && pTexture2->Dirty == FALSE) { + glBindTexture(GL_TEXTURE_2D, pTexture2->surfaces[i]->textureName); + checkGLcall("glBindTexture"); + TRACE("Texture %p given name %d\n", pTexture2->surfaces[i], pTexture2->surfaces[i]->textureName); + } else { + + if (pTexture2->surfaces[i]->textureName == 0) { + glGenTextures(1, &pTexture2->surfaces[i]->textureName); + checkGLcall("glGenTextures"); + TRACE("Texture %p given name %d\n", pTexture2->surfaces[i], pTexture2->surfaces[i]->textureName); + } + + glBindTexture(GL_TEXTURE_2D, pTexture2->surfaces[i]->textureName); + checkGLcall("glBindTexture"); + + TRACE("Calling glTexImage2D %x i=%d, intfmt=%x, w=%d, h=%d,0=%d, glFmt=%x, glType=%lx, Mem=%p\n", + GL_TEXTURE_2D, i, fmt2glintFmt(pTexture2->format), pTexture2->surfaces[i]->myDesc.Width, + pTexture2->surfaces[i]->myDesc.Height, 0, fmt2glFmt(pTexture2->format),fmt2glType(pTexture2->format), + pTexture2->surfaces[i]->allocatedMemory); + glTexImage2D(GL_TEXTURE_2D, i, + fmt2glintFmt(pTexture2->format), + pTexture2->surfaces[i]->myDesc.Width, + pTexture2->surfaces[i]->myDesc.Height, + 0, + fmt2glFmt(pTexture2->format), + fmt2glType(pTexture2->format), + pTexture2->surfaces[i]->allocatedMemory + ); + checkGLcall("glTexImage2D"); + + /* + * The following enable things to work but I dont think + * they all go here - FIXME! @@@ + */ + glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); + glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); + glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + /*glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);*/ + glEnable(GL_TEXTURE_2D); + checkGLcall("glEnable"); + + pTexture2->Dirty = FALSE; + } + } + } else { + FIXME("(%p) : stub\n", This); + } + } + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice8Impl_GetTextureStageState(LPDIRECT3DDEVICE8 iface, DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : requesting Stage %ld, Type %d getting %ld\n", This, Stage, Type, This->StateBlock.texture_state[Stage][Type]); + *pValue = This->StateBlock.texture_state[Stage][Type]; + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice8Impl_SetTextureStageState(LPDIRECT3DDEVICE8 iface, DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + + TRACE("(%p) : stub, Stage=%ld, Type=%d, Value =%ld\n", This, Stage, Type, Value); + + This->UpdateStateBlock->Changed.texture_state[Stage][Type] = TRUE; + This->UpdateStateBlock->Set.texture_state[Stage][Type] = TRUE; + This->UpdateStateBlock->texture_state[Stage][Type] = Value; + + /* Handle recording of state blocks */ + if (This->isRecordingState) { + TRACE("Recording... not performing anything\n"); + return D3D_OK; + } + + /* Make appropriate texture active */ + TRACE("Activating appropriate texture state\n"); + glActiveTextureARB(GL_TEXTURE0_ARB + Stage); + checkGLcall("glActiveTextureARB"); + + switch (Type) { + + case D3DTSS_MINFILTER : + if (Value == D3DTEXF_POINT) { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + checkGLcall("glTexParameter GL_TEXTURE_MINFILTER, GL_NEAREST"); + } else if (Value == D3DTEXF_LINEAR) { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + checkGLcall("glTexParameter GL_TEXTURE_MINFILTER, GL_LINEAR"); + } else { + FIXME("Unhandled D3DTSS_MINFILTER value of %ld\n", Value); + } + break; + + + case D3DTSS_MAGFILTER : + if (Value == D3DTEXF_POINT) { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + checkGLcall("glTexParameter GL_TEXTURE_MAGFILTER, GL_NEAREST"); + } else if (Value == D3DTEXF_LINEAR) { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + checkGLcall("glTexParameter GL_TEXTURE_MAGFILTER, GL_LINEAR"); + } else { + FIXME("Unhandled D3DTSS_MAGFILTER value of %ld\n", Value); + } + break; + + case D3DTSS_COLORARG1 : + case D3DTSS_COLORARG2 : + case D3DTSS_COLORARG0 : + case D3DTSS_ALPHAARG1 : + case D3DTSS_ALPHAARG2 : + case D3DTSS_ALPHAARG0 : + { + BOOL isAlphaReplicate = FALSE; + BOOL isComplement = FALSE; + BOOL isAlphaArg = (Type == D3DTSS_ALPHAARG1 || Type == D3DTSS_ALPHAARG2 || Type == D3DTSS_ALPHAARG0); + int operand= GL_SRC_COLOR; + int source = GL_TEXTURE; + + TRACE("Type %d : %ld\n", Type, Value); + + /* Catch alpha replicate */ + if (Value & D3DTA_ALPHAREPLICATE) { + Value = Value & ~D3DTA_ALPHAREPLICATE; + isAlphaReplicate = TRUE; + } + + /* Catch Complement */ + if (Value & D3DTA_COMPLEMENT) { + Value = Value & ~D3DTA_COMPLEMENT; + isComplement = TRUE; + } + + /* Calculate the operand */ + if (isAlphaReplicate && !isComplement) { + operand = GL_SRC_ALPHA; + } else if (isAlphaReplicate && isComplement) { + operand = GL_ONE_MINUS_SRC_ALPHA; + } else if (isComplement) { + if (isAlphaArg) { + operand = GL_ONE_MINUS_SRC_COLOR; + } else { + operand = GL_ONE_MINUS_SRC_ALPHA; + } + } else { + if (isAlphaArg) { + operand = GL_SRC_ALPHA; + } else { + operand = GL_SRC_COLOR; + } + } + + /* Calculate the source */ + switch (Value) { + case D3DTA_CURRENT: source = GL_PREVIOUS_EXT; + break; + case D3DTA_DIFFUSE: source = GL_PRIMARY_COLOR_EXT; + break; + case D3DTA_TEXTURE: source = GL_TEXTURE; + break; + case D3DTA_TFACTOR: { + float col[4]; + + source = GL_CONSTANT_EXT; + + /* Note the D3DRS value applies to all textures, but GL has one + per texture, so apply it now ready to be used! */ + col[0] = ((This->StateBlock.renderstate[D3DRS_TEXTUREFACTOR] >> 16) & 0xFF) / 255.0; + col[1] = ((This->StateBlock.renderstate[D3DRS_TEXTUREFACTOR] >> 8 ) & 0xFF) / 255.0; + col[2] = ((This->StateBlock.renderstate[D3DRS_TEXTUREFACTOR] >> 0 ) & 0xFF) / 255.0; + col[3] = ((This->StateBlock.renderstate[D3DRS_TEXTUREFACTOR] >> 24 ) & 0xFF) / 255.0; + glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]); + checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);"); + } + break; + + /* According to the GL_ARB_texture_env_combine specs, SPECULAR is 'Secondary color' and + isnt supported until base GL supports it + There is no concept of temp registers as far as I can tell */ + + default: + FIXME("Unrecognized or unhandled texture arg %ld\n", Value); + } + + if (isAlphaArg) { + glTexEnvi(GL_TEXTURE_ENV, SOURCEx_ALPHA_EXT(Type), source); + checkGLcall("glTexEnvi(GL_TEXTURE_ENV, SOURCEx_ALPHA_EXT, source);"); + glTexEnvi(GL_TEXTURE_ENV, OPERANDx_ALPHA_EXT(Type), operand); + checkGLcall("glTexEnvi(GL_TEXTURE_ENV, OPERANDx_ALPHA_EXT, operand);"); + } else { + glTexEnvi(GL_TEXTURE_ENV, SOURCEx_RGB_EXT(Type), source); + checkGLcall("glTexEnvi(GL_TEXTURE_ENV, SOURCEx_RGB_EXT, source);"); + glTexEnvi(GL_TEXTURE_ENV, OPERANDx_RGB_EXT(Type), operand); + checkGLcall("glTexEnvi(GL_TEXTURE_ENV, OPERANDx_RGB_EXT, operand);"); + } + } + break; + + case D3DTSS_ALPHAOP : + case D3DTSS_COLOROP : + { + + int Scale = 1; + int Parm = (Type == D3DTSS_ALPHAOP)? GL_COMBINE_ALPHA_EXT : GL_COMBINE_RGB_EXT; + + switch (Value) { + case D3DTOP_SELECTARG1 : + glTexEnvi(GL_TEXTURE_ENV, Parm, GL_REPLACE); + break; + + case D3DTOP_MODULATE4X : Scale = Scale * 2; /* Drop through */ + case D3DTOP_MODULATE2X : Scale = Scale * 2; /* Drop through */ + case D3DTOP_MODULATE : + + /* Correct scale */ + if (Type == D3DTSS_ALPHAOP) glTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, Scale); + else glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, Scale); + + glTexEnvi(GL_TEXTURE_ENV, Parm, GL_MODULATE); + break; + + case D3DTOP_ADD : + glTexEnvi(GL_TEXTURE_ENV, Parm, GL_ADD); + break; + + + case D3DTOP_ADDSIGNED2X : Scale = Scale * 2; /* Drop through */ + case D3DTOP_ADDSIGNED : + glTexEnvi(GL_TEXTURE_ENV, Parm, GL_ADD_SIGNED_EXT); + break; + + + case D3DTOP_SUBTRACT : + /* glTexEnvi(GL_TEXTURE_ENV, Parm, GL_SUBTRACT); Missing? */ + case D3DTOP_DISABLE : + case D3DTOP_SELECTARG2 : + /* GL_REPLACE, swap args 0 and 1? */ + case D3DTOP_ADDSMOOTH : + case D3DTOP_BLENDDIFFUSEALPHA : + case D3DTOP_BLENDTEXTUREALPHA : + case D3DTOP_BLENDFACTORALPHA : + case D3DTOP_BLENDTEXTUREALPHAPM : + case D3DTOP_BLENDCURRENTALPHA : + case D3DTOP_PREMODULATE : + case D3DTOP_MODULATEALPHA_ADDCOLOR : + case D3DTOP_MODULATECOLOR_ADDALPHA : + case D3DTOP_MODULATEINVALPHA_ADDCOLOR : + case D3DTOP_MODULATEINVCOLOR_ADDALPHA : + case D3DTOP_BUMPENVMAP : + case D3DTOP_BUMPENVMAPLUMINANCE : + case D3DTOP_DOTPRODUCT3 : + case D3DTOP_MULTIPLYADD : + case D3DTOP_LERP : + default: + FIXME("Unhandled texture operation %ld\n", Value); + } + break; + } + + /* Unhandled */ + case D3DTSS_BUMPENVMAT00 : + case D3DTSS_BUMPENVMAT01 : + case D3DTSS_BUMPENVMAT10 : + case D3DTSS_BUMPENVMAT11 : + case D3DTSS_TEXCOORDINDEX : + case D3DTSS_ADDRESSU : + case D3DTSS_ADDRESSV : + case D3DTSS_BORDERCOLOR : + case D3DTSS_MIPFILTER : + case D3DTSS_MIPMAPLODBIAS : + case D3DTSS_MAXMIPLEVEL : + case D3DTSS_MAXANISOTROPY : + case D3DTSS_BUMPENVLSCALE : + case D3DTSS_BUMPENVLOFFSET : + case D3DTSS_TEXTURETRANSFORMFLAGS : + case D3DTSS_ADDRESSW : + case D3DTSS_RESULTARG : + default: + FIXME("(%p) : stub, Stage=%ld, Type=%d, Value =%ld\n", This, Stage, Type, Value); + } + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_ValidateDevice(LPDIRECT3DDEVICE8 iface, DWORD* pNumPasses) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetInfo(LPDIRECT3DDEVICE8 iface, DWORD DevInfoID,void* pDevInfoStruct,DWORD DevInfoStructSize) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_SetPaletteEntries(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber,CONST PALETTEENTRY* pEntries) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetPaletteEntries(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber,PALETTEENTRY* pEntries) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_SetCurrentTexturePalette(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetCurrentTexturePalette(LPDIRECT3DDEVICE8 iface, UINT *PaletteNumber) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_DrawPrimitive(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount) { + + IDirect3DVertexBuffer8 *pVB; + D3DVERTEXBUFFER_DESC VtxBufDsc; + + ICOM_THIS(IDirect3DDevice8Impl,iface); + pVB = This->StateBlock.stream_source[0]; + + TRACE("(%p) : Type=%d, Start=%d, Count=%d\n", This, PrimitiveType, StartVertex, PrimitiveCount); + + IDirect3DVertexBuffer8Impl_GetDesc(pVB, &VtxBufDsc); + DrawPrimitiveI(iface, PrimitiveType, PrimitiveCount, FALSE, + VtxBufDsc.FVF, ((IDirect3DVertexBuffer8Impl *)pVB)->allocatedMemory, StartVertex, -1, 0, NULL); + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_DrawIndexedPrimitive(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType, + UINT minIndex,UINT NumVertices,UINT startIndex,UINT primCount) { + UINT idxStride = 2; + IDirect3DIndexBuffer8 *pIB; + IDirect3DVertexBuffer8 *pVB; + D3DINDEXBUFFER_DESC IdxBufDsc; + D3DVERTEXBUFFER_DESC VtxBufDsc; + + ICOM_THIS(IDirect3DDevice8Impl,iface); + pIB = This->StateBlock.pIndexData; + pVB = This->StateBlock.stream_source[0]; + + TRACE("(%p) : Type=%d, min=%d, CountV=%d, startIdx=%d, countP=%d \n", This, PrimitiveType, + minIndex, NumVertices, startIndex, primCount); + + IDirect3DIndexBuffer8Impl_GetDesc(pIB, &IdxBufDsc); + if (IdxBufDsc.Format == D3DFMT_INDEX16) { + idxStride = 2; + } else { + idxStride = 4; + } + + IDirect3DVertexBuffer8Impl_GetDesc(pVB, &VtxBufDsc); + DrawPrimitiveI(iface, PrimitiveType, primCount, TRUE, VtxBufDsc.FVF, ((IDirect3DVertexBuffer8Impl *)pVB)->allocatedMemory, + This->StateBlock.baseVertexIndex, startIndex, idxStride, ((IDirect3DIndexBuffer8Impl *) pIB)->allocatedMemory); + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_DrawPrimitiveUP(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + + TRACE("(%p) : Type=%d, pCount=%d, pVtxData=%p, Stride=%d\n", This, PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride); + + if (This->StateBlock.stream_source[0] != NULL) IDirect3DVertexBuffer8Impl_Release(This->StateBlock.stream_source[0]); + + This->StateBlock.stream_source[0] = NULL; + This->StateBlock.stream_stride[0] = VertexStreamZeroStride; + DrawPrimitiveI(iface, PrimitiveType, PrimitiveCount, FALSE, This->StateBlock.VertexShader, pVertexStreamZeroData, + 0, 0, 0, NULL); + This->StateBlock.stream_stride[0] = 0; + + /*stream zero settings set to null at end */ + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_DrawIndexedPrimitiveUP(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex, + UINT NumVertexIndices,UINT PrimitiveCount,CONST void* pIndexData, + D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData, + UINT VertexStreamZeroStride) { + int idxStride; + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : Type=%d, MinVtxIdx=%d, NumVIdx=%d, PCount=%d, pidxdata=%p, IdxFmt=%d, pVtxdata=%p, stride=%d\n", This, PrimitiveType, + MinVertexIndex, NumVertexIndices, PrimitiveCount, pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride); + + if (This->StateBlock.stream_source[0] != NULL) IDirect3DVertexBuffer8Impl_Release(This->StateBlock.stream_source[0]); + if (IndexDataFormat == D3DFMT_INDEX16) { + idxStride = 2; + } else { + idxStride = 4; + } + + This->StateBlock.stream_source[0] = NULL; + This->StateBlock.stream_stride[0] = VertexStreamZeroStride; + DrawPrimitiveI(iface, PrimitiveType, PrimitiveCount, TRUE, This->StateBlock.VertexShader, pVertexStreamZeroData, + This->StateBlock.baseVertexIndex, 0, idxStride, pIndexData); + + /*stream zero settings set to null at end */ + This->StateBlock.stream_stride[0] = 0; + IDirect3DDevice8Impl_SetIndices(iface, NULL, 0); + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_ProcessVertices(LPDIRECT3DDEVICE8 iface, UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer8* pDestBuffer,DWORD Flags) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_CreateVertexShader(LPDIRECT3DDEVICE8 iface, CONST DWORD* pDeclaration,CONST DWORD* pFunction,DWORD* pHandle,DWORD Usage) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShader(LPDIRECT3DDEVICE8 iface, DWORD Handle) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + + This->UpdateStateBlock->VertexShader = Handle; + 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; + } + + if (Handle <= VS_HIGHESTFIXEDFXF) { + TRACE("(%p) : FVF Shader, Handle=%ld\n", This, Handle); + return D3D_OK; + } else { + FIXME("(%p) : Created shader, Handle=%lx stub\n", This, Handle); + return D3D_OK; + } +} +HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShader(LPDIRECT3DDEVICE8 iface, DWORD* pHandle) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) = %ld\n", This, This->StateBlock.VertexShader); + *pHandle = This->StateBlock.VertexShader; + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice8Impl_DeleteVertexShader(LPDIRECT3DDEVICE8 iface, DWORD Handle) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register,CONST void* pConstantData,DWORD ConstantCount) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register,void* pConstantData,DWORD ConstantCount) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderDeclaration(LPDIRECT3DDEVICE8 iface, DWORD Handle,void* pData,DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderFunction(LPDIRECT3DDEVICE8 iface, DWORD Handle,void* pData,DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice8Impl_SetIndices(LPDIRECT3DDEVICE8 iface, IDirect3DIndexBuffer8* pIndexData,UINT BaseVertexIndex) { + + IDirect3DIndexBuffer8 *oldIdxs; + + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : Setting to %p, base %d\n", This, pIndexData, BaseVertexIndex); + oldIdxs = This->StateBlock.pIndexData; + + This->UpdateStateBlock->Changed.Indices = TRUE; + This->UpdateStateBlock->Set.Indices = TRUE; + This->UpdateStateBlock->pIndexData = pIndexData; + This->UpdateStateBlock->baseVertexIndex = BaseVertexIndex; + + /* Handle recording of state blocks */ + if (This->isRecordingState) { + TRACE("Recording... not performing anything\n"); + return D3D_OK; + } + + if (oldIdxs) IDirect3DIndexBuffer8Impl_Release(oldIdxs); + if (pIndexData) IDirect3DIndexBuffer8Impl_AddRef(This->StateBlock.pIndexData); + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetIndices(LPDIRECT3DDEVICE8 iface, IDirect3DIndexBuffer8** ppIndexData,UINT* pBaseVertexIndex) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); + + *ppIndexData = This->StateBlock.pIndexData; + /* up ref count on ppindexdata */ + if (*ppIndexData) IDirect3DIndexBuffer8Impl_AddRef(*ppIndexData); + *pBaseVertexIndex = This->StateBlock.baseVertexIndex; + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_CreatePixelShader(LPDIRECT3DDEVICE8 iface, CONST DWORD* pFunction,DWORD* pHandle) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_SetPixelShader(LPDIRECT3DDEVICE8 iface, DWORD Handle) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + + This->UpdateStateBlock->PixelShader = Handle; + 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; + } + + FIXME("(%p) : stub\n", This); + + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShader(LPDIRECT3DDEVICE8 iface, DWORD* pHandle) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + TRACE("(%p) : returning %ld\n", This, This->StateBlock.PixelShader); + *pHandle = This->StateBlock.PixelShader; + return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice8Impl_DeletePixelShader(LPDIRECT3DDEVICE8 iface, DWORD Handle) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_SetPixelShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register,CONST void* pConstantData,DWORD ConstantCount) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register,void* pConstantData,DWORD ConstantCount) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShaderFunction(LPDIRECT3DDEVICE8 iface, DWORD Handle,void* pData,DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_DrawRectPatch(LPDIRECT3DDEVICE8 iface, UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_DrawTriPatch(LPDIRECT3DDEVICE8 iface, UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_DeletePatch(LPDIRECT3DDEVICE8 iface, UINT Handle) { + ICOM_THIS(IDirect3DDevice8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} + +HRESULT WINAPI IDirect3DDevice8Impl_SetStreamSource(LPDIRECT3DDEVICE8 iface, UINT StreamNumber,IDirect3DVertexBuffer8* pStreamData,UINT Stride) { + IDirect3DVertexBuffer8 *oldSrc; + ICOM_THIS(IDirect3DDevice8Impl,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) IDirect3DVertexBuffer8Impl_Release(oldSrc); + if (pStreamData != NULL) IDirect3DVertexBuffer8Impl_AddRef(pStreamData); + return D3D_OK; +} +HRESULT WINAPI IDirect3DDevice8Impl_GetStreamSource(LPDIRECT3DDEVICE8 iface, UINT StreamNumber,IDirect3DVertexBuffer8** pStream,UINT* pStride) { + ICOM_THIS(IDirect3DDevice8Impl,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]; + IDirect3DVertexBuffer8Impl_AddRef((LPDIRECT3DVERTEXBUFFER8) *pStream); + return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DDevice8) Direct3DDevice8_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DDevice8Impl_QueryInterface, + IDirect3DDevice8Impl_AddRef, + IDirect3DDevice8Impl_Release, + IDirect3DDevice8Impl_TestCooperativeLevel, + IDirect3DDevice8Impl_GetAvailableTextureMem, + IDirect3DDevice8Impl_ResourceManagerDiscardBytes, + IDirect3DDevice8Impl_GetDirect3D, + IDirect3DDevice8Impl_GetDeviceCaps, + IDirect3DDevice8Impl_GetDisplayMode, + IDirect3DDevice8Impl_GetCreationParameters, + IDirect3DDevice8Impl_SetCursorProperties, + IDirect3DDevice8Impl_SetCursorPosition, + IDirect3DDevice8Impl_ShowCursor, + IDirect3DDevice8Impl_CreateAdditionalSwapChain, + IDirect3DDevice8Impl_Reset, + IDirect3DDevice8Impl_Present, + IDirect3DDevice8Impl_GetBackBuffer, + IDirect3DDevice8Impl_GetRasterStatus, + IDirect3DDevice8Impl_SetGammaRamp, + IDirect3DDevice8Impl_GetGammaRamp, + IDirect3DDevice8Impl_CreateTexture, + IDirect3DDevice8Impl_CreateVolumeTexture, + IDirect3DDevice8Impl_CreateCubeTexture, + IDirect3DDevice8Impl_CreateVertexBuffer, + IDirect3DDevice8Impl_CreateIndexBuffer, + IDirect3DDevice8Impl_CreateRenderTarget, + IDirect3DDevice8Impl_CreateDepthStencilSurface, + IDirect3DDevice8Impl_CreateImageSurface, + IDirect3DDevice8Impl_CopyRects, + IDirect3DDevice8Impl_UpdateTexture, + IDirect3DDevice8Impl_GetFrontBuffer, + IDirect3DDevice8Impl_SetRenderTarget, + IDirect3DDevice8Impl_GetRenderTarget, + IDirect3DDevice8Impl_GetDepthStencilSurface, + IDirect3DDevice8Impl_BeginScene, + IDirect3DDevice8Impl_EndScene, + IDirect3DDevice8Impl_Clear, + IDirect3DDevice8Impl_SetTransform, + IDirect3DDevice8Impl_GetTransform, + IDirect3DDevice8Impl_MultiplyTransform, + IDirect3DDevice8Impl_SetViewport, + IDirect3DDevice8Impl_GetViewport, + IDirect3DDevice8Impl_SetMaterial, + IDirect3DDevice8Impl_GetMaterial, + IDirect3DDevice8Impl_SetLight, + IDirect3DDevice8Impl_GetLight, + IDirect3DDevice8Impl_LightEnable, + IDirect3DDevice8Impl_GetLightEnable, + IDirect3DDevice8Impl_SetClipPlane, + IDirect3DDevice8Impl_GetClipPlane, + IDirect3DDevice8Impl_SetRenderState, + IDirect3DDevice8Impl_GetRenderState, + IDirect3DDevice8Impl_BeginStateBlock, + IDirect3DDevice8Impl_EndStateBlock, + IDirect3DDevice8Impl_ApplyStateBlock, + IDirect3DDevice8Impl_CaptureStateBlock, + IDirect3DDevice8Impl_DeleteStateBlock, + IDirect3DDevice8Impl_CreateStateBlock, + IDirect3DDevice8Impl_SetClipStatus, + IDirect3DDevice8Impl_GetClipStatus, + IDirect3DDevice8Impl_GetTexture, + IDirect3DDevice8Impl_SetTexture, + IDirect3DDevice8Impl_GetTextureStageState, + IDirect3DDevice8Impl_SetTextureStageState, + IDirect3DDevice8Impl_ValidateDevice, + IDirect3DDevice8Impl_GetInfo, + IDirect3DDevice8Impl_SetPaletteEntries, + IDirect3DDevice8Impl_GetPaletteEntries, + IDirect3DDevice8Impl_SetCurrentTexturePalette, + IDirect3DDevice8Impl_GetCurrentTexturePalette, + IDirect3DDevice8Impl_DrawPrimitive, + IDirect3DDevice8Impl_DrawIndexedPrimitive, + IDirect3DDevice8Impl_DrawPrimitiveUP, + IDirect3DDevice8Impl_DrawIndexedPrimitiveUP, + IDirect3DDevice8Impl_ProcessVertices, + IDirect3DDevice8Impl_CreateVertexShader, + IDirect3DDevice8Impl_SetVertexShader, + IDirect3DDevice8Impl_GetVertexShader, + IDirect3DDevice8Impl_DeleteVertexShader, + IDirect3DDevice8Impl_SetVertexShaderConstant, + IDirect3DDevice8Impl_GetVertexShaderConstant, + IDirect3DDevice8Impl_GetVertexShaderDeclaration, + IDirect3DDevice8Impl_GetVertexShaderFunction, + IDirect3DDevice8Impl_SetStreamSource, + IDirect3DDevice8Impl_GetStreamSource, + IDirect3DDevice8Impl_SetIndices, + IDirect3DDevice8Impl_GetIndices, + IDirect3DDevice8Impl_CreatePixelShader, + IDirect3DDevice8Impl_SetPixelShader, + IDirect3DDevice8Impl_GetPixelShader, + IDirect3DDevice8Impl_DeletePixelShader, + IDirect3DDevice8Impl_SetPixelShaderConstant, + IDirect3DDevice8Impl_GetPixelShaderConstant, + IDirect3DDevice8Impl_GetPixelShaderFunction, + IDirect3DDevice8Impl_DrawRectPatch, + IDirect3DDevice8Impl_DrawTriPatch, + IDirect3DDevice8Impl_DeletePatch +}; + +void CreateStateBlock(LPDIRECT3DDEVICE8 iface) { + D3DLINEPATTERN lp; + + ICOM_THIS(IDirect3DDevice8Impl,iface); + + FIXME("Need to sort out defaults for the state information! \n"); + + TRACE("-----------------------> Setting up device defaults...\n"); + This->StateBlock.blockType = D3DSBT_ALL; + + /* Set some of the defaults */ + + + /* Render states: */ + if (This->PresentParms.EnableAutoDepthStencil) { + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ZENABLE, D3DZB_TRUE ); + } else { + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ZENABLE, D3DZB_FALSE ); + } + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_FILLMODE, D3DFILL_SOLID); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_SHADEMODE, D3DSHADE_GOURAUD); + lp.wRepeatFactor = 0; lp.wLinePattern = 0; IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_LINEPATTERN, (DWORD) &lp); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ZWRITEENABLE, TRUE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ALPHATESTENABLE, FALSE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_LASTPIXEL, TRUE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_SRCBLEND, D3DBLEND_ONE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_DESTBLEND, D3DBLEND_ZERO); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_CULLMODE, D3DCULL_CCW); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ZFUNC, D3DCMP_LESSEQUAL); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ALPHAFUNC, D3DCMP_ALWAYS); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ALPHAREF, 0xff); /*??*/ + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_DITHERENABLE, FALSE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ALPHABLENDENABLE, FALSE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_FOGENABLE, FALSE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_SPECULARENABLE, FALSE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ZVISIBLE, 0); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_FOGCOLOR, 0); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_FOGTABLEMODE, D3DFOG_NONE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_FOGSTART, 0.0f); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_FOGEND, 1.0f); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_FOGDENSITY, 1.0f); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_EDGEANTIALIAS, FALSE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_ZBIAS, 0); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_RANGEFOGENABLE, FALSE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_STENCILENABLE, FALSE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_STENCILPASS, D3DSTENCILOP_KEEP); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_STENCILFUNC, D3DCMP_ALWAYS); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_STENCILREF, 0); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_STENCILMASK, 0xFFFFFFFF); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_STENCILWRITEMASK, 0xFFFFFFFF); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_TEXTUREFACTOR, 0xFFFFFFFF); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_WRAP0, 0); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_WRAP1, 0); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_WRAP2, 0); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_WRAP3, 0); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_WRAP4, 0); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_WRAP5, 0); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_WRAP6, 0); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_WRAP7, 0); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_CLIPPING, TRUE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_LIGHTING, TRUE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_AMBIENT, 0); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_FOGVERTEXMODE, D3DFOG_NONE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_COLORVERTEX, TRUE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_LOCALVIEWER, TRUE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_NORMALIZENORMALS, FALSE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_COLOR1); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_SPECULARMATERIALSOURCE, D3DMCS_COLOR2); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_AMBIENTMATERIALSOURCE, D3DMCS_COLOR2); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_MATERIAL); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_VERTEXBLEND, D3DVBF_DISABLE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_CLIPPLANEENABLE, 0); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_SOFTWAREVERTEXPROCESSING, FALSE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POINTSIZE, 1.0f); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POINTSIZE_MIN, 0.0f); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POINTSPRITEENABLE, FALSE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POINTSCALEENABLE, FALSE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POINTSCALE_A, TRUE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POINTSCALE_B, TRUE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POINTSCALE_C, TRUE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_MULTISAMPLEANTIALIAS, TRUE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_MULTISAMPLEMASK, 0xFFFFFFFF); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_PATCHEDGESTYLE, D3DPATCHEDGE_DISCRETE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_PATCHSEGMENTS, 1.0f); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_DEBUGMONITORTOKEN, D3DDMT_DISABLE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POINTSIZE_MAX, (DWORD) 64.0f); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_INDEXEDVERTEXBLENDENABLE, FALSE); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_COLORWRITEENABLE, 0x0000000F); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_TWEENFACTOR, (DWORD) 0.0f); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_BLENDOP, D3DBLENDOP_ADD); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_POSITIONORDER, D3DORDER_CUBIC); + IDirect3DDevice8Impl_SetRenderState(iface, D3DRS_NORMALORDER, D3DORDER_LINEAR); + + + + + + TRACE("-----------------------> Device defaults now set up...\n"); + +} + +DWORD SavedPixelStates_R[NUM_SAVEDPIXELSTATES_R] = { + D3DRS_ALPHABLENDENABLE , + D3DRS_ALPHAFUNC , + D3DRS_ALPHAREF , + D3DRS_ALPHATESTENABLE , + D3DRS_BLENDOP , + D3DRS_COLORWRITEENABLE , + D3DRS_DESTBLEND , + D3DRS_DITHERENABLE , + D3DRS_EDGEANTIALIAS , + D3DRS_FILLMODE , + D3DRS_FOGDENSITY , + D3DRS_FOGEND , + D3DRS_FOGSTART , + D3DRS_LASTPIXEL , + D3DRS_LINEPATTERN , + D3DRS_SHADEMODE , + D3DRS_SRCBLEND , + D3DRS_STENCILENABLE , + D3DRS_STENCILFAIL , + D3DRS_STENCILFUNC , + D3DRS_STENCILMASK , + D3DRS_STENCILPASS , + D3DRS_STENCILREF , + D3DRS_STENCILWRITEMASK , + D3DRS_STENCILZFAIL , + D3DRS_TEXTUREFACTOR , + D3DRS_WRAP0 , + D3DRS_WRAP1 , + D3DRS_WRAP2 , + D3DRS_WRAP3 , + D3DRS_WRAP4 , + D3DRS_WRAP5 , + D3DRS_WRAP6 , + D3DRS_WRAP7 , + D3DRS_ZBIAS , + D3DRS_ZENABLE , + D3DRS_ZFUNC , + D3DRS_ZWRITEENABLE +}; + +DWORD SavedPixelStates_T[NUM_SAVEDPIXELSTATES_T] = { + D3DTSS_ADDRESSU , + D3DTSS_ADDRESSV , + D3DTSS_ADDRESSW , + D3DTSS_ALPHAARG0 , + D3DTSS_ALPHAARG1 , + D3DTSS_ALPHAARG2 , + D3DTSS_ALPHAOP , + D3DTSS_BORDERCOLOR , + D3DTSS_BUMPENVLOFFSET , + D3DTSS_BUMPENVLSCALE , + D3DTSS_BUMPENVMAT00 , + D3DTSS_BUMPENVMAT01 , + D3DTSS_BUMPENVMAT10 , + D3DTSS_BUMPENVMAT11 , + D3DTSS_COLORARG0 , + D3DTSS_COLORARG1 , + D3DTSS_COLORARG2 , + D3DTSS_COLOROP , + D3DTSS_MAGFILTER , + D3DTSS_MAXANISOTROPY , + D3DTSS_MAXMIPLEVEL , + D3DTSS_MINFILTER , + D3DTSS_MIPFILTER , + D3DTSS_MIPMAPLODBIAS , + D3DTSS_RESULTARG , + D3DTSS_TEXCOORDINDEX , + D3DTSS_TEXTURETRANSFORMFLAGS +}; + +DWORD SavedVertexStates_R[NUM_SAVEDVERTEXSTATES_R] = { + D3DRS_AMBIENT , + D3DRS_AMBIENTMATERIALSOURCE , + D3DRS_CLIPPING , + D3DRS_CLIPPLANEENABLE , + D3DRS_COLORVERTEX , + D3DRS_DIFFUSEMATERIALSOURCE , + D3DRS_EMISSIVEMATERIALSOURCE , + D3DRS_FOGDENSITY , + D3DRS_FOGEND , + D3DRS_FOGSTART , + D3DRS_FOGTABLEMODE , + D3DRS_FOGVERTEXMODE , + D3DRS_INDEXEDVERTEXBLENDENABLE , + D3DRS_LIGHTING , + D3DRS_LOCALVIEWER , + D3DRS_MULTISAMPLEANTIALIAS , + D3DRS_MULTISAMPLEMASK , + D3DRS_NORMALIZENORMALS , + D3DRS_PATCHEDGESTYLE , + D3DRS_PATCHSEGMENTS , + D3DRS_POINTSCALE_A , + D3DRS_POINTSCALE_B , + D3DRS_POINTSCALE_C , + D3DRS_POINTSCALEENABLE , + D3DRS_POINTSIZE , + D3DRS_POINTSIZE_MAX , + D3DRS_POINTSIZE_MIN , + D3DRS_POINTSPRITEENABLE , + D3DRS_RANGEFOGENABLE , + D3DRS_SOFTWAREVERTEXPROCESSING , + D3DRS_SPECULARMATERIALSOURCE , + D3DRS_TWEENFACTOR , + D3DRS_VERTEXBLEND +}; + +DWORD SavedVertexStates_T[NUM_SAVEDVERTEXSTATES_T] = { + D3DTSS_TEXCOORDINDEX , + D3DTSS_TEXTURETRANSFORMFLAGS +}; diff --git a/dlls/d3d8/directx.c b/dlls/d3d8/directx.c new file mode 100644 index 00000000000..5dd7faf2c07 --- /dev/null +++ b/dlls/d3d8/directx.c @@ -0,0 +1,549 @@ +/* + * IDirect3D8 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 "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "config.h" +#include "x11drv.h" + +#include "d3d8_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +static const float idmatrix[16] = { + 1.0, 0.0, 0.0, 0.0, + 0.0, 1.0, 0.0, 0.0, + 0.0, 0.0, 1.0, 0.0, + 0.0, 0.0, 0.0, 1.0 +}; + +#define NUM_MODES 10 +static const int modes[NUM_MODES][3] = { + {640, 480, 85}, + {800, 600, 85}, + {1024, 768, 85}, + {1152, 864, 85}, + {1280, 768, 85}, + {1280, 960, 85}, + {1280, 1024, 85}, + {1600, 900, 85}, + {1600, 1024, 85}, + {1600, 1200, 85} +}; + +/* retrieve the X display to use on a given DC */ +inline static Display *get_display( HDC hdc ) +{ + Display *display; + enum x11drv_escape_codes escape = X11DRV_GET_DISPLAY; + + if (!ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPCSTR)&escape, + sizeof(display), (LPSTR)&display )) display = NULL; + return display; +} + + +/* IDirect3D IUnknown parts follow: */ +HRESULT WINAPI IDirect3D8Impl_QueryInterface(LPDIRECT3D8 iface,REFIID riid,LPVOID *ppobj) +{ + ICOM_THIS(IDirect3D8Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IClassFactory)) { + IDirect3D8Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3D8Impl_AddRef(LPDIRECT3D8 iface) { + ICOM_THIS(IDirect3D8Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3D8Impl_Release(LPDIRECT3D8 iface) { + ICOM_THIS(IDirect3D8Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) + HeapFree(GetProcessHeap(), 0, This); + return ref; +} + +/* IDirect3D Interface follow: */ +HRESULT WINAPI IDirect3D8Impl_RegisterSoftwareDevice (LPDIRECT3D8 iface, void* pInitializeFunction) { + ICOM_THIS(IDirect3D8Impl,iface); + FIXME("(%p)->(%p): stub\n", This, pInitializeFunction); + return D3D_OK; +} + +UINT WINAPI IDirect3D8Impl_GetAdapterCount (LPDIRECT3D8 iface) { + ICOM_THIS(IDirect3D8Impl,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 IDirect3D8Impl_GetAdapterIdentifier (LPDIRECT3D8 iface, + UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER8* pIdentifier) { + ICOM_THIS(IDirect3D8Impl,iface); + + TRACE("(%p}->(Adapter: %d, Flags: %lx, pId=%p)\n", This, Adapter, Flags, pIdentifier); + + if (Adapter >= IDirect3D8Impl_GetAdapterCount(iface)) { + return D3DERR_INVALIDCALL; + } + + if (Adapter == 0) { /* Display */ + strcpy(pIdentifier->Driver, "Display"); + strcpy(pIdentifier->Description, "Direct3D Display"); + pIdentifier->DriverVersion.s.HighPart = 1; + pIdentifier->DriverVersion.s.LowPart = 0; + pIdentifier->VendorId = 0; + pIdentifier->DeviceId = 0; + pIdentifier->SubSysId = 0; + pIdentifier->Revision = 0; + /*FIXME: memcpy(&pIdentifier->DeviceIdentifier, ??, sizeof(??GUID)); */ + if (Flags & D3DENUM_NO_WHQL_LEVEL ) { + pIdentifier->WHQLLevel = 0; + } else { + pIdentifier->WHQLLevel = 1; + } + } else { + FIXME("Adapter not primary display\n"); + } + + return D3D_OK; +} + +UINT WINAPI IDirect3D8Impl_GetAdapterModeCount (LPDIRECT3D8 iface, + UINT Adapter) { + ICOM_THIS(IDirect3D8Impl,iface); + + TRACE("(%p}->(Adapter: %d)\n", This, Adapter); + + if (Adapter >= IDirect3D8Impl_GetAdapterCount(iface)) { + return D3DERR_INVALIDCALL; + } + + if (Adapter == 0) { /* Display */ + int maxWidth = GetSystemMetrics(SM_CXSCREEN); + int maxHeight = GetSystemMetrics(SM_CYSCREEN); + int i; + + for (i=0; i maxWidth || modes[i][1] > maxHeight) { + return i+1; + } + } + return NUM_MODES+1; + } else { + FIXME("Adapter not primary display\n"); + } + + return D3D_OK; +} + +HRESULT WINAPI IDirect3D8Impl_EnumAdapterModes (LPDIRECT3D8 iface, + UINT Adapter, UINT Mode, D3DDISPLAYMODE* pMode) { + ICOM_THIS(IDirect3D8Impl,iface); + + TRACE("(%p}->(Adapter: %d, mode: %d, pMode=%p)\n", This, Adapter, Mode, pMode); + + if (Adapter >= IDirect3D8Impl_GetAdapterCount(iface)) { + return D3DERR_INVALIDCALL; + } + + if (Adapter == 0) { /* Display */ + HDC hdc; + int bpp = 0; + + if (Mode == 0) { + pMode->Width = GetSystemMetrics(SM_CXSCREEN); + pMode->Height = GetSystemMetrics(SM_CYSCREEN); + pMode->RefreshRate = 85; /*FIXME: How to identify? */ + } else if (Mode < (NUM_MODES+1)) { + pMode->Width = modes[Mode-1][0]; + pMode->Height = modes[Mode-1][1]; + pMode->RefreshRate = modes[Mode-1][2]; + } else { + TRACE("Requested mode out of range %d\n", Mode); + return D3DERR_INVALIDCALL; + } + + hdc = CreateDCA("DISPLAY", NULL, NULL, NULL); + bpp = GetDeviceCaps(hdc, BITSPIXEL); + DeleteDC(hdc); + + switch (bpp) { + case 8: pMode->Format = D3DFMT_R3G3B2; break; + case 16: pMode->Format = D3DFMT_A4R4G4B4; break; + case 24: pMode->Format = D3DFMT_R8G8B8; break; + case 32: pMode->Format = D3DFMT_A8R8G8B8; break; + default: pMode->Format = D3DFMT_UNKNOWN; + } + TRACE("W %d H %d rr %d fmt %x\n", pMode->Width, pMode->Height, pMode->RefreshRate, pMode->Format); + + } else { + FIXME("Adapter not primary display\n"); + } + + return D3D_OK; +} + +HRESULT WINAPI IDirect3D8Impl_GetAdapterDisplayMode (LPDIRECT3D8 iface, + UINT Adapter, D3DDISPLAYMODE* pMode) { + ICOM_THIS(IDirect3D8Impl,iface); + TRACE("(%p}->(Adapter: %d, pMode: %p)\n", This, Adapter, pMode); + + if (Adapter >= IDirect3D8Impl_GetAdapterCount(iface)) { + return D3DERR_INVALIDCALL; + } + + if (Adapter == 0) { /* Display */ + HDC hdc; + int bpp = 0; + + pMode->Width = GetSystemMetrics(SM_CXSCREEN); + pMode->Height = GetSystemMetrics(SM_CYSCREEN); + pMode->RefreshRate = 85; /*FIXME: How to identify? */ + + hdc = CreateDCA("DISPLAY", NULL, NULL, NULL); + bpp = GetDeviceCaps(hdc, BITSPIXEL); + DeleteDC(hdc); + + switch (bpp) { + case 8: pMode->Format = D3DFMT_R3G3B2; break; + case 16: pMode->Format = D3DFMT_A4R4G4B4; break; + case 24: pMode->Format = D3DFMT_R8G8B8; break; + case 32: pMode->Format = D3DFMT_A8R8G8B8; break; + default: pMode->Format = D3DFMT_UNKNOWN; + } + + } else { + FIXME("Adapter not primary display\n"); + } + + TRACE("returning w:%d, h:%d, ref:%d, fmt:%d\n", pMode->Width, + pMode->Height, pMode->RefreshRate, pMode->Format); + return D3D_OK; +} + +HRESULT WINAPI IDirect3D8Impl_CheckDeviceType (LPDIRECT3D8 iface, + UINT Adapter, D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat, + D3DFORMAT BackBufferFormat, BOOL Windowed) { + ICOM_THIS(IDirect3D8Impl,iface); + FIXME("(%p)->(Adptr:%d, CheckType:%x, DispFmt:%x, BackBuf:%x, Win? %d): stub\n", This, Adapter, CheckType, + DisplayFormat, BackBufferFormat, Windowed); + return D3D_OK; +} + +HRESULT WINAPI IDirect3D8Impl_CheckDeviceFormat (LPDIRECT3D8 iface, + UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, + DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat) { + ICOM_THIS(IDirect3D8Impl,iface); + FIXME("(%p)->(Adptr:%d, DevType: %x, AdptFmt: %d, Use: %ld, ResTyp: %x, CheckFmt: %d)\n", This, Adapter, DeviceType, + AdapterFormat, Usage, RType, CheckFormat); + return D3D_OK; +} + +HRESULT WINAPI IDirect3D8Impl_CheckDeviceMultiSampleType (LPDIRECT3D8 iface, + UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, + BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType) { + ICOM_THIS(IDirect3D8Impl,iface); + FIXME("(%p)->(Adptr:%d, DevType: %x, SurfFmt: %x, Win? %d, MultiSamp: %x)\n", This, Adapter, DeviceType, + SurfaceFormat, Windowed, MultiSampleType); + return D3D_OK; +} + +HRESULT WINAPI IDirect3D8Impl_CheckDepthStencilMatch (LPDIRECT3D8 iface, + UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, + D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat) { + ICOM_THIS(IDirect3D8Impl,iface); + FIXME("(%p)->(Adptr:%d, DevType: %x, AdptFmt: %x, RendrTgtFmt: %x, DepthStencilFmt: %x)\n", This, Adapter, DeviceType, + AdapterFormat, RenderTargetFormat, DepthStencilFormat); + return D3D_OK; +} + +HRESULT WINAPI IDirect3D8Impl_GetDeviceCaps (LPDIRECT3D8 iface, + UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS8* pCaps) { + ICOM_THIS(IDirect3D8Impl,iface); + TRACE("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This, Adapter, DeviceType, pCaps); + + + /* NOTE: Most of the values here are complete garbage for now */ + pCaps->DeviceType = D3DDEVTYPE_HAL; /* Not quite true, but use h/w supported by opengl I suppose */ + pCaps->AdapterOrdinal = Adapter; + + pCaps->Caps = 0; + pCaps->Caps2 = D3DCAPS2_CANRENDERWINDOWED; + pCaps->Caps3 = D3DDEVCAPS_HWTRANSFORMANDLIGHT; + pCaps->PresentationIntervals = D3DPRESENT_INTERVAL_IMMEDIATE; + + pCaps->CursorCaps = 0; + + pCaps->DevCaps = D3DDEVCAPS_DRAWPRIMTLVERTEX | D3DDEVCAPS_HWTRANSFORMANDLIGHT | D3DDEVCAPS_PUREDEVICE; + + pCaps->PrimitiveMiscCaps = D3DPMISCCAPS_CULLCCW | D3DPMISCCAPS_CULLCW | D3DPMISCCAPS_COLORWRITEENABLE | D3DPMISCCAPS_CLIPTLVERTS | + D3DPMISCCAPS_CLIPPLANESCALEDPOINTS | D3DPMISCCAPS_MASKZ; /*NOT: D3DPMISCCAPS_TSSARGTEMP*/ + pCaps->RasterCaps = D3DPRASTERCAPS_DITHER | D3DPRASTERCAPS_PAT; + pCaps->ZCmpCaps = D3DPCMPCAPS_ALWAYS | D3DPCMPCAPS_EQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_GREATEREQUAL | + D3DPCMPCAPS_LESS | D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_NEVER | D3DPCMPCAPS_NOTEQUAL; + + pCaps->SrcBlendCaps = 0; + pCaps->DestBlendCaps = 0; + pCaps->AlphaCmpCaps = 0; + pCaps->ShadeCaps = D3DPSHADECAPS_SPECULARGOURAUDRGB | D3DPSHADECAPS_COLORGOURAUDRGB ; + pCaps->TextureCaps = D3DPTEXTURECAPS_ALPHA | D3DPTEXTURECAPS_ALPHAPALETTE | D3DPTEXTURECAPS_CUBEMAP | D3DPTEXTURECAPS_POW2; + pCaps->TextureFilterCaps = 0; + pCaps->CubeTextureFilterCaps = 0; + pCaps->VolumeTextureFilterCaps = 0; + pCaps->TextureAddressCaps = D3DPTADDRESSCAPS_BORDER | D3DPTADDRESSCAPS_CLAMP | D3DPTADDRESSCAPS_WRAP; + pCaps->VolumeTextureAddressCaps = 0; + + pCaps->LineCaps = D3DLINECAPS_TEXTURE | D3DLINECAPS_ZTEST; + + pCaps->MaxTextureWidth = 16384; + pCaps->MaxTextureHeight = 16384; + pCaps->MaxVolumeExtent = 0; + + pCaps->MaxTextureRepeat = 32768; + pCaps->MaxTextureAspectRatio = 32768; + pCaps->MaxAnisotropy = 0; + pCaps->MaxVertexW = 1.0; + + pCaps->GuardBandLeft = 0; + pCaps->GuardBandTop = 0; + pCaps->GuardBandRight = 0; + pCaps->GuardBandBottom = 0; + + pCaps->ExtentsAdjust = 0; + + pCaps->StencilCaps = 0; + + pCaps->FVFCaps = D3DFVFCAPS_PSIZE | 0x80000; + pCaps->TextureOpCaps = 0xFFFFFFFF; + pCaps->MaxTextureBlendStages = 256; + pCaps->MaxSimultaneousTextures = 256; + + pCaps->VertexProcessingCaps = D3DVTXPCAPS_DIRECTIONALLIGHTS | D3DVTXPCAPS_MATERIALSOURCE7 | D3DVTXPCAPS_POSITIONALLIGHTS | D3DVTXPCAPS_TEXGEN; + + pCaps->MaxActiveLights = 8; + pCaps->MaxUserClipPlanes = 1; + pCaps->MaxVertexBlendMatrices = 1; + pCaps->MaxVertexBlendMatrixIndex = 1; + + pCaps->MaxPointSize = 128.0; + + pCaps->MaxPrimitiveCount = 0xFFFFFFFF; + pCaps->MaxVertexIndex = 0xFFFFFFFF; + pCaps->MaxStreams = 1; + pCaps->MaxStreamStride = 1024; + + pCaps->VertexShaderVersion = 01; + pCaps->MaxVertexShaderConst = 1; + + pCaps->PixelShaderVersion = 01; + pCaps->MaxPixelShaderValue = 1.0; + + return D3D_OK; +} + +HMONITOR WINAPI IDirect3D8Impl_GetAdapterMonitor (LPDIRECT3D8 iface, + UINT Adapter) { + ICOM_THIS(IDirect3D8Impl,iface); + FIXME("(%p)->(Adptr:%d)\n", This, Adapter); + return D3D_OK; +} + +HRESULT WINAPI IDirect3D8Impl_CreateDevice (LPDIRECT3D8 iface, + UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow, + DWORD BehaviourFlags, D3DPRESENT_PARAMETERS* pPresentationParameters, + IDirect3DDevice8** ppReturnedDeviceInterface) { + IDirect3DDevice8Impl *object; + HWND whichHWND; + + ICOM_THIS(IDirect3D8Impl,iface); + TRACE("(%p)->(Adptr:%d, DevType: %x, FocusHwnd: %x, BehFlags: %lx, PresParms: %p, RetDevInt: %p)\n", This, Adapter, DeviceType, + hFocusWindow, BehaviourFlags, pPresentationParameters, ppReturnedDeviceInterface); + + /* Allocate the storage for the device */ + object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DDevice8Impl)); + object->lpVtbl = &Direct3DDevice8_Vtbl; + object->ref = 1; + object->direct3d8 = This; + object->UpdateStateBlock = &object->StateBlock; + CreateStateBlock((LPDIRECT3DDEVICE8) object); + + *ppReturnedDeviceInterface = (LPDIRECT3DDEVICE8)object; + + /* Initialize settings */ + memcpy(&object->PresentParms, pPresentationParameters, sizeof(D3DPRESENT_PARAMETERS)); + memcpy(&object->StateBlock.transforms[D3DTS_WORLDMATRIX(0)], &idmatrix, sizeof(idmatrix)); + memcpy(&object->StateBlock.transforms[D3DTS_PROJECTION], &idmatrix, sizeof(idmatrix)); + memcpy(&object->StateBlock.transforms[D3DTS_VIEW], &idmatrix, sizeof(idmatrix)); + + object->PresentParms.BackBufferCount = 1; /* Opengl only supports one? */ + pPresentationParameters->BackBufferCount = 1; + + object->adapterNo = Adapter; + object->devType = DeviceType; + + /* Initialize openGl */ + { + HDC hDc; + int dblBuf[]={GLX_RGBA,GLX_DEPTH_SIZE,16,GLX_DOUBLEBUFFER,None}; + /*int dblBuf[]={GLX_RGBA,GLX_DEPTH_SIZE,16, None}; // Useful for debugging */ + + /* Which hwnd are we using? */ +/* if (pPresentationParameters->Windowed) { */ + whichHWND = pPresentationParameters->hDeviceWindow; + if (!whichHWND) { + whichHWND = hFocusWindow; + } + object->win = (Window)GetPropA( whichHWND, "__wine_x11_client_window" ); +/* + * } else { + * whichHWND = (HWND) GetDesktopWindow(); + * object->win = (Window)GetPropA(whichHWND, "__wine_x11_whole_window" ); + * root_window + * } + */ + + hDc = GetDC(whichHWND); + object->display = get_display(hDc); + + ENTER_GL(); + object->visInfo = glXChooseVisual(object->display, DefaultScreen(object->display), dblBuf); + object->glCtx = glXCreateContext(object->display, object->visInfo, NULL, GL_TRUE); + LEAVE_GL(); + ReleaseDC(whichHWND, hDc); + + } + + if (object->glCtx == NULL) { + ERR("Error in context creation !\n"); + return D3DERR_INVALIDCALL; + } else { + TRACE("Context created (HWND=%x, glContext=%p, Window=%ld, VisInfo=%p)\n", + whichHWND, object->glCtx, object->win, object->visInfo); + } + + TRACE("Creating back buffer\n"); + /* MSDN: If Windowed is TRUE and either of the BackBufferWidth/Height values is zero, + then the corresponding dimension of the client area of the hDeviceWindow + (or the focus window, if hDeviceWindow is NULL) is taken. */ + if (pPresentationParameters->Windowed && ((pPresentationParameters->BackBufferWidth == 0) || + (pPresentationParameters->BackBufferHeight == 0))) { + RECT Rect; + + GetClientRect(whichHWND, &Rect); + + if (pPresentationParameters->BackBufferWidth == 0) { + pPresentationParameters->BackBufferWidth = Rect.right; + TRACE("Updating width to %d\n", pPresentationParameters->BackBufferWidth); + } + if (pPresentationParameters->BackBufferHeight == 0) { + pPresentationParameters->BackBufferHeight = Rect.bottom; + TRACE("Updating height to %d\n", pPresentationParameters->BackBufferHeight); + } + } + + IDirect3DDevice8Impl_CreateImageSurface((LPDIRECT3DDEVICE8) object, + pPresentationParameters->BackBufferWidth, + pPresentationParameters->BackBufferHeight, + pPresentationParameters->BackBufferFormat, + (LPDIRECT3DSURFACE8*) &object->backBuffer); + + /* Now override the surface's Flip method (if in double buffering) ?COPIED from DDRAW!? + ((x11_ds_private *) surface->private)->opengl_flip = TRUE; + { + int i; + struct _surface_chain *chain = surface->s.chain; + for (i=0;inrofsurfaces;i++) + if (chain->surfaces[i]->s.surface_desc.ddsCaps.dwCaps & DDSCAPS_FLIP) + ((x11_ds_private *) chain->surfaces[i]->private)->opengl_flip = TRUE; + } + */ + + ENTER_GL(); + if (glXMakeCurrent(object->display, object->win, object->glCtx) == False) { + ERR("Error in setting current context (context %p drawable %ld)!\n", + object->glCtx, object->win); + } + checkGLcall("glXMakeCurrent"); + + /* Clear the screen */ + glClearColor(1.0, 0.0, 0.0, 0.0); + checkGLcall("glClearColor"); + glColor3f(1.0, 1.0, 1.0); + checkGLcall("glColor3f"); + + glEnable(GL_LIGHTING); + checkGLcall("glEnable"); + + glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT); + checkGLcall("glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);"); + + LEAVE_GL(); + + { /* Set a default viewport */ + D3DVIEWPORT8 vp; + vp.X = 0; + vp.Y = 0; + vp.Width = pPresentationParameters->BackBufferWidth; + vp.Height = pPresentationParameters->BackBufferHeight; + vp.MinZ = 0.0f; + vp.MaxZ = 1.0f; + IDirect3DDevice8Impl_SetViewport((LPDIRECT3DDEVICE8) object, &vp); + } + + TRACE("(%p,%d) incomplete\n", This, Adapter); + return D3D_OK; +} + +ICOM_VTABLE(IDirect3D8) Direct3D8_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3D8Impl_QueryInterface, + IDirect3D8Impl_AddRef, + IDirect3D8Impl_Release, + IDirect3D8Impl_RegisterSoftwareDevice, + IDirect3D8Impl_GetAdapterCount, + IDirect3D8Impl_GetAdapterIdentifier, + IDirect3D8Impl_GetAdapterModeCount, + IDirect3D8Impl_EnumAdapterModes, + IDirect3D8Impl_GetAdapterDisplayMode, + IDirect3D8Impl_CheckDeviceType, + IDirect3D8Impl_CheckDeviceFormat, + IDirect3D8Impl_CheckDeviceMultiSampleType, + IDirect3D8Impl_CheckDepthStencilMatch, + IDirect3D8Impl_GetDeviceCaps, + IDirect3D8Impl_GetAdapterMonitor, + IDirect3D8Impl_CreateDevice +}; diff --git a/dlls/d3d8/indexbuffer.c b/dlls/d3d8/indexbuffer.c new file mode 100644 index 00000000000..f74517f788b --- /dev/null +++ b/dlls/d3d8/indexbuffer.c @@ -0,0 +1,143 @@ +/* + * IDirect3DIndexBuffer8 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 "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d8_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DIndexBuffer8 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DIndexBuffer8Impl_QueryInterface(LPDIRECT3DINDEXBUFFER8 iface,REFIID riid,LPVOID *ppobj) +{ + ICOM_THIS(IDirect3DIndexBuffer8Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IClassFactory)) { + IDirect3DIndexBuffer8Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DIndexBuffer8Impl_AddRef(LPDIRECT3DINDEXBUFFER8 iface) { + ICOM_THIS(IDirect3DIndexBuffer8Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DIndexBuffer8Impl_Release(LPDIRECT3DINDEXBUFFER8 iface) { + ICOM_THIS(IDirect3DIndexBuffer8Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + HeapFree(GetProcessHeap(), 0, This); + HeapFree(GetProcessHeap(), 0, This->allocatedMemory); + } + return ref; +} + +/* IDirect3DResource Interface follow: */ +HRESULT WINAPI IDirect3DIndexBuffer8Impl_GetDevice(LPDIRECT3DINDEXBUFFER8 iface, IDirect3DDevice8** ppDevice) { + ICOM_THIS(IDirect3DIndexBuffer8Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE8) This->Device; + return D3D_OK; +} +HRESULT WINAPI IDirect3DIndexBuffer8Impl_SetPrivateData(LPDIRECT3DINDEXBUFFER8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DIndexBuffer8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DIndexBuffer8Impl_GetPrivateData(LPDIRECT3DINDEXBUFFER8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DIndexBuffer8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DIndexBuffer8Impl_FreePrivateData(LPDIRECT3DINDEXBUFFER8 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DIndexBuffer8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DIndexBuffer8Impl_SetPriority(LPDIRECT3DINDEXBUFFER8 iface, DWORD PriorityNew) { + ICOM_THIS(IDirect3DIndexBuffer8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DIndexBuffer8Impl_GetPriority(LPDIRECT3DINDEXBUFFER8 iface) { + ICOM_THIS(IDirect3DIndexBuffer8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +void WINAPI IDirect3DIndexBuffer8Impl_PreLoad(LPDIRECT3DINDEXBUFFER8 iface) { + ICOM_THIS(IDirect3DIndexBuffer8Impl,iface); + FIXME("(%p) : stub\n", This); +} +D3DRESOURCETYPE WINAPI IDirect3DIndexBuffer8Impl_GetType(LPDIRECT3DINDEXBUFFER8 iface) { + ICOM_THIS(IDirect3DIndexBuffer8Impl,iface); + TRACE("(%p) : returning %d\n", This, This->ResourceType); + return This->ResourceType; +} + +/* IDirect3DIndexBuffer8 */ +HRESULT WINAPI IDirect3DIndexBuffer8Impl_Lock(LPDIRECT3DINDEXBUFFER8 iface, UINT OffsetToLock, UINT SizeToLock, BYTE** ppbData, DWORD Flags) { + ICOM_THIS(IDirect3DIndexBuffer8Impl,iface); + if (OffsetToLock==0) { + TRACE("(%p) : no locking yet, offset %d, size %d, Flags=%lx\n", This, OffsetToLock, SizeToLock, Flags); + } else { + FIXME("(%p) : stub, offset %d, size %d, Flags=%lx\n", This, OffsetToLock, SizeToLock, Flags); + } + *ppbData = This->allocatedMemory; + return D3D_OK; +} + +HRESULT WINAPI IDirect3DIndexBuffer8Impl_Unlock(LPDIRECT3DINDEXBUFFER8 iface) { + ICOM_THIS(IDirect3DIndexBuffer8Impl,iface); + TRACE("(%p) : stub\n", This); + return D3D_OK; +} +HRESULT WINAPI IDirect3DIndexBuffer8Impl_GetDesc(LPDIRECT3DINDEXBUFFER8 iface, D3DINDEXBUFFER_DESC *pDesc) { + ICOM_THIS(IDirect3DIndexBuffer8Impl,iface); + + TRACE("(%p) : copying into %p\n", This, pDesc); + memcpy(pDesc, &This->currentDesc, sizeof(D3DINDEXBUFFER_DESC)); + return D3D_OK; +} + +ICOM_VTABLE(IDirect3DIndexBuffer8) Direct3DIndexBuffer8_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DIndexBuffer8Impl_QueryInterface, + IDirect3DIndexBuffer8Impl_AddRef, + IDirect3DIndexBuffer8Impl_Release, + IDirect3DIndexBuffer8Impl_GetDevice, + IDirect3DIndexBuffer8Impl_SetPrivateData, + IDirect3DIndexBuffer8Impl_GetPrivateData, + IDirect3DIndexBuffer8Impl_FreePrivateData, + IDirect3DIndexBuffer8Impl_SetPriority, + IDirect3DIndexBuffer8Impl_GetPriority, + IDirect3DIndexBuffer8Impl_PreLoad, + IDirect3DIndexBuffer8Impl_GetType, + IDirect3DIndexBuffer8Impl_Lock, + IDirect3DIndexBuffer8Impl_Unlock, + IDirect3DIndexBuffer8Impl_GetDesc +}; diff --git a/dlls/d3d8/resource.c b/dlls/d3d8/resource.c new file mode 100644 index 00000000000..cb8a2fae74c --- /dev/null +++ b/dlls/d3d8/resource.c @@ -0,0 +1,113 @@ +/* + * IDirect3DResource8 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 "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d8_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DResource IUnknown parts follow: */ +HRESULT WINAPI IDirect3DResource8Impl_QueryInterface(LPDIRECT3DRESOURCE8 iface,REFIID riid,LPVOID *ppobj) +{ + ICOM_THIS(IDirect3DResource8Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IClassFactory)) { + IDirect3DResource8Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DResource8Impl_AddRef(LPDIRECT3DRESOURCE8 iface) { + ICOM_THIS(IDirect3DResource8Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DResource8Impl_Release(LPDIRECT3DRESOURCE8 iface) { + ICOM_THIS(IDirect3DResource8Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) + HeapFree(GetProcessHeap(), 0, This); + return ref; +} + +/* IDirect3DResource Interface follow: */ +HRESULT WINAPI IDirect3DResource8Impl_GetDevice(LPDIRECT3DRESOURCE8 iface, IDirect3DDevice8** ppDevice) { + ICOM_THIS(IDirect3DResource8Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE8) This->Device; + return D3D_OK; +} +HRESULT WINAPI IDirect3DResource8Impl_SetPrivateData(LPDIRECT3DRESOURCE8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DResource8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DResource8Impl_GetPrivateData(LPDIRECT3DRESOURCE8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DResource8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DResource8Impl_FreePrivateData(LPDIRECT3DRESOURCE8 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DResource8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DResource8Impl_SetPriority(LPDIRECT3DRESOURCE8 iface, DWORD PriorityNew) { + ICOM_THIS(IDirect3DResource8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DResource8Impl_GetPriority(LPDIRECT3DRESOURCE8 iface) { + ICOM_THIS(IDirect3DResource8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +void WINAPI IDirect3DResource8Impl_PreLoad(LPDIRECT3DRESOURCE8 iface) { + ICOM_THIS(IDirect3DResource8Impl,iface); + FIXME("(%p) : stub\n", This); +} +D3DRESOURCETYPE WINAPI IDirect3DResource8Impl_GetType(LPDIRECT3DRESOURCE8 iface) { + ICOM_THIS(IDirect3DResource8Impl,iface); + TRACE("(%p) : returning %d\n", This, This->ResourceType); + return This->ResourceType; +} + +ICOM_VTABLE(IDirect3DResource8) Direct3DResource8_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DResource8Impl_QueryInterface, + IDirect3DResource8Impl_AddRef, + IDirect3DResource8Impl_Release, + IDirect3DResource8Impl_GetDevice, + IDirect3DResource8Impl_SetPrivateData, + IDirect3DResource8Impl_GetPrivateData, + IDirect3DResource8Impl_FreePrivateData, + IDirect3DResource8Impl_SetPriority, + IDirect3DResource8Impl_GetPriority, + IDirect3DResource8Impl_PreLoad, + IDirect3DResource8Impl_GetType +}; diff --git a/dlls/d3d8/surface.c b/dlls/d3d8/surface.c new file mode 100644 index 00000000000..64b26b22e30 --- /dev/null +++ b/dlls/d3d8/surface.c @@ -0,0 +1,148 @@ +/* + * IDirect3DSurface8 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 "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d8_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DVolume IUnknown parts follow: */ +HRESULT WINAPI IDirect3DSurface8Impl_QueryInterface(LPDIRECT3DSURFACE8 iface,REFIID riid,LPVOID *ppobj) +{ + ICOM_THIS(IDirect3DSurface8Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IClassFactory)) { + IDirect3DSurface8Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DSurface8Impl_AddRef(LPDIRECT3DSURFACE8 iface) { + ICOM_THIS(IDirect3DSurface8Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DSurface8Impl_Release(LPDIRECT3DSURFACE8 iface) { + ICOM_THIS(IDirect3DSurface8Impl,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; +} + +/* IDirect3DSurface8: */ +HRESULT WINAPI IDirect3DSurface8Impl_GetDevice(LPDIRECT3DSURFACE8 iface, IDirect3DDevice8** ppDevice) { + ICOM_THIS(IDirect3DSurface8Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE8) This->Device; + return D3D_OK; +} +HRESULT WINAPI IDirect3DSurface8Impl_SetPrivateData(LPDIRECT3DSURFACE8 iface, REFGUID refguid,CONST void* pData,DWORD SizeOfData,DWORD Flags) { + ICOM_THIS(IDirect3DSurface8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DSurface8Impl_GetPrivateData(LPDIRECT3DSURFACE8 iface, REFGUID refguid,void* pData,DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DSurface8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DSurface8Impl_FreePrivateData(LPDIRECT3DSURFACE8 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DSurface8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DSurface8Impl_GetContainer(LPDIRECT3DSURFACE8 iface, REFIID riid,void** ppContainer) { + ICOM_THIS(IDirect3DSurface8Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Container); + *ppContainer = This->Container; + return D3D_OK; +} +HRESULT WINAPI IDirect3DSurface8Impl_GetDesc(LPDIRECT3DSURFACE8 iface, D3DSURFACE_DESC *pDesc) { + ICOM_THIS(IDirect3DSurface8Impl,iface); + + TRACE("(%p) : copying into %p\n", This, pDesc); + memcpy(pDesc, &This->myDesc, sizeof(D3DSURFACE_DESC)); + return D3D_OK; +} +HRESULT WINAPI IDirect3DSurface8Impl_LockRect(LPDIRECT3DSURFACE8 iface, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect,DWORD Flags) { + ICOM_THIS(IDirect3DSurface8Impl,iface); + /* fixme: should we really lock as such? */ + TRACE("(%p) : rect=%p, output prect=%p, allMem=%p\n", This, pRect, pLockedRect, This->allocatedMemory); + + pLockedRect->Pitch = This->bytesPerPixel * This->myDesc.Width; /* Bytes / row */ + if (!pRect) { + pLockedRect->pBits = This->allocatedMemory; + } else { + TRACE("Lock Rect (%p) = l %d, t %d, r %d, b %d\n", pRect, pRect->left, pRect->top, pRect->right, pRect->bottom); + pLockedRect->pBits = This->allocatedMemory + (pLockedRect->Pitch * pRect->top) + (pRect->left * This->bytesPerPixel); + } + TRACE("returning pBits=%p, pitch=%d\n", pLockedRect->pBits, pLockedRect->Pitch); + return D3D_OK; +} +HRESULT WINAPI IDirect3DSurface8Impl_UnlockRect(LPDIRECT3DSURFACE8 iface) { + ICOM_THIS(IDirect3DSurface8Impl,iface); + TRACE("(%p) : stub\n", This); + if (This->Container) { + IDirect3DBaseTexture8 *cont = This->Container; + + /* Now setup the texture appropraitly */ + int containerType = IDirect3DBaseTexture8Impl_GetType(cont); + if (containerType == D3DRTYPE_TEXTURE) { + IDirect3DTexture8Impl *pTexture = (IDirect3DTexture8Impl *)cont; + pTexture->Dirty = TRUE; + } else if (containerType == D3DRTYPE_CUBETEXTURE) { + IDirect3DCubeTexture8Impl *pTexture = (IDirect3DCubeTexture8Impl *)cont; + pTexture->Dirty = TRUE; + + } else { + FIXME("Set dirty on container type %d\n", containerType); + } + } + return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DSurface8) Direct3DSurface8_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DSurface8Impl_QueryInterface, + IDirect3DSurface8Impl_AddRef, + IDirect3DSurface8Impl_Release, + IDirect3DSurface8Impl_GetDevice, + IDirect3DSurface8Impl_SetPrivateData, + IDirect3DSurface8Impl_GetPrivateData, + IDirect3DSurface8Impl_FreePrivateData, + IDirect3DSurface8Impl_GetContainer, + IDirect3DSurface8Impl_GetDesc, + IDirect3DSurface8Impl_LockRect, + IDirect3DSurface8Impl_UnlockRect, +}; diff --git a/dlls/d3d8/swapchain.c b/dlls/d3d8/swapchain.c new file mode 100644 index 00000000000..88e7b90e72d --- /dev/null +++ b/dlls/d3d8/swapchain.c @@ -0,0 +1,81 @@ +/* + * IDirect3DSwapChain8 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 "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d8_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DSwapChain IUnknown parts follow: */ +HRESULT WINAPI IDirect3DSwapChain8Impl_QueryInterface(LPDIRECT3DSWAPCHAIN8 iface,REFIID riid,LPVOID *ppobj) +{ + ICOM_THIS(IDirect3DSwapChain8Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IClassFactory)) { + IDirect3DSwapChain8Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DSwapChain8Impl_AddRef(LPDIRECT3DSWAPCHAIN8 iface) { + ICOM_THIS(IDirect3DSwapChain8Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DSwapChain8Impl_Release(LPDIRECT3DSWAPCHAIN8 iface) { + ICOM_THIS(IDirect3DSwapChain8Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) + HeapFree(GetProcessHeap(), 0, This); + return ref; +} + +/* IDirect3DSwapChain parts follow: */ +HRESULT WINAPI IDirect3DSwapChain8Impl_Present(LPDIRECT3DSWAPCHAIN8 iface, CONST RECT* pSourceRect, CONST RECT* pDestRect, HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion) { + ICOM_THIS(IDirect3DSwapChain8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DSwapChain8Impl_GetBackBuffer(LPDIRECT3DSWAPCHAIN8 iface, UINT BackBuffer, D3DBACKBUFFER_TYPE Type,IDirect3DSurface8** ppBackBuffer) { + ICOM_THIS(IDirect3DSwapChain8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DSwapChain8) Direct3DSwapChain8_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DSwapChain8Impl_QueryInterface, + IDirect3DSwapChain8Impl_AddRef, + IDirect3DSwapChain8Impl_Release, + IDirect3DSwapChain8Impl_Present, + IDirect3DSwapChain8Impl_GetBackBuffer +}; diff --git a/dlls/d3d8/texture.c b/dlls/d3d8/texture.c new file mode 100644 index 00000000000..8f6a34c3a02 --- /dev/null +++ b/dlls/d3d8/texture.c @@ -0,0 +1,188 @@ +/* + * IDirect3DTexture8 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 "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d8_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DTexture8 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DTexture8Impl_QueryInterface(LPDIRECT3DTEXTURE8 iface,REFIID riid,LPVOID *ppobj) +{ + ICOM_THIS(IDirect3DTexture8Impl,iface); + TRACE("(%p) : QueryInterface\n", This); + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IClassFactory)) { + IDirect3DTexture8Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DTexture8Impl_AddRef(LPDIRECT3DTEXTURE8 iface) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DTexture8Impl_Release(LPDIRECT3DTEXTURE8 iface) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + ULONG ref = --This->ref; + int i; + + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) { + for (i=0; ilevels; i++) { + if (This->surfaces[i] != NULL) { + TRACE("(%p) : Releasing surface %p\n", This, This->surfaces[i]); + IDirect3DSurface8Impl_Release((LPDIRECT3DSURFACE8) This->surfaces[i]); + } + } + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + +/* IDirect3DTexture8 IDirect3DResource8 Interface follow: */ +HRESULT WINAPI IDirect3DTexture8Impl_GetDevice(LPDIRECT3DTEXTURE8 iface, IDirect3DDevice8** ppDevice) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE8) This->Device; + return D3D_OK; +} +HRESULT WINAPI IDirect3DTexture8Impl_SetPrivateData(LPDIRECT3DTEXTURE8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DTexture8Impl_GetPrivateData(LPDIRECT3DTEXTURE8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DTexture8Impl_FreePrivateData(LPDIRECT3DTEXTURE8 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DTexture8Impl_SetPriority(LPDIRECT3DTEXTURE8 iface, DWORD PriorityNew) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DTexture8Impl_GetPriority(LPDIRECT3DTEXTURE8 iface) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +void WINAPI IDirect3DTexture8Impl_PreLoad(LPDIRECT3DTEXTURE8 iface) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + FIXME("(%p) : stub\n", This); +} +D3DRESOURCETYPE WINAPI IDirect3DTexture8Impl_GetType(LPDIRECT3DTEXTURE8 iface) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + TRACE("(%p) : is %d \n", This, This->ResourceType); + return This->ResourceType; +} + +/* IDirect3DTexture8 (Inherited from IDirect3DBaseTexture8) */ +DWORD WINAPI IDirect3DTexture8Impl_SetLOD(LPDIRECT3DTEXTURE8 iface, DWORD LODNew) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DTexture8Impl_GetLOD(LPDIRECT3DTEXTURE8 iface) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DTexture8Impl_GetLevelCount(LPDIRECT3DTEXTURE8 iface) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + TRACE("(%p) : returning %d\n", This, This->levels); + return This->levels; +} + +/* IDirect3DTexture8 */ +HRESULT WINAPI IDirect3DTexture8Impl_GetLevelDesc(LPDIRECT3DTEXTURE8 iface, UINT Level,D3DSURFACE_DESC* pDesc) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + + if (Level < This->levels) { + TRACE("(%p) Level (%d)\n", This, Level); + return IDirect3DSurface8Impl_GetDesc((LPDIRECT3DSURFACE8)This->surfaces[Level], pDesc); + } else { + FIXME("(%p) Level (%d)\n", This, Level); + } + return D3D_OK; +} +HRESULT WINAPI IDirect3DTexture8Impl_GetSurfaceLevel(LPDIRECT3DTEXTURE8 iface, UINT Level,IDirect3DSurface8** ppSurfaceLevel) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + *ppSurfaceLevel = (LPDIRECT3DSURFACE8)This->surfaces[Level]; + IDirect3DSurface8Impl_AddRef((LPDIRECT3DSURFACE8)This->surfaces[Level]); + TRACE("(%p) : returning %p for level %d\n", This, *ppSurfaceLevel, Level); + return D3D_OK; +} +HRESULT WINAPI IDirect3DTexture8Impl_LockRect(LPDIRECT3DTEXTURE8 iface, UINT Level,D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + TRACE("(%p) Level (%d)\n", This, Level); + if (Level < This->levels) { + return IDirect3DSurface8Impl_LockRect((LPDIRECT3DSURFACE8)This->surfaces[Level], pLockedRect, pRect, Flags); + } else { + FIXME("Levels seems too high?!!\n"); + } + return D3D_OK; +} +HRESULT WINAPI IDirect3DTexture8Impl_UnlockRect(LPDIRECT3DTEXTURE8 iface, UINT Level) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + This->Dirty = TRUE; + TRACE("(%p) : stub\n", This); + return D3D_OK; +} +HRESULT WINAPI IDirect3DTexture8Impl_AddDirtyRect(LPDIRECT3DTEXTURE8 iface, CONST RECT* pDirtyRect) { + ICOM_THIS(IDirect3DTexture8Impl,iface); + This->Dirty = TRUE; + FIXME("(%p) : stub\n", This); return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DTexture8) Direct3DTexture8_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DTexture8Impl_QueryInterface, + IDirect3DTexture8Impl_AddRef, + IDirect3DTexture8Impl_Release, + IDirect3DTexture8Impl_GetDevice, + IDirect3DTexture8Impl_SetPrivateData, + IDirect3DTexture8Impl_GetPrivateData, + IDirect3DTexture8Impl_FreePrivateData, + IDirect3DTexture8Impl_SetPriority, + IDirect3DTexture8Impl_GetPriority, + IDirect3DTexture8Impl_PreLoad, + IDirect3DTexture8Impl_GetType, + IDirect3DTexture8Impl_SetLOD, + IDirect3DTexture8Impl_GetLOD, + IDirect3DTexture8Impl_GetLevelCount, + IDirect3DTexture8Impl_GetLevelDesc, + IDirect3DTexture8Impl_GetSurfaceLevel, + IDirect3DTexture8Impl_LockRect, + IDirect3DTexture8Impl_UnlockRect, + IDirect3DTexture8Impl_AddDirtyRect + +}; diff --git a/dlls/d3d8/vertexbuffer.c b/dlls/d3d8/vertexbuffer.c new file mode 100644 index 00000000000..6226ac490c8 --- /dev/null +++ b/dlls/d3d8/vertexbuffer.c @@ -0,0 +1,144 @@ +/* + * IDirect3DResource8 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 "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d8_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DResource IUnknown parts follow: */ +HRESULT WINAPI IDirect3DVertexBuffer8Impl_QueryInterface(LPDIRECT3DVERTEXBUFFER8 iface,REFIID riid,LPVOID *ppobj) +{ + ICOM_THIS(IDirect3DVertexBuffer8Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IClassFactory)) { + IDirect3DVertexBuffer8Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DVertexBuffer8Impl_AddRef(LPDIRECT3DVERTEXBUFFER8 iface) { + ICOM_THIS(IDirect3DVertexBuffer8Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DVertexBuffer8Impl_Release(LPDIRECT3DVERTEXBUFFER8 iface) { + ICOM_THIS(IDirect3DVertexBuffer8Impl,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; +} + +/* IDirect3DResource Interface follow: */ +HRESULT WINAPI IDirect3DVertexBuffer8Impl_GetDevice(LPDIRECT3DVERTEXBUFFER8 iface, IDirect3DDevice8** ppDevice) { + ICOM_THIS(IDirect3DVertexBuffer8Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE8) This->Device; + return D3D_OK; +} +HRESULT WINAPI IDirect3DVertexBuffer8Impl_SetPrivateData(LPDIRECT3DVERTEXBUFFER8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DVertexBuffer8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DVertexBuffer8Impl_GetPrivateData(LPDIRECT3DVERTEXBUFFER8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DVertexBuffer8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DVertexBuffer8Impl_FreePrivateData(LPDIRECT3DVERTEXBUFFER8 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DVertexBuffer8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DVertexBuffer8Impl_SetPriority(LPDIRECT3DVERTEXBUFFER8 iface, DWORD PriorityNew) { + ICOM_THIS(IDirect3DVertexBuffer8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DVertexBuffer8Impl_GetPriority(LPDIRECT3DVERTEXBUFFER8 iface) { + ICOM_THIS(IDirect3DVertexBuffer8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +void WINAPI IDirect3DVertexBuffer8Impl_PreLoad(LPDIRECT3DVERTEXBUFFER8 iface) { + ICOM_THIS(IDirect3DVertexBuffer8Impl,iface); + FIXME("(%p) : stub\n", This); +} +D3DRESOURCETYPE WINAPI IDirect3DVertexBuffer8Impl_GetType(LPDIRECT3DVERTEXBUFFER8 iface) { + ICOM_THIS(IDirect3DVertexBuffer8Impl,iface); + TRACE("(%p) : returning %d\n", This, This->ResourceType); + return This->ResourceType; +} + +/* IDirect3DVertexBuffer8 */ +HRESULT WINAPI IDirect3DVertexBuffer8Impl_Lock(LPDIRECT3DVERTEXBUFFER8 iface, UINT OffsetToLock, UINT SizeToLock, BYTE** ppbData, DWORD Flags) { + ICOM_THIS(IDirect3DVertexBuffer8Impl,iface); + if (OffsetToLock) FIXME("(%p) : with non-zero offset!!\n", This); + TRACE("(%p) : returning memory of %p\n", This, This->allocatedMemory); + *ppbData = This->allocatedMemory; + return D3D_OK; +} +HRESULT WINAPI IDirect3DVertexBuffer8Impl_Unlock(LPDIRECT3DVERTEXBUFFER8 iface) { + ICOM_THIS(IDirect3DVertexBuffer8Impl,iface); + TRACE("(%p) : stub\n", This); + return D3D_OK; +} +HRESULT WINAPI IDirect3DVertexBuffer8Impl_GetDesc(LPDIRECT3DVERTEXBUFFER8 iface, D3DVERTEXBUFFER_DESC *pDesc) { + ICOM_THIS(IDirect3DVertexBuffer8Impl,iface); + + TRACE("(%p)\n", This); + pDesc->Format= This->currentDesc.Format; + pDesc->Type= This->currentDesc.Type; + pDesc->Usage= This->currentDesc.Usage; + pDesc->Pool= This->currentDesc.Pool; + pDesc->Size= This->currentDesc.Size; + pDesc->FVF= This->currentDesc.FVF; + return D3D_OK; +} + +ICOM_VTABLE(IDirect3DVertexBuffer8) Direct3DVertexBuffer8_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DVertexBuffer8Impl_QueryInterface, + IDirect3DVertexBuffer8Impl_AddRef, + IDirect3DVertexBuffer8Impl_Release, + IDirect3DVertexBuffer8Impl_GetDevice, + IDirect3DVertexBuffer8Impl_SetPrivateData, + IDirect3DVertexBuffer8Impl_GetPrivateData, + IDirect3DVertexBuffer8Impl_FreePrivateData, + IDirect3DVertexBuffer8Impl_SetPriority, + IDirect3DVertexBuffer8Impl_GetPriority, + IDirect3DVertexBuffer8Impl_PreLoad, + IDirect3DVertexBuffer8Impl_GetType, + IDirect3DVertexBuffer8Impl_Lock, + IDirect3DVertexBuffer8Impl_Unlock, + IDirect3DVertexBuffer8Impl_GetDesc +}; diff --git a/dlls/d3d8/volume.c b/dlls/d3d8/volume.c new file mode 100644 index 00000000000..d9e5cabdd32 --- /dev/null +++ b/dlls/d3d8/volume.c @@ -0,0 +1,115 @@ +/* + * IDirect3DVolume8 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 "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d8_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DVolume IUnknown parts follow: */ +HRESULT WINAPI IDirect3DVolume8Impl_QueryInterface(LPDIRECT3DVOLUME8 iface,REFIID riid,LPVOID *ppobj) +{ + ICOM_THIS(IDirect3DVolume8Impl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IClassFactory)) { + IDirect3DVolume8Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DVolume8Impl_AddRef(LPDIRECT3DVOLUME8 iface) { + ICOM_THIS(IDirect3DVolume8Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DVolume8Impl_Release(LPDIRECT3DVOLUME8 iface) { + ICOM_THIS(IDirect3DVolume8Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) + HeapFree(GetProcessHeap(), 0, This); + return ref; +} + +/* IDirect3DVolume8: */ +HRESULT WINAPI IDirect3DVolume8Impl_GetDevice(LPDIRECT3DVOLUME8 iface, IDirect3DDevice8** ppDevice) { + ICOM_THIS(IDirect3DVolume8Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE8) This->Device; + return D3D_OK; +} +HRESULT WINAPI IDirect3DVolume8Impl_SetPrivateData(LPDIRECT3DVOLUME8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DVolume8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DVolume8Impl_GetPrivateData(LPDIRECT3DVOLUME8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DVolume8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DVolume8Impl_FreePrivateData(LPDIRECT3DVOLUME8 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DVolume8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DVolume8Impl_GetContainer(LPDIRECT3DVOLUME8 iface, REFIID riid, void** ppContainer) { + ICOM_THIS(IDirect3DVolume8Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Container); + *ppContainer = This->Container; + return D3D_OK; +} +HRESULT WINAPI IDirect3DVolume8Impl_GetDesc(LPDIRECT3DVOLUME8 iface, D3DVOLUME_DESC* pDesc) { + ICOM_THIS(IDirect3DVolume8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DVolume8Impl_LockBox(LPDIRECT3DVOLUME8 iface, D3DLOCKED_BOX* pLockedVolume,CONST D3DBOX* pBox, DWORD Flags) { + ICOM_THIS(IDirect3DVolume8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DVolume8Impl_UnlockBox(LPDIRECT3DVOLUME8 iface) { + ICOM_THIS(IDirect3DVolume8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DVolume8) Direct3DVolume8_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DVolume8Impl_QueryInterface, + IDirect3DVolume8Impl_AddRef, + IDirect3DVolume8Impl_Release, + IDirect3DVolume8Impl_GetDevice, + IDirect3DVolume8Impl_SetPrivateData, + IDirect3DVolume8Impl_GetPrivateData, + IDirect3DVolume8Impl_FreePrivateData, + IDirect3DVolume8Impl_GetContainer, + IDirect3DVolume8Impl_GetDesc, + IDirect3DVolume8Impl_LockBox, + IDirect3DVolume8Impl_UnlockBox +}; diff --git a/dlls/d3d8/volumetexture.c b/dlls/d3d8/volumetexture.c new file mode 100644 index 00000000000..c94d7bb5d34 --- /dev/null +++ b/dlls/d3d8/volumetexture.c @@ -0,0 +1,160 @@ +/* + * IDirect3DVolumeTexture8 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 "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "wingdi.h" +#include "wine/debug.h" + +#include "d3d8_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3d); + +/* IDirect3DVolumeTexture8 IUnknown parts follow: */ +HRESULT WINAPI IDirect3DVolumeTexture8Impl_QueryInterface(LPDIRECT3DVOLUMETEXTURE8 iface,REFIID riid,LPVOID *ppobj) +{ + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + + TRACE("(%p) : QueryInterface\n", This); + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IClassFactory)) { + IDirect3DVolumeTexture8Impl_AddRef(iface); + *ppobj = This; + return D3D_OK; + } + + WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj); + return E_NOINTERFACE; +} + +ULONG WINAPI IDirect3DVolumeTexture8Impl_AddRef(LPDIRECT3DVOLUMETEXTURE8 iface) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + TRACE("(%p) : AddRef from %ld\n", This, This->ref); + return ++(This->ref); +} + +ULONG WINAPI IDirect3DVolumeTexture8Impl_Release(LPDIRECT3DVOLUMETEXTURE8 iface) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + ULONG ref = --This->ref; + TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref); + if (ref == 0) + HeapFree(GetProcessHeap(), 0, This); + return ref; +} + +/* IDirect3DVolumeTexture8 IDirect3DResource8 Interface follow: */ +HRESULT WINAPI IDirect3DVolumeTexture8Impl_GetDevice(LPDIRECT3DVOLUMETEXTURE8 iface, IDirect3DDevice8** ppDevice) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + TRACE("(%p) : returning %p\n", This, This->Device); + *ppDevice = (LPDIRECT3DDEVICE8) This->Device; + return D3D_OK; +} +HRESULT WINAPI IDirect3DVolumeTexture8Impl_SetPrivateData(LPDIRECT3DVOLUMETEXTURE8 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DVolumeTexture8Impl_GetPrivateData(LPDIRECT3DVOLUMETEXTURE8 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DVolumeTexture8Impl_FreePrivateData(LPDIRECT3DVOLUMETEXTURE8 iface, REFGUID refguid) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DVolumeTexture8Impl_SetPriority(LPDIRECT3DVOLUMETEXTURE8 iface, DWORD PriorityNew) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DVolumeTexture8Impl_GetPriority(LPDIRECT3DVOLUMETEXTURE8 iface) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +void WINAPI IDirect3DVolumeTexture8Impl_PreLoad(LPDIRECT3DVOLUMETEXTURE8 iface) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); +} +D3DRESOURCETYPE WINAPI IDirect3DVolumeTexture8Impl_GetType(LPDIRECT3DVOLUMETEXTURE8 iface) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + TRACE("(%p) : returning %d\n", This, This->ResourceType); + return This->ResourceType; +} + +/* IDirect3DVolumeTexture8 (Inherited from IDirect3DBaseTexture8) */ +DWORD WINAPI IDirect3DVolumeTexture8Impl_SetLOD(LPDIRECT3DVOLUMETEXTURE8 iface, DWORD LODNew) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DVolumeTexture8Impl_GetLOD(LPDIRECT3DVOLUMETEXTURE8 iface) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +DWORD WINAPI IDirect3DVolumeTexture8Impl_GetLevelCount(LPDIRECT3DVOLUMETEXTURE8 iface) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} + +/* IDirect3DVolumeTexture8 */ +HRESULT WINAPI IDirect3DVolumeTexture8Impl_GetLevelDesc(LPDIRECT3DVOLUMETEXTURE8 iface, UINT Level,D3DVOLUME_DESC *pDesc) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DVolumeTexture8Impl_GetVolumeLevel(LPDIRECT3DVOLUMETEXTURE8 iface, UINT Level,IDirect3DVolume8** ppVolumeLevel) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DVolumeTexture8Impl_LockBox(LPDIRECT3DVOLUMETEXTURE8 iface, UINT Level,D3DLOCKED_BOX* pLockedVolume,CONST D3DBOX* pBox,DWORD Flags) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DVolumeTexture8Impl_UnlockBox(LPDIRECT3DVOLUMETEXTURE8 iface, UINT Level) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} +HRESULT WINAPI IDirect3DVolumeTexture8Impl_AddDirtyBox(LPDIRECT3DVOLUMETEXTURE8 iface, CONST D3DBOX* pDirtyBox) { + ICOM_THIS(IDirect3DVolumeTexture8Impl,iface); + FIXME("(%p) : stub\n", This); return D3D_OK; +} + + +ICOM_VTABLE(IDirect3DVolumeTexture8) Direct3DVolumeTexture8_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirect3DVolumeTexture8Impl_QueryInterface, + IDirect3DVolumeTexture8Impl_AddRef, + IDirect3DVolumeTexture8Impl_Release, + IDirect3DVolumeTexture8Impl_GetDevice, + IDirect3DVolumeTexture8Impl_SetPrivateData, + IDirect3DVolumeTexture8Impl_GetPrivateData, + IDirect3DVolumeTexture8Impl_FreePrivateData, + IDirect3DVolumeTexture8Impl_SetPriority, + IDirect3DVolumeTexture8Impl_GetPriority, + IDirect3DVolumeTexture8Impl_PreLoad, + IDirect3DVolumeTexture8Impl_GetType, + IDirect3DVolumeTexture8Impl_SetLOD, + IDirect3DVolumeTexture8Impl_GetLOD, + IDirect3DVolumeTexture8Impl_GetLevelCount, + IDirect3DVolumeTexture8Impl_GetLevelDesc, + IDirect3DVolumeTexture8Impl_GetVolumeLevel, + IDirect3DVolumeTexture8Impl_LockBox, + IDirect3DVolumeTexture8Impl_UnlockBox, + IDirect3DVolumeTexture8Impl_AddDirtyBox +}; -- 2.11.4.GIT