Add render target support, and ensure there is a front and back buffer

dlls/d3d8/d3d8_private.h

@@ -643,6 +643,8 @@ struct IDirect3DSurface8Impl
     BOOL                    Dirty;
     BOOL                    inTexture;
     BOOL                    inPBuffer;
+
+    IWineD3DSurface        *wineD3DSurface;
 };
 
 /* IUnknown: */

dlls/d3d8/directx.c

@@ -538,6 +538,24 @@ static void IDirect3D8Impl_FillGLCaps(LPDIRECT3D8 iface, Display* display) {
 
 }
 
+/* Internal function called back during the CreateDevice to create a render target */
+HRESULT WINAPI D3D8CB_CreateRenderTarget(IUnknown *device, UINT Width, UINT Height, 
+                                         D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, 
+                                         DWORD MultisampleQuality, BOOL Lockable, 
+                                         IWineD3DSurface** ppSurface, HANDLE* pSharedHandle) {
+    HRESULT res = D3D_OK;
+    IDirect3DSurface8Impl *d3dSurface = NULL;
+
+    /* Note - Throw away MultisampleQuality and SharedHandle - only relevant for d3d9  */
+    res = IDirect3DDevice8_CreateRenderTarget((IDirect3DDevice8 *)device, Width, Height, 
+                                         Format, MultiSample, Lockable, 
+                                         (IDirect3DSurface8 **)&d3dSurface);
+    if (res == D3D_OK) {
+        *ppSurface = d3dSurface->wineD3DSurface;
+    }
+    return res;
+}
+
 HRESULT  WINAPI  IDirect3D8Impl_CreateDevice               (LPDIRECT3D8 iface,
                                                             UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow,
                                                             DWORD BehaviourFlags, D3DPRESENT_PARAMETERS* pPresentationParameters,
@@ -583,7 +601,7 @@ HRESULT  WINAPI  IDirect3D8Impl_CreateDevice               (LPDIRECT3D8 iface,
     localParameters.Flags                          = &pPresentationParameters->Flags;                      
     localParameters.FullScreen_RefreshRateInHz     = &pPresentationParameters->FullScreen_RefreshRateInHz; 
     localParameters.PresentationInterval           = &pPresentationParameters->FullScreen_PresentationInterval;    /* Renamed in dx9 */
-    IWineD3D_CreateDevice(This->WineD3D, Adapter, DeviceType, hFocusWindow, BehaviourFlags, &localParameters, &object->WineD3DDevice, (IUnknown *)object);
+    IWineD3D_CreateDevice(This->WineD3D, Adapter, DeviceType, hFocusWindow, BehaviourFlags, &localParameters, &object->WineD3DDevice, (IUnknown *)object, D3D8CB_CreateRenderTarget);
 
     /** use StateBlock Factory here, for creating the startup stateBlock */
     object->StateBlock = NULL;

dlls/d3d8/surface.c

@@ -479,7 +479,7 @@ IDirect3DSurface8Vtbl Direct3DSurface8_Vtbl =
 };
 
 
-HRESULT WINAPI IDirect3DSurface8Impl_LoadTexture(LPDIRECT3DSURFACE8 iface, GLenum gl_target, GLenum gl_level) {
+HRESULT WINAPI IDirect3DSurface8Impl_LoadTexture(LPDIRECT3DSURFACE8 iface, UINT gl_target, UINT gl_level) {
   IDirect3DSurface8Impl *This = (IDirect3DSurface8Impl *)iface;
 
   if (This->inTexture)

dlls/d3d9/d3d9_private.h

@@ -577,20 +577,8 @@ struct IDirect3DSurface9Impl
     DWORD                   ref;
 
     /* IDirect3DResource9 fields */
-    D3DRESOURCETYPE         ResourceType;
+    IWineD3DSurface        *wineD3DSurface;
 
-    /* IDirect3DSurface9 fields */
-    IUnknown               *Container;
-    D3DSURFACE_DESC         myDesc;
-    BYTE                   *allocatedMemory;
-    UINT                    textureName;
-    UINT                    bytesPerPixel;
-
-    BOOL                    lockable;
-    BOOL                    locked;
-    RECT                    lockedRect;
-    RECT                    dirtyRect;
-    BOOL                    Dirty;
 };
 
 /* IUnknown: */

dlls/d3d9/device.c

@@ -114,10 +114,11 @@ HRESULT  WINAPI  IDirect3DDevice9Impl_GetCreationParameters(LPDIRECT3DDEVICE9 if
 }
 
 HRESULT  WINAPI  IDirect3DDevice9Impl_SetCursorProperties(LPDIRECT3DDEVICE9 iface, UINT XHotSpot, UINT YHotSpot, IDirect3DSurface9* pCursorBitmap) {
-    IDirect3DSurface9Impl* pSur = (IDirect3DSurface9Impl*) pCursorBitmap;
     IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
     TRACE("(%p) : Spot Pos(%u,%u)\n", This, XHotSpot, YHotSpot);
 
+/* TODO:
+    IDirect3DSurface9Impl* pSur = (IDirect3DSurface9Impl*) pCursorBitmap;
     if (D3DFMT_A8R8G8B8 != pSur->myDesc.Format) {
       ERR("(%p) : surface(%p) have a invalid format\n", This, pCursorBitmap);
       return D3DERR_INVALIDCALL;
@@ -126,6 +127,7 @@ HRESULT  WINAPI  IDirect3DDevice9Impl_SetCursorProperties(LPDIRECT3DDEVICE9 ifac
       ERR("(%p) : surface(%p) have a invalid size\n", This, pCursorBitmap);
       return D3DERR_INVALIDCALL;
     }
+*/    
 
     This->xHotSpot = XHotSpot;
     This->yHotSpot = YHotSpot;
@@ -205,9 +207,21 @@ void WINAPI IDirect3DDevice9Impl_GetGammaRamp(LPDIRECT3DDEVICE9 iface, UINT iSwa
     return;
 }
 
-HRESULT  WINAPI  IDirect3DDevice9Impl_CreateRenderTarget(LPDIRECT3DDEVICE9 iface, UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality, BOOL Lockable, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle) {
+HRESULT  WINAPI  IDirect3DDevice9Impl_CreateRenderTarget(LPDIRECT3DDEVICE9 iface, UINT Width, UINT Height, 
+                                                         D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, 
+                                                         DWORD MultisampleQuality, BOOL Lockable, 
+                                                         IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle) {
+    IDirect3DSurface9Impl *object;
     IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
-    FIXME("(%p) : stub\n", This);    
+
+    /* Allocate the storage for the device */
+    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DSurface9Impl));
+    object->lpVtbl = &Direct3DSurface9_Vtbl;
+    object->ref = 1;
+    IWineD3DDevice_CreateRenderTarget(This->WineD3DDevice, Width, Height, Format, MultiSample, MultisampleQuality, 
+                                      Lockable, &object->wineD3DSurface, pSharedHandle, (IUnknown *)This);
+    *ppSurface = (LPDIRECT3DSURFACE9) object;
+
     return D3D_OK;
 }
 

dlls/d3d9/directx.c

@@ -152,6 +152,23 @@ HMONITOR WINAPI  IDirect3D9Impl_GetAdapterMonitor(LPDIRECT3D9 iface, UINT Adapte
     return IWineD3D_GetAdapterMonitor(This->WineD3D, Adapter);
 }
 
+/* Internal function called back during the CreateDevice to create a render target */
+HRESULT WINAPI D3D9CB_CreateRenderTarget(IUnknown *device, UINT Width, UINT Height, 
+                                         D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, 
+                                         DWORD MultisampleQuality, BOOL Lockable, 
+                                         IWineD3DSurface** ppSurface, HANDLE* pSharedHandle) {
+    HRESULT res = D3D_OK;
+    IDirect3DSurface9Impl *d3dSurface = NULL;
+
+    res = IDirect3DDevice9_CreateRenderTarget((IDirect3DDevice9 *)device, Width, Height, 
+                                         Format, MultiSample, MultisampleQuality, Lockable, 
+                                         (IDirect3DSurface9 **)&d3dSurface, pSharedHandle);
+    if (res == D3D_OK) {
+        *ppSurface = d3dSurface->wineD3DSurface;
+    }
+    return res;
+}
+
 HRESULT  WINAPI  IDirect3D9Impl_CreateDevice(LPDIRECT3D9 iface, UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow,
 					     DWORD BehaviourFlags, D3DPRESENT_PARAMETERS* pPresentationParameters, 
 					     IDirect3DDevice9** ppReturnedDeviceInterface) {
@@ -191,7 +208,7 @@ HRESULT  WINAPI  IDirect3D9Impl_CreateDevice(LPDIRECT3D9 iface, UINT Adapter, D3
     localParameters.Flags                          = &pPresentationParameters->Flags;                      
     localParameters.FullScreen_RefreshRateInHz     = &pPresentationParameters->FullScreen_RefreshRateInHz; 
     localParameters.PresentationInterval           = &pPresentationParameters->PresentationInterval;       
-    IWineD3D_CreateDevice(This->WineD3D, Adapter, DeviceType, hFocusWindow, BehaviourFlags, &localParameters, &object->WineD3DDevice, (IUnknown *)object);
+    IWineD3D_CreateDevice(This->WineD3D, Adapter, DeviceType, hFocusWindow, BehaviourFlags, &localParameters, &object->WineD3DDevice, (IUnknown *)object, D3D9CB_CreateRenderTarget);
 
     FIXME("(%p) : incomplete stub\n", This);
     return D3D_OK;

dlls/d3d9/surface.c

 /*
  * IDirect3DSurface9 implementation
  *
- * Copyright 2002-2003 Jason Edmeades
+ * Copyright 2002-2005 Jason Edmeades
  *                     Raphael Junqueira
  *
  * This library is free software; you can redistribute it and/or
@@ -29,7 +29,7 @@ HRESULT WINAPI IDirect3DSurface9Impl_QueryInterface(LPDIRECT3DSURFACE9 iface, RE
     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
 
     if (IsEqualGUID(riid, &IID_IUnknown)
-	|| IsEqualGUID(riid, &IID_IDirect3DResource9)
+        || IsEqualGUID(riid, &IID_IDirect3DResource9)
         || IsEqualGUID(riid, &IID_IDirect3DSurface9)) {
         IDirect3DSurface9Impl_AddRef(iface);
         *ppobj = This;
@@ -43,16 +43,16 @@ HRESULT WINAPI IDirect3DSurface9Impl_QueryInterface(LPDIRECT3DSURFACE9 iface, RE
 ULONG WINAPI IDirect3DSurface9Impl_AddRef(LPDIRECT3DSURFACE9 iface) {
     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
     TRACE("(%p) : AddRef from %ld\n", This, This->ref);
-    return ++(This->ref);
+    return InterlockedIncrement(&This->ref);
 }
 
 ULONG WINAPI IDirect3DSurface9Impl_Release(LPDIRECT3DSURFACE9 iface) {
     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
-    ULONG ref = --This->ref;
+    ULONG ref = InterlockedDecrement(&This->ref);
     TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
     if (ref == 0) {
-      HeapFree(GetProcessHeap(), 0, This->allocatedMemory);
-      HeapFree(GetProcessHeap(), 0, This);
+        IWineD3DBaseTexture_Release(This->wineD3DSurface);
+        HeapFree(GetProcessHeap(), 0, This);
     }
     return ref;
 }
@@ -65,89 +65,103 @@ HRESULT WINAPI IDirect3DSurface9Impl_GetDevice(LPDIRECT3DSURFACE9 iface, IDirect
 
 HRESULT WINAPI IDirect3DSurface9Impl_SetPrivateData(LPDIRECT3DSURFACE9 iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags) {
     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
-    FIXME("(%p) : stub\n", This);    
-    return D3D_OK;
+    return IWineD3DSurface_SetPrivateData(This->wineD3DSurface, refguid, pData, SizeOfData, Flags);
 }
 
 HRESULT WINAPI IDirect3DSurface9Impl_GetPrivateData(LPDIRECT3DSURFACE9 iface, REFGUID refguid, void* pData, DWORD* pSizeOfData) {
     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
-    FIXME("(%p) : stub\n", This);    
-    return D3D_OK;
+    return IWineD3DSurface_GetPrivateData(This->wineD3DSurface, refguid, pData, pSizeOfData);
 }
 
 HRESULT WINAPI IDirect3DSurface9Impl_FreePrivateData(LPDIRECT3DSURFACE9 iface, REFGUID refguid) {
     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
-    FIXME("(%p) : stub\n", This);    
-    return D3D_OK;
+    return IWineD3DSurface_FreePrivateData(This->wineD3DSurface, refguid);
 }
 
-DWORD   WINAPI IDirect3DSurface9Impl_SetPriority(LPDIRECT3DSURFACE9 iface, DWORD PriorityNew) {
+DWORD WINAPI IDirect3DSurface9Impl_SetPriority(LPDIRECT3DSURFACE9 iface, DWORD PriorityNew) {
     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
-    return IDirect3DResource9Impl_SetPriority((LPDIRECT3DRESOURCE9) This, PriorityNew);
+    return IWineD3DSurface_SetPriority(This->wineD3DSurface, PriorityNew);
 }
 
-DWORD   WINAPI IDirect3DSurface9Impl_GetPriority(LPDIRECT3DSURFACE9 iface) {
+DWORD WINAPI IDirect3DSurface9Impl_GetPriority(LPDIRECT3DSURFACE9 iface) {
     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
-    return IDirect3DResource9Impl_GetPriority((LPDIRECT3DRESOURCE9) This);
+    return IWineD3DSurface_GetPriority(This->wineD3DSurface);
 }
 
-void    WINAPI IDirect3DSurface9Impl_PreLoad(LPDIRECT3DSURFACE9 iface) {
+void WINAPI IDirect3DSurface9Impl_PreLoad(LPDIRECT3DSURFACE9 iface) {
     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
-    FIXME("(%p) : stub\n", This);    
+    IWineD3DSurface_PreLoad(This->wineD3DSurface);
     return ;
 }
 
 D3DRESOURCETYPE WINAPI IDirect3DSurface9Impl_GetType(LPDIRECT3DSURFACE9 iface) {
     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
-    return IDirect3DResource9Impl_GetType((LPDIRECT3DRESOURCE9) This);
+    return IWineD3DSurface_GetType(This->wineD3DSurface);
 }
 
 /* IDirect3DSurface9 Interface follow: */
 HRESULT WINAPI IDirect3DSurface9Impl_GetContainer(LPDIRECT3DSURFACE9 iface, REFIID riid, void** ppContainer) {
     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
     HRESULT res;
-    res = IUnknown_QueryInterface(This->Container, riid, ppContainer);
-    if (E_NOINTERFACE == res) { 
-      /**
-       * If the surface is created using CreateImageSurface, CreateRenderTarget, 
-       * or CreateDepthStencilSurface, the surface is considered stand alone. In this case, 
-       * GetContainer will return the Direct3D device used to create the surface. 
-       */
-      res = IUnknown_QueryInterface(This->Container, &IID_IDirect3DDevice9, ppContainer);
+
+    /* The container returned from IWineD3DSurface_GetContainer is either a IWineD3DDevice or
+       opne of the subclasses of resource                                                     */
+    IUnknown *IWineContainer = NULL;
+    res = IWineD3DSurface_GetContainer(This->wineD3DSurface, riid, (void **)&IWineContainer);
+
+    if (res == D3D_OK) {
+        IWineD3DDevice *myDevice = NULL;
+        IWineD3DResource_GetDevice((IWineD3DSurface *)This->wineD3DSurface, &myDevice);
+
+        if (IWineContainer == (IUnknown *)myDevice) {
+            IWineD3DDevice_GetParent((IWineD3DDevice *)IWineContainer, (IUnknown **)ppContainer);
+            IWineD3DDevice_Release((IWineD3DDevice *)IWineContainer);
+        } else {
+            IWineD3DResource_GetParent((IWineD3DResource *)IWineContainer, (IUnknown **)ppContainer);
+            IWineD3DResource_Release((IWineD3DResource *)IWineContainer);
+        }
+
+        IWineD3DDevice_Release(myDevice);
     }
-    TRACE("(%p) : returning %p\n", This, *ppContainer);
+
     return res;
 }
 
 HRESULT WINAPI IDirect3DSurface9Impl_GetDesc(LPDIRECT3DSURFACE9 iface, D3DSURFACE_DESC* pDesc) {
     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
-    TRACE("(%p) : copying into %p\n", This, pDesc);
-    memcpy(pDesc, &This->myDesc, sizeof(D3DSURFACE_DESC));
-    return D3D_OK;
+    WINED3DSURFACE_DESC    wined3ddesc;
+
+    /* As d3d8 and d3d9 structures differ, pass in ptrs to where data needs to go */
+    wined3ddesc.Format              = &pDesc->Format;
+    wined3ddesc.Type                = &pDesc->Type;
+    wined3ddesc.Usage               = &pDesc->Usage;
+    wined3ddesc.Pool                = &pDesc->Pool;
+    wined3ddesc.MultiSampleType     = &pDesc->MultiSampleType;
+    wined3ddesc.MultiSampleQuality  = &pDesc->MultiSampleQuality;
+    wined3ddesc.Width               = &pDesc->Width;
+    wined3ddesc.Height              = &pDesc->Height;
+
+    return IWineD3DSurface_GetDesc(This->wineD3DSurface, &wined3ddesc);
 }
 
 HRESULT WINAPI IDirect3DSurface9Impl_LockRect(LPDIRECT3DSURFACE9 iface, D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) {
     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
-    FIXME("(%p) : stub\n", This);
-    return D3D_OK;
+    return IWineD3DSurface_LockRect(This->wineD3DSurface, pLockedRect, pRect, Flags);
 }
 
 HRESULT WINAPI IDirect3DSurface9Impl_UnlockRect(LPDIRECT3DSURFACE9 iface) {
     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
-    FIXME("(%p) : stub\n", This);
-    return D3D_OK;
+    return IWineD3DSurface_UnlockRect(This->wineD3DSurface);
 }
 
 HRESULT WINAPI IDirect3DSurface9Impl_GetDC(LPDIRECT3DSURFACE9 iface, HDC* phdc) {
     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
-    FIXME("(%p) : stub\n", This);
-    return D3D_OK;
+    return IWineD3DSurface_GetDC(This->wineD3DSurface, phdc);
 }
 
 HRESULT WINAPI IDirect3DSurface9Impl_ReleaseDC(LPDIRECT3DSURFACE9 iface, HDC hdc) {
     IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
-    FIXME("(%p) : stub\n", This);
-    return D3D_OK;
+    return IWineD3DSurface_ReleaseDC(This->wineD3DSurface, hdc);
 }
 
 

dlls/wined3d/Makefile.in

@@ -15,6 +15,7 @@ C_SRCS = \
 	indexbuffer.c \
 	resource.c \
 	stateblock.c \
+	surface.c \
 	utils.c \
 	vertexbuffer.c \
 	vertexshader.c \

dlls/wined3d/basetexture.c

@@ -48,7 +48,7 @@ ULONG WINAPI IWineD3DBaseTextureImpl_Release(IWineD3DBaseTexture *iface) {
     TRACE("(%p) : Releasing from %ld\n", This, This->resource.ref);
     ref = InterlockedDecrement(&This->resource.ref);
     if (ref == 0) {
-        IWineD3DDevice_Release(This->resource.wineD3DDevice);
+        IWineD3DDevice_Release((IWineD3DDevice *)This->resource.wineD3DDevice);
         HeapFree(GetProcessHeap(), 0, This);
     } else {
         IUnknown_Release(This->resource.parent);  /* Released the reference to the d3dx object */
@@ -134,6 +134,15 @@ void WINAPI IWineD3DBaseTextureImpl_GenerateMipSubLevels(IWineD3DBaseTexture *if
   return ;
 }
 
+/* Internal function, No d3d mapping */
+BOOL WINAPI IWineD3DBaseTextureImpl_SetDirty(IWineD3DBaseTexture *iface, BOOL dirty) {
+    BOOL old;
+    IWineD3DBaseTextureImpl *This = (IWineD3DBaseTextureImpl *)iface;
+    old = This->baseTexture.dirty;
+    This->baseTexture.dirty = dirty;
+    return old;
+}
+
 IWineD3DBaseTextureVtbl IWineD3DBaseTexture_Vtbl =
 {
     IWineD3DBaseTextureImpl_QueryInterface,
@@ -153,5 +162,6 @@ IWineD3DBaseTextureVtbl IWineD3DBaseTexture_Vtbl =
     IWineD3DBaseTextureImpl_GetLevelCount,
     IWineD3DBaseTextureImpl_SetAutoGenFilterType,
     IWineD3DBaseTextureImpl_GetAutoGenFilterType,
-    IWineD3DBaseTextureImpl_GenerateMipSubLevels
+    IWineD3DBaseTextureImpl_GenerateMipSubLevels,
+    IWineD3DBaseTextureImpl_SetDirty
 };

dlls/wined3d/device.c

@@ -217,8 +217,12 @@ HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexBuffer(IWineD3DDevice *iface, UINT
 
     /* Allocate the storage for the device */
     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DVertexBufferImpl));
+    if (NULL == object) {
+        *ppVertexBuffer = NULL;
+        return D3DERR_OUTOFVIDEOMEMORY;
+    }
     object->lpVtbl                = &IWineD3DVertexBuffer_Vtbl;
-    object->resource.wineD3DDevice= iface;
+    object->resource.wineD3DDevice= This;
     IWineD3DDevice_AddRef(iface);
     object->resource.parent       = parent;
     object->resource.resourceType = D3DRTYPE_VERTEXBUFFER;
@@ -243,11 +247,15 @@ HRESULT WINAPI IWineD3DDeviceImpl_CreateIndexBuffer(IWineD3DDevice *iface, UINT
 
     /* Allocate the storage for the device */
     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DIndexBufferImpl));
+    if (NULL == object) {
+        *ppIndexBuffer = NULL;
+        return D3DERR_OUTOFVIDEOMEMORY;
+    }
     object->lpVtbl = &IWineD3DIndexBuffer_Vtbl;
-    object->resource.wineD3DDevice = iface;
+    object->resource.wineD3DDevice = This;
+    IWineD3DDevice_AddRef(iface);
     object->resource.resourceType  = D3DRTYPE_INDEXBUFFER;
     object->resource.parent        = parent;
-    IWineD3DDevice_AddRef(iface);
     object->resource.ref = 1;
     object->allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, Length);
     object->currentDesc.Usage = Usage;
@@ -269,8 +277,12 @@ HRESULT WINAPI IWineD3DDeviceImpl_CreateStateBlock(IWineD3DDevice* iface, D3DSTA
   
     /* Allocate Storage for the state block */
     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DStateBlockImpl));
+    if (NULL == object) {
+        *ppStateBlock = NULL;
+        return D3DERR_OUTOFVIDEOMEMORY;
+    }
     object->lpVtbl        = &IWineD3DStateBlock_Vtbl;
-    object->wineD3DDevice = iface;
+    object->wineD3DDevice = This;
     IWineD3DDevice_AddRef(iface);
     object->parent        = parent;
     object->ref           = 1;
@@ -292,6 +304,49 @@ HRESULT WINAPI IWineD3DDeviceImpl_CreateStateBlock(IWineD3DDevice* iface, D3DSTA
     return D3D_OK;
 }
 
+HRESULT WINAPI IWineD3DDeviceImpl_CreateRenderTarget(IWineD3DDevice *iface, UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, 
+                                                     DWORD MultisampleQuality, BOOL Lockable, IWineD3DSurface** ppSurface, HANDLE* pSharedHandle, 
+                                                     IUnknown *parent) {
+    IWineD3DSurfaceImpl *object;
+    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
+    
+    object  = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DSurfaceImpl));
+    if (NULL == object) {
+        *ppSurface = NULL;
+        return D3DERR_OUTOFVIDEOMEMORY;
+    }
+    object->lpVtbl                 = &IWineD3DSurface_Vtbl;
+    object->resource.wineD3DDevice = This;
+    IWineD3DDevice_AddRef(iface);
+    object->resource.resourceType  = D3DRTYPE_SURFACE;
+    object->resource.parent        = parent;
+    object->resource.ref           = 1;
+    *ppSurface = (IWineD3DSurface *)object;
+    object->container     = (IUnknown*) This;
+
+    object->currentDesc.Width  = Width;
+    object->currentDesc.Height = Height;
+    object->currentDesc.Format = Format;
+    object->currentDesc.Type   = D3DRTYPE_SURFACE;
+    object->currentDesc.Usage  = D3DUSAGE_RENDERTARGET;
+    object->currentDesc.Pool   = D3DPOOL_DEFAULT;
+    object->currentDesc.MultiSampleType = MultiSample;
+    object->bytesPerPixel = D3DFmtGetBpp(This, Format);
+    if (Format == D3DFMT_DXT1) { 
+        object->currentDesc.Size = (Width * object->bytesPerPixel)/2 * Height;  /* DXT1 is half byte per pixel */
+    } else {
+        object->currentDesc.Size = (Width * object->bytesPerPixel) * Height;
+    }
+    object->allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, object->currentDesc.Size);
+    object->lockable = Lockable;
+    object->locked = FALSE;
+    memset(&object->lockedRect, 0, sizeof(RECT));
+    IWineD3DSurface_CleanDirtyRect(*ppSurface);
+
+    TRACE("(%p) : w(%d) h(%d) fmt(%d,%s) lockable(%d) surf@%p, surfmem@%p, %d bytes\n", This, Width, Height, Format, debug_d3dformat(Format), Lockable, *ppSurface, object->allocatedMemory, object->currentDesc.Size);
+    return D3D_OK;
+}
+
 /*****
  * Get / Set FVF
  *****/
