git.oblomov.eu Git - wine/blob - dlls/d3d8/surface.c

   1 /*
   2  * IDirect3DSurface8 implementation
   3  *
   4  * Copyright 2005 Oliver Stieber
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "d3d8_private.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(d3d8);
  25
  26 static inline IDirect3DSurface8Impl *impl_from_IDirect3DSurface8(IDirect3DSurface8 *iface)
  27 {
  28     return CONTAINING_RECORD(iface, IDirect3DSurface8Impl, lpVtbl);
  29 }
  30
  31 /* IDirect3DSurface8 IUnknown parts follow: */
  32 static HRESULT WINAPI IDirect3DSurface8Impl_QueryInterface(LPDIRECT3DSURFACE8 iface, REFIID riid, LPVOID *ppobj) {
  33     IDirect3DSurface8Impl *This = (IDirect3DSurface8Impl *)iface;
  34
  35     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), ppobj);
  36
  37     if (IsEqualGUID(riid, &IID_IUnknown)
  38         || IsEqualGUID(riid, &IID_IDirect3DResource8)
  39         || IsEqualGUID(riid, &IID_IDirect3DSurface8)) {
  40         IUnknown_AddRef(iface);
  41         *ppobj = This;
  42         return S_OK;
  43     }
  44
  45     WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
  46     *ppobj = NULL;
  47     return E_NOINTERFACE;
  48 }
  49
  50 static ULONG WINAPI IDirect3DSurface8Impl_AddRef(LPDIRECT3DSURFACE8 iface) {
  51     IDirect3DSurface8Impl *This = (IDirect3DSurface8Impl *)iface;
  52
  53     TRACE("iface %p.\n", iface);
  54
  55     if (This->forwardReference) {
  56         /* Forward refcounting */
  57         TRACE("(%p) : Forwarding to %p\n", This, This->forwardReference);
  58         return IUnknown_AddRef(This->forwardReference);
  59     } else {
  60         /* No container, handle our own refcounting */
  61         ULONG ref = InterlockedIncrement(&This->ref);
  62
  63         TRACE("%p increasing refcount to %u.\n", iface, ref);
  64
  65         if (ref == 1)
  66         {
  67             if (This->parentDevice) IUnknown_AddRef(This->parentDevice);
  68             wined3d_mutex_lock();
  69             wined3d_surface_incref(This->wined3d_surface);
  70             wined3d_mutex_unlock();
  71         }
  72
  73         return ref;
  74     }
  75 }
  76
  77 static ULONG WINAPI IDirect3DSurface8Impl_Release(LPDIRECT3DSURFACE8 iface) {
  78     IDirect3DSurface8Impl *This = (IDirect3DSurface8Impl *)iface;
  79
  80     TRACE("iface %p.\n", iface);
  81
  82     if (This->forwardReference) {
  83         /* Forward refcounting */
  84         TRACE("(%p) : Forwarding to %p\n", This, This->forwardReference);
  85         return IUnknown_Release(This->forwardReference);
  86     } else {
  87         /* No container, handle our own refcounting */
  88         ULONG ref = InterlockedDecrement(&This->ref);
  89
  90         TRACE("%p decreasing refcount to %u.\n", iface, ref);
  91
  92         if (ref == 0) {
  93             IDirect3DDevice8 *parentDevice = This->parentDevice;
  94
  95             /* Implicit surfaces are destroyed with the device, not if refcount reaches 0. */
  96             wined3d_mutex_lock();
  97             wined3d_surface_decref(This->wined3d_surface);
  98             wined3d_mutex_unlock();
  99
 100             if (parentDevice) IDirect3DDevice8_Release(parentDevice);
 101         }
 102
 103         return ref;
 104     }
 105 }
 106
 107 /* IDirect3DSurface8 IDirect3DResource8 Interface follow: */
 108 static HRESULT WINAPI IDirect3DSurface8Impl_GetDevice(IDirect3DSurface8 *iface, IDirect3DDevice8 **device)
 109 {
 110     IDirect3DSurface8Impl *This = (IDirect3DSurface8Impl *)iface;
 111
 112     TRACE("iface %p, device %p.\n", iface, device);
 113
 114     if (This->forwardReference)
 115     {
 116         IDirect3DResource8 *resource;
 117         HRESULT hr;
 118
 119         hr = IUnknown_QueryInterface(This->forwardReference, &IID_IDirect3DResource8, (void **)&resource);
 120         if (SUCCEEDED(hr))
 121         {
 122             hr = IDirect3DResource8_GetDevice(resource, device);
 123             IDirect3DResource8_Release(resource);
 124
 125             TRACE("Returning device %p.\n", *device);
 126         }
 127
 128         return hr;
 129     }
 130
 131     *device = (IDirect3DDevice8 *)This->parentDevice;
 132     IDirect3DDevice8_AddRef(*device);
 133
 134     TRACE("Returning device %p.\n", *device);
 135
 136     return D3D_OK;
 137 }
 138
 139 static HRESULT WINAPI IDirect3DSurface8Impl_SetPrivateData(IDirect3DSurface8 *iface, REFGUID guid,
 140         const void *data, DWORD data_size, DWORD flags)
 141 {
 142     IDirect3DSurface8Impl *surface = impl_from_IDirect3DSurface8(iface);
 143     struct wined3d_resource *resource;
 144     HRESULT hr;
 145
 146     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
 147             iface, debugstr_guid(guid), data, data_size, flags);
 148
 149     wined3d_mutex_lock();
 150     resource = wined3d_surface_get_resource(surface->wined3d_surface);
 151     hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags);
 152     wined3d_mutex_unlock();
 153
 154     return hr;
 155 }
 156
 157 static HRESULT WINAPI IDirect3DSurface8Impl_GetPrivateData(IDirect3DSurface8 *iface, REFGUID guid,
 158         void *data, DWORD *data_size)
 159 {
 160     IDirect3DSurface8Impl *surface = impl_from_IDirect3DSurface8(iface);
 161     struct wined3d_resource *resource;
 162     HRESULT hr;
 163
 164     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
 165             iface, debugstr_guid(guid), data, data_size);
 166
 167     wined3d_mutex_lock();
 168     resource = wined3d_surface_get_resource(surface->wined3d_surface);
 169     hr = wined3d_resource_get_private_data(resource, guid, data, data_size);
 170     wined3d_mutex_unlock();
 171
 172     return hr;
 173 }
 174
 175 static HRESULT WINAPI IDirect3DSurface8Impl_FreePrivateData(IDirect3DSurface8 *iface, REFGUID guid)
 176 {
 177     IDirect3DSurface8Impl *surface = impl_from_IDirect3DSurface8(iface);
 178     struct wined3d_resource *resource;
 179     HRESULT hr;
 180
 181     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
 182
 183     wined3d_mutex_lock();
 184     resource = wined3d_surface_get_resource(surface->wined3d_surface);
 185     hr = wined3d_resource_free_private_data(resource, guid);
 186     wined3d_mutex_unlock();
 187
 188     return hr;
 189 }
 190
 191 /* IDirect3DSurface8 Interface follow: */
 192 static HRESULT WINAPI IDirect3DSurface8Impl_GetContainer(LPDIRECT3DSURFACE8 iface, REFIID riid, void **ppContainer) {
 193     IDirect3DSurface8Impl *This = (IDirect3DSurface8Impl *)iface;
 194     HRESULT res;
 195
 196     TRACE("iface %p, riid %s, container %p.\n", iface, debugstr_guid(riid), ppContainer);
 197
 198     if (!This->container) return E_NOINTERFACE;
 199
 200     res = IUnknown_QueryInterface(This->container, riid, ppContainer);
 201
 202     TRACE("(%p) : returning %p\n", This, *ppContainer);
 203     return res;
 204 }
 205
 206 static HRESULT WINAPI IDirect3DSurface8Impl_GetDesc(IDirect3DSurface8 *iface, D3DSURFACE_DESC *desc)
 207 {
 208     IDirect3DSurface8Impl *This = (IDirect3DSurface8Impl *)iface;
 209     struct wined3d_resource_desc wined3d_desc;
 210     struct wined3d_resource *wined3d_resource;
 211
 212     TRACE("iface %p, desc %p.\n", iface, desc);
 213
 214     wined3d_mutex_lock();
 215     wined3d_resource = wined3d_surface_get_resource(This->wined3d_surface);
 216     wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);
 217     wined3d_mutex_unlock();
 218
 219     desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
 220     desc->Type = wined3d_desc.resource_type;
 221     desc->Usage = wined3d_desc.usage;
 222     desc->Pool = wined3d_desc.pool;
 223     desc->Size = wined3d_desc.size;
 224     desc->MultiSampleType = wined3d_desc.multisample_type;
 225     desc->Width = wined3d_desc.width;
 226     desc->Height = wined3d_desc.height;
 227
 228     return D3D_OK;
 229 }
 230
 231 static HRESULT WINAPI IDirect3DSurface8Impl_LockRect(LPDIRECT3DSURFACE8 iface, D3DLOCKED_RECT *pLockedRect, CONST RECT *pRect, DWORD Flags) {
 232     IDirect3DSurface8Impl *This = (IDirect3DSurface8Impl *)iface;
 233     HRESULT hr;
 234
 235     TRACE("iface %p, locked_rect %p, rect %p, flags %#x.\n", iface, pLockedRect, pRect, Flags);
 236
 237     wined3d_mutex_lock();
 238     if (pRect) {
 239         D3DSURFACE_DESC desc;
 240         IDirect3DSurface8_GetDesc(iface, &desc);
 241
 242         if ((pRect->left < 0)
 243                 || (pRect->top < 0)
 244                 || (pRect->left >= pRect->right)
 245                 || (pRect->top >= pRect->bottom)
 246                 || (pRect->right > desc.Width)
 247                 || (pRect->bottom > desc.Height)) {
 248             WARN("Trying to lock an invalid rectangle, returning D3DERR_INVALIDCALL\n");
 249             wined3d_mutex_unlock();
 250
 251             return D3DERR_INVALIDCALL;
 252         }
 253     }
 254
 255     hr = wined3d_surface_map(This->wined3d_surface, (WINED3DLOCKED_RECT *)pLockedRect, pRect, Flags);
 256     wined3d_mutex_unlock();
 257
 258     return hr;
 259 }
 260
 261 static HRESULT WINAPI IDirect3DSurface8Impl_UnlockRect(LPDIRECT3DSURFACE8 iface) {
 262     IDirect3DSurface8Impl *This = (IDirect3DSurface8Impl *)iface;
 263     HRESULT hr;
 264
 265     TRACE("iface %p.\n", iface);
 266
 267     wined3d_mutex_lock();
 268     hr = wined3d_surface_unmap(This->wined3d_surface);
 269     wined3d_mutex_unlock();
 270
 271     switch(hr)
 272     {
 273         case WINEDDERR_NOTLOCKED:       return D3DERR_INVALIDCALL;
 274         default:                        return hr;
 275     }
 276 }
 277
 278 static const IDirect3DSurface8Vtbl Direct3DSurface8_Vtbl =
 279 {
 280     /* IUnknown */
 281     IDirect3DSurface8Impl_QueryInterface,
 282     IDirect3DSurface8Impl_AddRef,
 283     IDirect3DSurface8Impl_Release,
 284     /* IDirect3DResource8 */
 285     IDirect3DSurface8Impl_GetDevice,
 286     IDirect3DSurface8Impl_SetPrivateData,
 287     IDirect3DSurface8Impl_GetPrivateData,
 288     IDirect3DSurface8Impl_FreePrivateData,
 289     /* IDirect3DSurface8 */
 290     IDirect3DSurface8Impl_GetContainer,
 291     IDirect3DSurface8Impl_GetDesc,
 292     IDirect3DSurface8Impl_LockRect,
 293     IDirect3DSurface8Impl_UnlockRect
 294 };
 295
 296 static void STDMETHODCALLTYPE surface_wined3d_object_destroyed(void *parent)
 297 {
 298     HeapFree(GetProcessHeap(), 0, parent);
 299 }
 300
 301 static const struct wined3d_parent_ops d3d8_surface_wined3d_parent_ops =
 302 {
 303     surface_wined3d_object_destroyed,
 304 };
 305
 306 HRESULT surface_init(IDirect3DSurface8Impl *surface, IDirect3DDevice8Impl *device,
 307         UINT width, UINT height, D3DFORMAT format, BOOL lockable, BOOL discard, UINT level,
 308         DWORD usage, D3DPOOL pool, D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality)
 309 {
 310     HRESULT hr;
 311
 312     surface->lpVtbl = &Direct3DSurface8_Vtbl;
 313     surface->ref = 1;
 314
 315     /* FIXME: Check MAX bounds of MultisampleQuality. */
 316     if (multisample_quality > 0)
 317     {
 318         FIXME("Multisample quality set to %u, substituting 0.\n", multisample_quality);
 319         multisample_quality = 0;
 320     }
 321
 322     wined3d_mutex_lock();
 323     hr = wined3d_surface_create(device->wined3d_device, width, height, wined3dformat_from_d3dformat(format),
 324             lockable, discard, level, usage & WINED3DUSAGE_MASK, (WINED3DPOOL)pool, multisample_type,
 325             multisample_quality, SURFACE_OPENGL, surface, &d3d8_surface_wined3d_parent_ops, &surface->wined3d_surface);
 326     wined3d_mutex_unlock();
 327     if (FAILED(hr))
 328     {
 329         WARN("Failed to create wined3d surface, hr %#x.\n", hr);
 330         return hr;
 331     }
 332
 333     surface->parentDevice = &device->IDirect3DDevice8_iface;
 334     IUnknown_AddRef(surface->parentDevice);
 335
 336     return D3D_OK;
 337 }