Initial D3D8 implementation.

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)

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@
 

dlls/d3d8/basetexture.c

+/*
+ * 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,
+};

dlls/d3d8/cubetexture.c

+/*
+ * 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; i<This->levels; 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
+};

dlls/d3d8/d3d8.spec

+init D3D8_DllMain
+
 @ stdcall D3D8GetSWInfo() D3D8GetSWInfo
 @ stdcall DebugSetMute() DebugSetMute
 @ stdcall Direct3DCreate8(long) Direct3DCreate8

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;
 }

dlls/d3d8/indexbuffer.c

+/*
+ * 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
+};

dlls/d3d8/resource.c

+/*
+ * 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
+};

dlls/d3d8/surface.c

+/*
+ * 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,
+};

dlls/d3d8/swapchain.c

+/*
+ * 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
+};

dlls/d3d8/texture.c

+/*
+ * 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; i<This->levels; 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
+
+};

dlls/d3d8/vertexbuffer.c

+/*
+ * 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
+};

dlls/d3d8/volume.c

+/*
+ * 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
+};

dlls/d3d8/volumetexture.c

+/*
+ * 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
+};