@@ -1158,12 +1213,10 @@ HRESULT WINAPI IWineD3DDeviceImpl_SetViewport(IWineD3DDevice *iface, CONST WINED
     glDepthRange(pViewport->MinZ, pViewport->MaxZ);
     checkGLcall("glDepthRange");
 
-#if 0 /* TODO */
     /* Note: GL requires lower left, DirectX supplies upper left */
-    glViewport(pViewport->X, (This->renderTarget->myDesc.Height - (pViewport->Y + pViewport->Height)), 
+    glViewport(pViewport->X, (This->renderTarget->currentDesc.Height - (pViewport->Y + pViewport->Height)), 
                pViewport->Width, pViewport->Height);
     checkGLcall("glViewport");
-#endif
 
     LEAVE_GL();
 
@@ -2610,25 +2663,22 @@ HRESULT WINAPI IWineD3DDeviceImpl_EndScene(IWineD3DDevice *iface) {
     glFlush();
     checkGLcall("glFlush");
 
-#if 0  /* TODO: render targer support */
     if ((This->frontBuffer != This->renderTarget) && (This->backBuffer != This->renderTarget)) {
 
-      IWineD3DBaseTexture *cont = NULL;
-      HRESULT              hr;
-
-      hr = IDirect3DSurface8_GetContainer((LPDIRECT3DSURFACE8) This->renderTarget, &IID_IDirect3DBaseTexture8, (void**) &cont);
-      if (SUCCEEDED(hr) && NULL != cont) {
-        /** always dirtify for now. we must find a better way to see that surface have been modified */
-        This->renderTarget->inPBuffer = TRUE;
-        This->renderTarget->inTexture = FALSE;
-              IDirect3DBaseTexture8Impl_SetDirty(cont, TRUE);
-        IDirect3DBaseTexture8_PreLoad(cont);
-        This->renderTarget->inPBuffer = FALSE;
-        IDirect3DBaseTexture8Impl_Release(cont);
-        cont = NULL;
-      }
+        /* If we are rendering to a texture (surface) then flag it as dirty.
+           A surfaces container is either the appropriate texture or the device itself
+              depending on how the surface was created.                                */
+        if (This->renderTarget != NULL && ((IWineD3DDeviceImpl *)This->renderTarget->container != This)) {
+
+            IWineD3DBaseTexture *cont = (IWineD3DBaseTexture *)This->renderTarget->container;
+            /** always dirtify for now. we must find a better way to see that surface have been modified */
+            This->renderTarget->inPBuffer = TRUE;
+            This->renderTarget->inTexture = FALSE;
+            IWineD3DBaseTexture_SetDirty(cont, TRUE);
+            IWineD3DBaseTexture_PreLoad(cont);
+            This->renderTarget->inPBuffer = FALSE;
+        }
     }
-#endif  /* TODO: render targer support */
 
     LEAVE_GL();
     return D3D_OK;
@@ -2776,24 +2826,22 @@ HRESULT WINAPI IWineD3DDeviceImpl_Clear(IWineD3DDevice *iface, DWORD Count, CONS
     /* Now process each rect in turn */
     for (i = 0; i < Count || i == 0; i++) {
 
-#if 0 /* TODO: renderTarget support */
         if (curRect) {
             /* Note gl uses lower left, width/height */
             TRACE("(%p) %p Rect=(%ld,%ld)->(%ld,%ld) glRect=(%ld,%ld), len=%ld, hei=%ld\n", This, curRect,
                   curRect->x1, curRect->y1, curRect->x2, curRect->y2,
-                  curRect->x1, (This->renderTarget->myDesc.Height - curRect->y2), 
+                  curRect->x1, (This->renderTarget->currentDesc.Height - curRect->y2), 
                   curRect->x2 - curRect->x1, curRect->y2 - curRect->y1);
-            glScissor(curRect->x1, (This->renderTarget->myDesc.Height - curRect->y2), 
+            glScissor(curRect->x1, (This->renderTarget->currentDesc.Height - curRect->y2), 
                       curRect->x2 - curRect->x1, curRect->y2 - curRect->y1);
             checkGLcall("glScissor");
         } else {
             glScissor(This->stateBlock->viewport.X, 
-                      (This->renderTarget->myDesc.Height - (This->stateBlock->viewport.Y + This->stateBlock->viewport.Height)), 
+                      (This->renderTarget->currentDesc.Height - (This->stateBlock->viewport.Y + This->stateBlock->viewport.Height)), 
                       This->stateBlock->viewport.Width, 
                       This->stateBlock->viewport.Height);
             checkGLcall("glScissor");
         }
-#endif
 
         /* Clear the selected rectangle (or full screen) */
         glClear(glMask);
@@ -2980,6 +3028,7 @@ IWineD3DDeviceVtbl IWineD3DDevice_Vtbl =
     IWineD3DDeviceImpl_CreateVertexBuffer,
     IWineD3DDeviceImpl_CreateIndexBuffer,
     IWineD3DDeviceImpl_CreateStateBlock,
+    IWineD3DDeviceImpl_CreateRenderTarget,
 
     IWineD3DDeviceImpl_SetFVF,
     IWineD3DDeviceImpl_GetFVF,

dlls/wined3d/directx.c

@@ -1313,7 +1313,7 @@ HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter, D3DDEVT
    and fields being inserted in the middle, a new structure is used in place    */
 HRESULT  WINAPI  IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow,
                                            DWORD BehaviourFlags, WINED3DPRESENT_PARAMETERS* pPresentationParameters,
-                                           IWineD3DDevice** ppReturnedDeviceInterface, IUnknown *parent) {
+                                           IWineD3DDevice** ppReturnedDeviceInterface, IUnknown *parent, D3DCB_CREATERENDERTARGETFN D3DCB_CreateRenderTarget) {
 
     HWND                whichHWND;
     HDC                 hDc;
@@ -1479,23 +1479,32 @@ HRESULT  WINAPI  IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT Adapter, D3DDEV
     /* Setup surfaces for the backbuffer, frontbuffer and depthstencil buffer */
     TRACE("Creating initial device surfaces\n");
 
-/* TODO:
-    IWineD3DDevice_CreateRenderTarget((IWineD3DDevice *) object,
-                                      *(pPresentationParameters->BackBufferWidth),
-                                      *(pPresentationParameters->BackBufferHeight),
-                                      *(pPresentationParameters->BackBufferFormat),
-                                      *(pPresentationParameters->MultiSampleType),
-                                      TRUE,
-                                      (IWineD3DSurface *) &object->frontBuffer);
-
-    IWineD3DDevice_CreateRenderTarget((IWineD3DDevice *) object,
-                                      *(pPresentationParameters->BackBufferWidth),
-                                      *(pPresentationParameters->BackBufferHeight),
-                                      *(pPresentationParameters->BackBufferFormat),
-                                      *(pPresentationParameters->MultiSampleType),
-                                      TRUE,
-                                      (IWineD3DSurface *) &object->backBuffer);
-
+    /* We need to 'magic' either d3d8 or d3d9 surfaces for the front and backbuuffer 
+       but the respective CreateRenderTarget functions take a differing number of
+       parms. Fix this by passing in a function to call which takes identical parms
+       and handles the differences at the d3dx layer, and returns the IWineD3DSurface
+       pointer rather than the created D3D8/9 one                                      */
+    D3DCB_CreateRenderTarget((IUnknown *) parent,
+                             *(pPresentationParameters->BackBufferWidth),
+                             *(pPresentationParameters->BackBufferHeight),
+                             *(pPresentationParameters->BackBufferFormat),
+                             *(pPresentationParameters->MultiSampleType),
+                             *(pPresentationParameters->MultiSampleQuality),
+                             TRUE,
+                             (IWineD3DSurface **) &object->frontBuffer,
+                             NULL);
+
+    D3DCB_CreateRenderTarget((IUnknown *) parent,
+                             *(pPresentationParameters->BackBufferWidth),
+                             *(pPresentationParameters->BackBufferHeight),
+                             *(pPresentationParameters->BackBufferFormat),
+                             *(pPresentationParameters->MultiSampleType),
+                             *(pPresentationParameters->MultiSampleQuality),
+                             TRUE,
+                             (IWineD3DSurface **) &object->backBuffer,
+                             NULL);
+
+/* TODO: 
     if (*(pPresentationParameters->EnableAutoDepthStencil)) {
        IWineD3DDevice_CreateDepthStencilSurface((IWineD3DDevice *) object,
                                                 *(pPresentationParameters->BackBufferWidth),
@@ -1512,10 +1521,10 @@ HRESULT  WINAPI  IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT Adapter, D3DDEV
     /* init the default renderTarget management */
     object->drawable     = object->win;
     object->render_ctx   = object->glCtx;
-/* TODO:
     object->renderTarget = object->backBuffer;
     
     IWineD3DSurface_AddRef((IWineD3DSurface *) object->renderTarget);
+/* TODO: Depth Stencil support
     object->stencilBufferTarget = object->depthStencilBuffer;
     if (NULL != object->stencilBufferTarget) {
       IDirect3DSurface8Impl_AddRef((LPDIRECT3DSURFACE8) object->stencilBufferTarget);

dlls/wined3d/indexbuffer.c

@@ -50,7 +50,7 @@ ULONG WINAPI IWineD3DIndexBufferImpl_Release(IWineD3DIndexBuffer *iface) {
     ref = InterlockedDecrement(&This->resource.ref);
     if (ref == 0) {
         HeapFree(GetProcessHeap(), 0, This->allocatedMemory);
-        IWineD3DDevice_Release(This->resource.wineD3DDevice);
+        IWineD3DDevice_Release((IWineD3DDevice *)This->resource.wineD3DDevice);
         HeapFree(GetProcessHeap(), 0, This);
     } else {
         IUnknown_Release(This->resource.parent);  /* Released the reference to the d3dx object */

dlls/wined3d/resource.c

@@ -46,7 +46,7 @@ ULONG WINAPI IWineD3DResourceImpl_Release(IWineD3DResource *iface) {
     TRACE("(%p) : Releasing from %ld\n", This, This->resource.ref);
     ref = InterlockedDecrement(&This->resource.ref);
     if (ref == 0) {
-        IWineD3DDevice_Release(This->resource.wineD3DDevice);
+        IWineD3DDevice_Release((IWineD3DDevice *)This->resource.wineD3DDevice);
         HeapFree(GetProcessHeap(), 0, This);
     }
     return ref;

dlls/wined3d/utils.c

@@ -1519,3 +1519,210 @@ void GetSrcAndOpFromValue(DWORD iValue, BOOL isAlphaArg, GLenum* source, GLenum*
     *source = GL_TEXTURE;
   }
 }
+
+
+#define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
+GLint D3DFmt2GLIntFmt(IWineD3DDeviceImpl* This, D3DFORMAT fmt) {
+    GLint retVal = 0;
+
+    if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) {
+        switch (fmt) {
+        case D3DFMT_DXT1:             retVal = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; break;
+        case D3DFMT_DXT3:             retVal = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; break;
+        case D3DFMT_DXT5:             retVal = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; break;
+        default:
+            /* stupid compiler */
+            break;
+        }
+    }
+
+    if (retVal == 0) {
+        switch (fmt) {
+        /* Paletted */
+        case D3DFMT_P8:               retVal = GL_COLOR_INDEX8_EXT; break;
+        case D3DFMT_A8P8:             retVal = GL_COLOR_INDEX8_EXT; break;
+            /* Luminance */
+        case D3DFMT_L8:               retVal = GL_LUMINANCE8; break;
+        case D3DFMT_A8L8:             retVal = GL_LUMINANCE8_ALPHA8; break;
+        case D3DFMT_A4L4:             retVal = GL_LUMINANCE4_ALPHA4; break;
+            /* Bump */
+        case D3DFMT_V8U8:             retVal = GL_COLOR_INDEX8_EXT; break;
+        case D3DFMT_V16U16:           retVal = GL_COLOR_INDEX; break;
+        case D3DFMT_L6V5U5:           retVal = GL_COLOR_INDEX8_EXT; break;
+        case D3DFMT_X8L8V8U8:         retVal = GL_COLOR_INDEX; break;
+            /* color buffer */ 
+        case D3DFMT_R3G3B2:           retVal = GL_R3_G3_B2; break;
+        case D3DFMT_R5G6B5:           retVal = GL_RGB5; break; /* fixme: internal format 6 for g? */
+        case D3DFMT_R8G8B8:           retVal = GL_RGB8; break;
+        case D3DFMT_A1R5G5B5:         retVal = GL_RGB5_A1; break;
+        case D3DFMT_X1R5G5B5:         retVal = GL_RGB5_A1; break;
+        case D3DFMT_A4R4G4B4:         retVal = GL_RGBA4; break;
+        case D3DFMT_X4R4G4B4:         retVal = GL_RGBA4; break;
+        case D3DFMT_A8R8G8B8:         retVal = GL_RGBA8; break;
+        case D3DFMT_X8R8G8B8:         retVal = GL_RGBA8; break;
+            /* to see */
+        case D3DFMT_A8:               retVal = GL_ALPHA8; break;
+        default:
+            FIXME("Unhandled fmt(%u,%s)\n", fmt, debug_d3dformat(fmt));
+            retVal = GL_RGB8;
+        }
+    }
+    TRACE("fmt2glintFmt for fmt(%u,%s) = %x\n", fmt, debug_d3dformat(fmt), retVal);
+    return retVal;
+}
+
+GLenum D3DFmt2GLFmt(IWineD3DDeviceImpl* This, D3DFORMAT fmt) {
+    GLenum retVal = 0;
+
+    if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) {
+        switch (fmt) {
+        case D3DFMT_DXT1:             retVal = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; break;
+        case D3DFMT_DXT3:             retVal = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; break;
+        case D3DFMT_DXT5:             retVal = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; break;
+        default:
+            /* stupid compiler */
+            break;
+        }
+    }
+
+    if (retVal == 0) {
+        switch (fmt) {
+        /* Paletted */
+        case D3DFMT_P8:               retVal = GL_COLOR_INDEX; break;
+        case D3DFMT_A8P8:             retVal = GL_COLOR_INDEX; break;
+            /* Luminance */
+        case D3DFMT_L8:               retVal = GL_LUMINANCE; break;
+        case D3DFMT_A8L8:             retVal = GL_LUMINANCE_ALPHA; break;
+        case D3DFMT_A4L4:             retVal = GL_LUMINANCE_ALPHA; break;
+            /* Bump */
+        case D3DFMT_V8U8:             retVal = GL_COLOR_INDEX; break;
+        case D3DFMT_V16U16:           retVal = GL_COLOR_INDEX; break;
+        case D3DFMT_L6V5U5:           retVal = GL_COLOR_INDEX; break;
+        case D3DFMT_X8L8V8U8:         retVal = GL_COLOR_INDEX; break;
+            /* color buffer */
+        case D3DFMT_R3G3B2:           retVal = GL_BGR; break;
+        case D3DFMT_R5G6B5:           retVal = GL_RGB; break;
+        case D3DFMT_R8G8B8:           retVal = GL_RGB; break;
+        case D3DFMT_A1R5G5B5:         retVal = GL_BGRA; break;
+        case D3DFMT_X1R5G5B5:         retVal = GL_BGRA; break;
+        case D3DFMT_A4R4G4B4:         retVal = GL_BGRA; break;
+        case D3DFMT_X4R4G4B4:         retVal = GL_BGRA; break;
+        case D3DFMT_A8R8G8B8:         retVal = GL_BGRA; break;
+        case D3DFMT_X8R8G8B8:         retVal = GL_BGRA; break;
+            /* to see */
+        case D3DFMT_A8:               retVal = GL_ALPHA; break;
+        default:
+            FIXME("Unhandled fmt(%u,%s)\n", fmt, debug_d3dformat(fmt));
+            retVal = GL_BGR;
+        }
+    }
+
+    TRACE("fmt2glFmt for fmt(%u,%s) = %x\n", fmt, debug_d3dformat(fmt), retVal);
+    return retVal;
+}
+
+GLenum D3DFmt2GLType(IWineD3DDeviceImpl* This, D3DFORMAT fmt) {
+    GLenum retVal = 0;
+
+    if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) {
+        switch (fmt) {
+        case D3DFMT_DXT1:             retVal = 0; break;
+        case D3DFMT_DXT3:             retVal = 0; break;
+        case D3DFMT_DXT5:             retVal = 0; break;
+        default:
+            /* stupid compiler */
+            break;
+        }
+    }
+
+    if (retVal == 0) {
+        switch (fmt) {
+        /* Paletted */
+        case D3DFMT_P8:               retVal = GL_UNSIGNED_BYTE; break;
+        case D3DFMT_A8P8:             retVal = GL_UNSIGNED_BYTE; break;        
+            /* Luminance */
+        case D3DFMT_L8:               retVal = GL_UNSIGNED_BYTE; break;
+        case D3DFMT_A8L8:             retVal = GL_UNSIGNED_BYTE; break;
+        case D3DFMT_A4L4:             retVal = GL_UNSIGNED_BYTE; break;
+            /* Bump */
+        case D3DFMT_V8U8:             retVal = GL_UNSIGNED_BYTE; break;
+        case D3DFMT_V16U16:           retVal = GL_UNSIGNED_SHORT; break;
+        case D3DFMT_L6V5U5:           retVal = GL_UNSIGNED_SHORT_5_5_5_1; break;
+        case D3DFMT_X8L8V8U8:         retVal = GL_UNSIGNED_BYTE; break;
+            /* Color buffer */
+        case D3DFMT_R3G3B2:           retVal = GL_UNSIGNED_BYTE_2_3_3_REV; break;
+        case D3DFMT_R5G6B5:           retVal = GL_UNSIGNED_SHORT_5_6_5; break;
+        case D3DFMT_R8G8B8:           retVal = GL_UNSIGNED_BYTE; break;
+        case D3DFMT_A1R5G5B5:         retVal = GL_UNSIGNED_SHORT_1_5_5_5_REV; break;
+        case D3DFMT_X1R5G5B5:         retVal = GL_UNSIGNED_SHORT_1_5_5_5_REV; break;
+        case D3DFMT_A4R4G4B4:         retVal = GL_UNSIGNED_SHORT_4_4_4_4_REV; break;
+        case D3DFMT_X4R4G4B4:         retVal = GL_UNSIGNED_SHORT_4_4_4_4_REV; break;
+        case D3DFMT_A8R8G8B8:         retVal = GL_UNSIGNED_INT_8_8_8_8_REV; break;
+        case D3DFMT_X8R8G8B8:         retVal = GL_UNSIGNED_INT_8_8_8_8_REV; break;
+            /* to see */
+        case D3DFMT_A8:               retVal = GL_ALPHA; break;
+        default:
+            FIXME("Unhandled fmt(%u,%s)\n", fmt, debug_d3dformat(fmt));
+            retVal = GL_UNSIGNED_BYTE;
+        }
+    }
+
+    TRACE("fmt2glType for fmt(%u,%s) = %x\n", fmt, debug_d3dformat(fmt), retVal);
+    return retVal;
+}
+
+SHORT D3DFmtGetBpp(IWineD3DDeviceImpl* This, D3DFORMAT fmt) {
+    SHORT retVal;
+
+    switch (fmt) {
+    /* color buffer */
+    case D3DFMT_R3G3B2:           retVal = 1; break;
+    case D3DFMT_R5G6B5:           retVal = 2; break;
+    case D3DFMT_R8G8B8:           retVal = 3; break;
+    case D3DFMT_A1R5G5B5:         retVal = 2; break;
+    case D3DFMT_X1R5G5B5:         retVal = 2; break;
+    case D3DFMT_A4R4G4B4:         retVal = 2; break;
+    case D3DFMT_X4R4G4B4:         retVal = 2; break;
+    case D3DFMT_A8R8G8B8:         retVal = 4; break;
+    case D3DFMT_X8R8G8B8:         retVal = 4; break;
+        /* Paletted */
+    case D3DFMT_P8:               retVal = 1; break;
+    case D3DFMT_A8P8:             retVal = 2; break;
+        /* depth/stencil buffer */
+    case D3DFMT_D16_LOCKABLE:     retVal = 2; break;
+    case D3DFMT_D16:              retVal = 2; break;
+    case D3DFMT_D32:              retVal = 4; break;
+    case D3DFMT_D15S1:            retVal = 2; break;
+    case D3DFMT_D24X4S4:          retVal = 4; break;
+    case D3DFMT_D24S8:            retVal = 4; break;
+    case D3DFMT_D24X8:            retVal = 4; break;
+        /* Luminance */
+    case D3DFMT_L8:               retVal = 1; break;
+    case D3DFMT_A4L4:             retVal = 1; break;
+    case D3DFMT_A8L8:             retVal = 2; break;
+        /* Bump */
+    case D3DFMT_V8U8:             retVal = 2; break;
+    case D3DFMT_L6V5U5:           retVal = 2; break;
+    case D3DFMT_V16U16:           retVal = 4; break;
+    case D3DFMT_X8L8V8U8:         retVal = 4; break;
+        /* Compressed */                                  
+    case D3DFMT_DXT1:             retVal = 1; break; /* Actually  8 bytes per 16 pixels - Special cased later */
+    case D3DFMT_DXT3:             retVal = 1; break; /* Actually 16 bytes per 16 pixels */
+    case D3DFMT_DXT5:             retVal = 1; break; /* Actually 16 bytes per 16 pixels */
+        /* to see */
+    case D3DFMT_A8:               retVal = 1; break;      
+        /* unknown */                                  
+    case D3DFMT_UNKNOWN:
+        /* Guess at the highest value of the above */
+        TRACE("D3DFMT_UNKNOWN - Guessing at 4 bytes/pixel %u\n", fmt);
+        retVal = 4;
+        break;
+
+    default:
+        FIXME("Unhandled fmt(%u,%s)\n", fmt, debug_d3dformat(fmt));
+        retVal = 4;
+    }
+    TRACE("bytes/Pxl for fmt(%u,%s) = %d\n", fmt, debug_d3dformat(fmt), retVal);
+    return retVal;
+}
+#undef GLINFO_LOCATION

dlls/wined3d/vertexbuffer.c

@@ -50,7 +50,7 @@ ULONG WINAPI IWineD3DVertexBufferImpl_Release(IWineD3DVertexBuffer *iface) {
     ref = InterlockedDecrement(&This->resource.ref);
     if (ref == 0) {
         HeapFree(GetProcessHeap(), 0, This->allocatedMemory);
-        IWineD3DDevice_Release(This->resource.wineD3DDevice);
+        IWineD3DDevice_Release((IWineD3DDevice *)This->resource.wineD3DDevice);
         HeapFree(GetProcessHeap(), 0, This);
     } else {
         IUnknown_Release(This->resource.parent);  /* Released the reference to the d3dx object */

dlls/wined3d/wined3d_private.h

@@ -128,6 +128,8 @@ extern int num_lock;
                          /* Maximum number of constants provided to the shaders */
 #define MAX_CLIPPLANES  D3DMAXUSERCLIPPLANES
 
+#define MAX_PALETTES      256
+
 /* Checking of API calls */
 /* --------------------- */
 #define checkGLcall(A) \
@@ -175,6 +177,7 @@ do {
 
 /* Advance declaration of structures to satisfy compiler */
 typedef struct IWineD3DStateBlockImpl IWineD3DStateBlockImpl;
+typedef struct IWineD3DSurfaceImpl    IWineD3DSurfaceImpl;
 
 /* Global variables */
 extern const float identity[16];
@@ -366,6 +369,18 @@ typedef struct IWineD3DDeviceImpl
     UINT                            adapterNo;
     D3DDEVTYPE                      devType;
 
+    /* Render Target Support */
+    IWineD3DSurfaceImpl    *frontBuffer;
+    IWineD3DSurfaceImpl    *backBuffer;
+    IWineD3DSurfaceImpl    *depthStencilBuffer;
+
+    IWineD3DSurfaceImpl    *renderTarget;
+    IWineD3DSurfaceImpl    *stencilBufferTarget;
+
+    /* palettes texture management */
+    PALETTEENTRY                  palettes[MAX_PALETTES][256];
+    UINT                          currentPalette;
+
     /* For rendering to a texture using glCopyTexImage */
     BOOL                          renderUpsideDown;
 
@@ -387,7 +402,7 @@ typedef struct IWineD3DResourceClass
     /* WineD3DResource Information */
     IUnknown               *parent;
     D3DRESOURCETYPE         resourceType;
-    IWineD3DDevice         *wineD3DDevice;
+    IWineD3DDeviceImpl     *wineD3DDevice;
 
 } IWineD3DResourceClass;
 
@@ -440,6 +455,7 @@ extern IWineD3DIndexBufferVtbl IWineD3DIndexBuffer_Vtbl;
 typedef struct IWineD3DBaseTextureClass
 {
     UINT                    levels;
+    BOOL                    dirty;
 
 } IWineD3DBaseTextureClass;
 
@@ -455,6 +471,34 @@ typedef struct IWineD3DBaseTextureImpl
 extern IWineD3DBaseTextureVtbl IWineD3DBaseTexture_Vtbl;
 
 /*****************************************************************************
+ * IWineD3DSurface implementation structure
+ */
+struct IWineD3DSurfaceImpl
+{
+    /* IUnknown & IWineD3DResource Information     */
+    IWineD3DSurfaceVtbl      *lpVtbl;
+    IWineD3DResourceClass     resource;
+
+    /* IWineD3DSurface fields */
+    IUnknown                 *container;
+    D3DSURFACE_DESC           currentDesc;
+    BYTE                     *allocatedMemory;
+
+    UINT                      textureName;
+    UINT                      bytesPerPixel;
+    
+    BOOL                      lockable;
+    BOOL                      locked;
+    RECT                      lockedRect;
+    RECT                      dirtyRect;
+    BOOL                      Dirty;
+    BOOL                      inTexture;
+    BOOL                      inPBuffer;
+};
+
+extern IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl;
+
+/*****************************************************************************
  * IWineD3DStateBlock implementation structure
  */
 
@@ -482,7 +526,7 @@ struct IWineD3DStateBlockImpl
     
     /* IWineD3DStateBlock information */
     IUnknown                 *parent;
-    IWineD3DDevice           *wineD3DDevice;
+    IWineD3DDeviceImpl       *wineD3DDevice;
     D3DSTATEBLOCKTYPE         blockType;
 
     /* Array indicating whether things have been set or changed */
@@ -556,6 +600,12 @@ void   set_tex_op(IWineD3DDevice *iface, BOOL isAlpha, int Stage, D3DTEXTUREOP o
 void   set_texture_matrix(const float *smat, DWORD flags);
 void   GetSrcAndOpFromValue(DWORD iValue, BOOL isAlphaArg, GLenum* source, GLenum* operand);
 
+SHORT  D3DFmtGetBpp(IWineD3DDeviceImpl* This, D3DFORMAT fmt);
+GLenum D3DFmt2GLFmt(IWineD3DDeviceImpl* This, D3DFORMAT fmt);
+GLenum D3DFmt2GLType(IWineD3DDeviceImpl *This, D3DFORMAT fmt);
+GLint  D3DFmt2GLIntFmt(IWineD3DDeviceImpl* This, D3DFORMAT fmt);
+
+
 #if 0 /* Needs fixing during rework */
 /*****************************************************************************
  * IDirect3DVertexShaderDeclaration implementation structure

include/d3d9types.h

@@ -1306,6 +1306,7 @@ typedef struct _D3DSURFACE_DESC {
     D3DPOOL             Pool;
     UINT                Size;
     D3DMULTISAMPLE_TYPE MultiSampleType;
+    DWORD               MultiSampleQuality;
     UINT                Width;
     UINT                Height;
 } D3DSURFACE_DESC;

include/wine/wined3d_interface.h

@@ -69,6 +69,19 @@ typedef struct _WINED3DPRESENT_PARAMETERS {
     UINT                *PresentationInterval;
 } WINED3DPRESENT_PARAMETERS;
 
+typedef struct _WINED3DSURFACE_DESC
+{
+    D3DFORMAT           *Format;
+    D3DRESOURCETYPE     *Type;
+    DWORD               *Usage;
+    D3DPOOL             *Pool;
+                        
+    D3DMULTISAMPLE_TYPE *MultiSampleType;
+    DWORD               *MultiSampleQuality;
+    UINT                *Width;
+    UINT                *Height;
+} WINED3DSURFACE_DESC;
+
 /* The following have differing names, but actually are the same layout */
 #if defined( __WINE_D3D8_H )
  #define WINED3DLIGHT           D3DLIGHT8
@@ -89,6 +102,20 @@ typedef struct IWineD3DVertexBuffer   IWineD3DVertexBuffer;
 typedef struct IWineD3DIndexBuffer    IWineD3DIndexBuffer;
 typedef struct IWineD3DBaseTexture    IWineD3DBaseTexture;
 typedef struct IWineD3DStateBlock     IWineD3DStateBlock;
+typedef struct IWineD3DSurface        IWineD3DSurface;
+
+/*****************************************************************************
+ * Callback functions required for predefining surfaces / stencils
+ */
+typedef HRESULT WINAPI (*D3DCB_CREATERENDERTARGETFN) (IUnknown  *pSurface,
+                                               UINT       Width, 
+                                               UINT       Height, 
+                                               D3DFORMAT  Format, 
+                                               D3DMULTISAMPLE_TYPE MultiSample, 
+                                               DWORD      MultisampleQuality, 
+                                               BOOL       Lockable, 
+                                               IWineD3DSurface **ppSurface, 
+                                               HANDLE   * pSharedHandle);
 
 /*****************************************************************************
  * WineD3D interface 
@@ -116,7 +143,7 @@ DECLARE_INTERFACE_(IWineD3D,IUnknown)
     STDMETHOD(CheckDeviceFormat)(THIS_ UINT  Adapter, D3DDEVTYPE  DeviceType, D3DFORMAT  AdapterFormat, DWORD  Usage, D3DRESOURCETYPE  RType, D3DFORMAT  CheckFormat) PURE;
     STDMETHOD(CheckDeviceFormatConversion)(THIS_ UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SourceFormat, D3DFORMAT TargetFormat) PURE;
     STDMETHOD(GetDeviceCaps)(THIS_ UINT  Adapter, D3DDEVTYPE  DeviceType, void * pCaps) PURE;
-    STDMETHOD(CreateDevice)(THIS_ UINT  Adapter, D3DDEVTYPE  DeviceType,HWND  hFocusWindow, DWORD  BehaviorFlags, WINED3DPRESENT_PARAMETERS * pPresentationParameters, IWineD3DDevice ** ppReturnedDeviceInterface, IUnknown *parent) PURE;
+    STDMETHOD(CreateDevice)(THIS_ UINT  Adapter, D3DDEVTYPE  DeviceType,HWND  hFocusWindow, DWORD  BehaviorFlags, WINED3DPRESENT_PARAMETERS * pPresentationParameters, IWineD3DDevice ** ppReturnedDeviceInterface, IUnknown *parent, D3DCB_CREATERENDERTARGETFN pFn) PURE;
 };
 #undef INTERFACE
 
@@ -140,7 +167,7 @@ DECLARE_INTERFACE_(IWineD3D,IUnknown)
 #define IWineD3D_CheckDeviceFormat(p,a,b,c,d,e,f)         (p)->lpVtbl->CheckDeviceFormat(p,a,b,c,d,e,f)
 #define IWineD3D_CheckDeviceFormatConversion(p,a,b,c,d)   (p)->lpVtbl->CheckDeviceFormatConversion(p,a,b,c,d)
 #define IWineD3D_GetDeviceCaps(p,a,b,c)                   (p)->lpVtbl->GetDeviceCaps(p,a,b,c)
-#define IWineD3D_CreateDevice(p,a,b,c,d,e,f,g)            (p)->lpVtbl->CreateDevice(p,a,b,c,d,e,f,g)
+#define IWineD3D_CreateDevice(p,a,b,c,d,e,f,g,h)          (p)->lpVtbl->CreateDevice(p,a,b,c,d,e,f,g,h)
 #endif
 
 /* Define the main WineD3D entrypoint */
@@ -161,6 +188,7 @@ DECLARE_INTERFACE_(IWineD3DDevice,IUnknown)
     STDMETHOD(CreateVertexBuffer)(THIS_ UINT  Length,DWORD  Usage,DWORD  FVF,D3DPOOL  Pool,IWineD3DVertexBuffer **ppVertexBuffer, HANDLE *sharedHandle, IUnknown *parent) PURE;
     STDMETHOD(CreateIndexBuffer)(THIS_ UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IWineD3DIndexBuffer** ppIndexBuffer, HANDLE* pSharedHandle, IUnknown *parent) PURE;
     STDMETHOD(CreateStateBlock)(THIS_ D3DSTATEBLOCKTYPE Type, IWineD3DStateBlock **ppStateBlock, IUnknown *parent) PURE;
+    STDMETHOD(CreateRenderTarget)(THIS_ UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality, BOOL Lockable, IWineD3DSurface** ppSurface, HANDLE* pSharedHandle, IUnknown *parent) PURE;
     STDMETHOD(SetFVF)(THIS_ DWORD  fvf) PURE;
     STDMETHOD(GetFVF)(THIS_ DWORD * pfvf) PURE;
     STDMETHOD(SetStreamSource)(THIS_ UINT  StreamNumber,IWineD3DVertexBuffer * pStreamData,UINT Offset,UINT  Stride) PURE;
@@ -211,6 +239,7 @@ DECLARE_INTERFACE_(IWineD3DDevice,IUnknown)
 #define IWineD3DDevice_CreateVertexBuffer(p,a,b,c,d,e,f,g)      (p)->lpVtbl->CreateVertexBuffer(p,a,b,c,d,e,f,g)
 #define IWineD3DDevice_CreateIndexBuffer(p,a,b,c,d,e,f,g)       (p)->lpVtbl->CreateIndexBuffer(p,a,b,c,d,e,f,g)
 #define IWineD3DDevice_CreateStateBlock(p,a,b,c)                (p)->lpVtbl->CreateStateBlock(p,a,b,c)
+#define IWineD3DDevice_CreateRenderTarget(p,a,b,c,d,e,f,g,h,i)  (p)->lpVtbl->CreateRenderTarget(p,a,b,c,d,e,f,g,h,i)
 #define IWineD3DDevice_SetFVF(p,a)                              (p)->lpVtbl->SetFVF(p,a)
 #define IWineD3DDevice_GetFVF(p,a)                              (p)->lpVtbl->GetFVF(p,a)
 #define IWineD3DDevice_SetStreamSource(p,a,b,c,d)               (p)->lpVtbl->SetStreamSource(p,a,b,c,d)
@@ -412,6 +441,8 @@ DECLARE_INTERFACE_(IWineD3DBaseTexture,IWineD3DResource)
     STDMETHOD(SetAutoGenFilterType)(THIS_ D3DTEXTUREFILTERTYPE FilterType) PURE;
     STDMETHOD_(D3DTEXTUREFILTERTYPE, GetAutoGenFilterType)(THIS) PURE;
     STDMETHOD_(void, GenerateMipSubLevels)(THIS) PURE;
+    STDMETHOD_(BOOL, SetDirty)(THIS_ BOOL) PURE;
+
 };
 #undef INTERFACE
 
@@ -437,6 +468,72 @@ DECLARE_INTERFACE_(IWineD3DBaseTexture,IWineD3DResource)
 #define IWineD3DBaseTexture_SetAutoGenFilterType(p,a)  (p)->lpVtbl->SetAutoGenFilterType(p,a)
 #define IWineD3DBaseTexture_GetAutoGenFilterType(p)    (p)->lpVtbl->GetAutoGenFilterType(p)
 #define IWineD3DBaseTexture_GenerateMipSubLevels(p)    (p)->lpVtbl->GenerateMipSubLevels(p)
+#define IWineD3DBaseTexture_SetDirty(p,a)              (p)->lpVtbl->SetDirty(p,a)
+#endif
+
+/*****************************************************************************
+ * IWineD3DSurface interface
+ */
+#define INTERFACE IWineD3DSurface
+DECLARE_INTERFACE_(IWineD3DSurface,IWineD3DResource)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+    /*** IWineD3DResource methods ***/
+    STDMETHOD(GetParent)(THIS_ IUnknown **pParent) PURE;
+    STDMETHOD(GetDevice)(THIS_ IWineD3DDevice ** ppDevice) PURE;
+    STDMETHOD(SetPrivateData)(THIS_ REFGUID  refguid, CONST void * pData, DWORD  SizeOfData, DWORD  Flags) PURE;
+    STDMETHOD(GetPrivateData)(THIS_ REFGUID  refguid, void * pData, DWORD * pSizeOfData) PURE;
+    STDMETHOD(FreePrivateData)(THIS_ REFGUID  refguid) PURE;
+    STDMETHOD_(DWORD,SetPriority)(THIS_ DWORD  PriorityNew) PURE;
+    STDMETHOD_(DWORD,GetPriority)(THIS) PURE;
+    STDMETHOD_(void,PreLoad)(THIS) PURE;
+    STDMETHOD_(D3DRESOURCETYPE,GetType)(THIS) PURE;
+    /*** IWineD3DSurface methods ***/
+    STDMETHOD(GetContainer)(THIS_ REFIID  riid, void ** ppContainer) PURE;
+    STDMETHOD(GetDesc)(THIS_ WINED3DSURFACE_DESC * pDesc) PURE;
+    STDMETHOD(LockRect)(THIS_ D3DLOCKED_RECT * pLockedRect, CONST RECT * pRect,DWORD  Flags) PURE;
+    STDMETHOD(UnlockRect)(THIS) PURE;
+    STDMETHOD(GetDC)(THIS_ HDC *pHdc) PURE;
+    STDMETHOD(ReleaseDC)(THIS_ HDC hdc) PURE;
+    /* Internally used methods */
+    STDMETHOD(CleanDirtyRect)(THIS) PURE;
+    STDMETHOD(AddDirtyRect)(THIS_ CONST RECT* pRect) PURE;
+    STDMETHOD(LoadTexture)(THIS_ UINT gl_target, UINT gl_level) PURE;
+    STDMETHOD(SaveSnapshot)(THIS_ const char *filename) PURE;
+};
+#undef INTERFACE
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+/*** IUnknown methods ***/
+#define IWineD3DSurface_QueryInterface(p,a,b)        (p)->lpVtbl->QueryInterface(p,a,b)
+#define IWineD3DSurface_AddRef(p)                    (p)->lpVtbl->AddRef(p)
+#define IWineD3DSurface_Release(p)                   (p)->lpVtbl->Release(p)
+/*** IWineD3DResource methods ***/
+/*** IWineD3DResource methods ***/
+#define IWineD3DSurface_GetParent(p,a)               (p)->lpVtbl->GetParent(p,a)
+#define IWineD3DSurface_GetDevice(p,a)               (p)->lpVtbl->GetDevice(p,a)
+#define IWineD3DSurface_SetPrivateData(p,a,b,c,d)    (p)->lpVtbl->SetPrivateData(p,a,b,c,d)
+#define IWineD3DSurface_GetPrivateData(p,a,b,c)      (p)->lpVtbl->GetPrivateData(p,a,b,c)
+#define IWineD3DSurface_FreePrivateData(p,a)         (p)->lpVtbl->FreePrivateData(p,a)
+#define IWineD3DSurface_SetPriority(p,a)             (p)->lpVtbl->SetPriority(p,a)
+#define IWineD3DSurface_GetPriority(p)               (p)->lpVtbl->GetPriority(p)
+#define IWineD3DSurface_PreLoad(p)                   (p)->lpVtbl->PreLoad(p)
+#define IWineD3DSurface_GetType(p)                   (p)->lpVtbl->GetType(p)
+/*** IWineD3DSurface methods ***/
+#define IWineD3DSurface_GetContainer(p,a,b)          (p)->lpVtbl->GetContainer(p,a,b)
+#define IWineD3DSurface_GetDesc(p,a)                 (p)->lpVtbl->GetDesc(p,a)
+#define IWineD3DSurface_LockRect(p,a,b,c)            (p)->lpVtbl->LockRect(p,a,b,c)
+#define IWineD3DSurface_UnlockRect(p)                (p)->lpVtbl->UnlockRect(p)
+#define IWineD3DSurface_GetDC(p,a)                   (p)->lpVtbl->GetDC(p,a)
+#define IWineD3DSurface_ReleaseDC(p,a)               (p)->lpVtbl->ReleaseDC(p,a)
+/*** IWineD3DSurface (Internal, no d3d mapping) methods ***/
+#define IWineD3DSurface_CleanDirtyRect(p)            (p)->lpVtbl->CleanDirtyRect(p)
+#define IWineD3DSurface_AddDirtyRect(p,a)            (p)->lpVtbl->AddDirtyRect(p,a)
+#define IWineD3DSurface_LoadTexture(p,a,b)           (p)->lpVtbl->LoadTexture(p,a,b)
+#define IWineD3DSurface_SaveSnapshot(p,a)            (p)->lpVtbl->SaveSnapshot(p,a)
 #endif
 
 /*****************************************************************************