From 95469309d6f82fe91e78c94e59984fcd75cefc2b Mon Sep 17 00:00:00 2001 From: Henri Verbeet Date: Thu, 14 Oct 2010 13:04:02 +0200 Subject: [PATCH] wined3d: Consistently use Map/Unmap for mapping resources. --- dlls/d3d8/cubetexture.c | 5 ++- dlls/d3d8/surface.c | 4 +- dlls/d3d8/texture.c | 4 +- dlls/d3d8/volume.c | 5 ++- dlls/d3d8/volumetexture.c | 5 ++- dlls/d3d9/cubetexture.c | 5 ++- dlls/d3d9/surface.c | 4 +- dlls/d3d9/texture.c | 4 +- dlls/d3d9/volume.c | 4 +- dlls/d3d9/volumetexture.c | 6 +-- dlls/ddraw/surface.c | 21 +++++----- dlls/wined3d/cubetexture.c | 12 +++--- dlls/wined3d/device.c | 33 ++++++++-------- dlls/wined3d/surface.c | 70 +++++++++++++++++----------------- dlls/wined3d/surface_base.c | 51 +++++++++++++------------ dlls/wined3d/surface_gdi.c | 64 +++++++++---------------------- dlls/wined3d/texture.c | 12 +++--- dlls/wined3d/volume.c | 11 ++++-- dlls/wined3d/volumetexture.c | 12 +++--- dlls/wined3d/wined3d_private.h | 2 +- include/wine/wined3d.idl | 20 +++++----- 21 files changed, 166 insertions(+), 188 deletions(-) diff --git a/dlls/d3d8/cubetexture.c b/dlls/d3d8/cubetexture.c index b9b411a1156..b8de291c68d 100644 --- a/dlls/d3d8/cubetexture.c +++ b/dlls/d3d8/cubetexture.c @@ -284,7 +284,8 @@ static HRESULT WINAPI IDirect3DCubeTexture8Impl_LockRect(LPDIRECT3DCUBETEXTURE8 iface, FaceType, Level, pLockedRect, pRect, Flags); wined3d_mutex_lock(); - hr = IWineD3DCubeTexture_LockRect(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES) FaceType, Level, (WINED3DLOCKED_RECT *) pLockedRect, pRect, Flags); + hr = IWineD3DCubeTexture_Map(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES)FaceType, + Level, (WINED3DLOCKED_RECT *)pLockedRect, pRect, Flags); wined3d_mutex_unlock(); return hr; @@ -297,7 +298,7 @@ static HRESULT WINAPI IDirect3DCubeTexture8Impl_UnlockRect(LPDIRECT3DCUBETEXTURE TRACE("iface %p, face %#x, level %u.\n", iface, FaceType, Level); wined3d_mutex_lock(); - hr = IWineD3DCubeTexture_UnlockRect(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES) FaceType, Level); + hr = IWineD3DCubeTexture_Unmap(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES)FaceType, Level); wined3d_mutex_unlock(); return hr; diff --git a/dlls/d3d8/surface.c b/dlls/d3d8/surface.c index 6e59bd65f75..d6bfd63c7ea 100644 --- a/dlls/d3d8/surface.c +++ b/dlls/d3d8/surface.c @@ -233,7 +233,7 @@ static HRESULT WINAPI IDirect3DSurface8Impl_LockRect(LPDIRECT3DSURFACE8 iface, D } } - hr = IWineD3DSurface_LockRect(This->wineD3DSurface, (WINED3DLOCKED_RECT *) pLockedRect, pRect, Flags); + hr = IWineD3DSurface_Map(This->wineD3DSurface, (WINED3DLOCKED_RECT *)pLockedRect, pRect, Flags); wined3d_mutex_unlock(); return hr; @@ -246,7 +246,7 @@ static HRESULT WINAPI IDirect3DSurface8Impl_UnlockRect(LPDIRECT3DSURFACE8 iface) TRACE("iface %p.\n", iface); wined3d_mutex_lock(); - hr = IWineD3DSurface_UnlockRect(This->wineD3DSurface); + hr = IWineD3DSurface_Unmap(This->wineD3DSurface); wined3d_mutex_unlock(); switch(hr) diff --git a/dlls/d3d8/texture.c b/dlls/d3d8/texture.c index a8421604862..b4f3258373c 100644 --- a/dlls/d3d8/texture.c +++ b/dlls/d3d8/texture.c @@ -281,7 +281,7 @@ static HRESULT WINAPI IDirect3DTexture8Impl_LockRect(LPDIRECT3DTEXTURE8 iface, U iface, Level, pLockedRect, pRect, Flags); wined3d_mutex_lock(); - hr = IWineD3DTexture_LockRect(This->wineD3DTexture, Level, (WINED3DLOCKED_RECT *) pLockedRect, pRect, Flags); + hr = IWineD3DTexture_Map(This->wineD3DTexture, Level, (WINED3DLOCKED_RECT *)pLockedRect, pRect, Flags); wined3d_mutex_unlock(); return hr; @@ -294,7 +294,7 @@ static HRESULT WINAPI IDirect3DTexture8Impl_UnlockRect(LPDIRECT3DTEXTURE8 iface, TRACE("iface %p, level %u.\n", iface, Level); wined3d_mutex_lock(); - hr = IWineD3DTexture_UnlockRect(This->wineD3DTexture, Level); + hr = IWineD3DTexture_Unmap(This->wineD3DTexture, Level); wined3d_mutex_unlock(); return hr; diff --git a/dlls/d3d8/volume.c b/dlls/d3d8/volume.c index 1705822cf5d..545ba246930 100644 --- a/dlls/d3d8/volume.c +++ b/dlls/d3d8/volume.c @@ -205,7 +205,8 @@ static HRESULT WINAPI IDirect3DVolume8Impl_LockBox(LPDIRECT3DVOLUME8 iface, D3DL iface, pLockedVolume, pBox, Flags); wined3d_mutex_lock(); - hr = IWineD3DVolume_LockBox(This->wineD3DVolume, (WINED3DLOCKED_BOX *) pLockedVolume, (CONST WINED3DBOX *) pBox, Flags); + hr = IWineD3DVolume_Map(This->wineD3DVolume, (WINED3DLOCKED_BOX *)pLockedVolume, + (const WINED3DBOX *)pBox, Flags); wined3d_mutex_unlock(); return hr; @@ -218,7 +219,7 @@ static HRESULT WINAPI IDirect3DVolume8Impl_UnlockBox(LPDIRECT3DVOLUME8 iface) { TRACE("iface %p.\n", iface); wined3d_mutex_lock(); - hr = IWineD3DVolume_UnlockBox(This->wineD3DVolume); + hr = IWineD3DVolume_Unmap(This->wineD3DVolume); wined3d_mutex_unlock(); return hr; diff --git a/dlls/d3d8/volumetexture.c b/dlls/d3d8/volumetexture.c index bd72d68e916..9b78d6ed159 100644 --- a/dlls/d3d8/volumetexture.c +++ b/dlls/d3d8/volumetexture.c @@ -281,7 +281,8 @@ static HRESULT WINAPI IDirect3DVolumeTexture8Impl_LockBox(LPDIRECT3DVOLUMETEXTUR iface, Level, pLockedVolume, pBox, Flags); wined3d_mutex_lock(); - hr = IWineD3DVolumeTexture_LockBox(This->wineD3DVolumeTexture, Level, (WINED3DLOCKED_BOX *) pLockedVolume, (CONST WINED3DBOX *) pBox, Flags); + hr = IWineD3DVolumeTexture_Map(This->wineD3DVolumeTexture, Level, + (WINED3DLOCKED_BOX *)pLockedVolume, (const WINED3DBOX *)pBox, Flags); wined3d_mutex_unlock(); return hr; @@ -294,7 +295,7 @@ static HRESULT WINAPI IDirect3DVolumeTexture8Impl_UnlockBox(LPDIRECT3DVOLUMETEXT TRACE("iface %p, level %u.\n", iface, Level); wined3d_mutex_lock(); - hr = IWineD3DVolumeTexture_UnlockBox(This->wineD3DVolumeTexture, Level); + hr = IWineD3DVolumeTexture_Unmap(This->wineD3DVolumeTexture, Level); wined3d_mutex_unlock(); return hr; diff --git a/dlls/d3d9/cubetexture.c b/dlls/d3d9/cubetexture.c index 508784f8958..9564aa01535 100644 --- a/dlls/d3d9/cubetexture.c +++ b/dlls/d3d9/cubetexture.c @@ -323,7 +323,8 @@ static HRESULT WINAPI IDirect3DCubeTexture9Impl_LockRect(LPDIRECT3DCUBETEXTURE9 iface, FaceType, Level, pLockedRect, pRect, Flags); wined3d_mutex_lock(); - hr = IWineD3DCubeTexture_LockRect(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES) FaceType, Level, (WINED3DLOCKED_RECT *) pLockedRect, pRect, Flags); + hr = IWineD3DCubeTexture_Map(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES)FaceType, + Level, (WINED3DLOCKED_RECT *)pLockedRect, pRect, Flags); wined3d_mutex_unlock(); return hr; @@ -336,7 +337,7 @@ static HRESULT WINAPI IDirect3DCubeTexture9Impl_UnlockRect(LPDIRECT3DCUBETEXTURE TRACE("iface %p, face %#x, level %u.\n", iface, FaceType, Level); wined3d_mutex_lock(); - hr = IWineD3DCubeTexture_UnlockRect(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES) FaceType, Level); + hr = IWineD3DCubeTexture_Unmap(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES)FaceType, Level); wined3d_mutex_unlock(); return hr; diff --git a/dlls/d3d9/surface.c b/dlls/d3d9/surface.c index de3fb779e0d..76c5e983af0 100644 --- a/dlls/d3d9/surface.c +++ b/dlls/d3d9/surface.c @@ -272,7 +272,7 @@ static HRESULT WINAPI IDirect3DSurface9Impl_LockRect(LPDIRECT3DSURFACE9 iface, D TRACE("iface %p, locked_rect %p, rect %p, flags %#x.\n", iface, pLockedRect, pRect, Flags); wined3d_mutex_lock(); - hr = IWineD3DSurface_LockRect(This->wineD3DSurface, (WINED3DLOCKED_RECT *) pLockedRect, pRect, Flags); + hr = IWineD3DSurface_Map(This->wineD3DSurface, (WINED3DLOCKED_RECT *)pLockedRect, pRect, Flags); wined3d_mutex_unlock(); return hr; @@ -285,7 +285,7 @@ static HRESULT WINAPI IDirect3DSurface9Impl_UnlockRect(LPDIRECT3DSURFACE9 iface) TRACE("iface %p.\n", iface); wined3d_mutex_lock(); - hr = IWineD3DSurface_UnlockRect(This->wineD3DSurface); + hr = IWineD3DSurface_Unmap(This->wineD3DSurface); wined3d_mutex_unlock(); switch(hr) diff --git a/dlls/d3d9/texture.c b/dlls/d3d9/texture.c index dbe9798ab64..74ac2f8d178 100644 --- a/dlls/d3d9/texture.c +++ b/dlls/d3d9/texture.c @@ -319,7 +319,7 @@ static HRESULT WINAPI IDirect3DTexture9Impl_LockRect(LPDIRECT3DTEXTURE9 iface, U iface, Level, pLockedRect, pRect, Flags); wined3d_mutex_lock(); - hr = IWineD3DTexture_LockRect(This->wineD3DTexture, Level, (WINED3DLOCKED_RECT *) pLockedRect, pRect, Flags); + hr = IWineD3DTexture_Map(This->wineD3DTexture, Level, (WINED3DLOCKED_RECT *)pLockedRect, pRect, Flags); wined3d_mutex_unlock(); return hr; @@ -332,7 +332,7 @@ static HRESULT WINAPI IDirect3DTexture9Impl_UnlockRect(LPDIRECT3DTEXTURE9 iface, TRACE("iface %p, level %u.\n", iface, Level); wined3d_mutex_lock(); - hr = IWineD3DTexture_UnlockRect(This->wineD3DTexture, Level); + hr = IWineD3DTexture_Unmap(This->wineD3DTexture, Level); wined3d_mutex_unlock(); return hr; diff --git a/dlls/d3d9/volume.c b/dlls/d3d9/volume.c index 1ecd2b27d29..5206187634a 100644 --- a/dlls/d3d9/volume.c +++ b/dlls/d3d9/volume.c @@ -212,7 +212,7 @@ static HRESULT WINAPI IDirect3DVolume9Impl_LockBox(LPDIRECT3DVOLUME9 iface, D3DL wined3d_mutex_lock(); - hr = IWineD3DVolume_LockBox(This->wineD3DVolume, (WINED3DLOCKED_BOX *)pLockedVolume, + hr = IWineD3DVolume_Map(This->wineD3DVolume, (WINED3DLOCKED_BOX *)pLockedVolume, (const WINED3DBOX *)pBox, Flags); wined3d_mutex_unlock(); @@ -228,7 +228,7 @@ static HRESULT WINAPI IDirect3DVolume9Impl_UnlockBox(LPDIRECT3DVOLUME9 iface) { wined3d_mutex_lock(); - hr = IWineD3DVolume_UnlockBox(This->wineD3DVolume); + hr = IWineD3DVolume_Unmap(This->wineD3DVolume); wined3d_mutex_unlock(); diff --git a/dlls/d3d9/volumetexture.c b/dlls/d3d9/volumetexture.c index 7ce46237cc3..fed7fc8d092 100644 --- a/dlls/d3d9/volumetexture.c +++ b/dlls/d3d9/volumetexture.c @@ -348,8 +348,8 @@ static HRESULT WINAPI IDirect3DVolumeTexture9Impl_LockBox(LPDIRECT3DVOLUMETEXTUR wined3d_mutex_lock(); - hr = IWineD3DVolumeTexture_LockBox(This->wineD3DVolumeTexture, Level, (WINED3DLOCKED_BOX *)pLockedVolume, - (const WINED3DBOX *)pBox, Flags); + hr = IWineD3DVolumeTexture_Map(This->wineD3DVolumeTexture, Level, + (WINED3DLOCKED_BOX *)pLockedVolume, (const WINED3DBOX *)pBox, Flags); wined3d_mutex_unlock(); @@ -364,7 +364,7 @@ static HRESULT WINAPI IDirect3DVolumeTexture9Impl_UnlockBox(LPDIRECT3DVOLUMETEXT wined3d_mutex_lock(); - hr = IWineD3DVolumeTexture_UnlockBox(This->wineD3DVolumeTexture, Level); + hr = IWineD3DVolumeTexture_Unmap(This->wineD3DVolumeTexture, Level); wined3d_mutex_unlock(); diff --git a/dlls/ddraw/surface.c b/dlls/ddraw/surface.c index 8c8fb897df4..5bd219f4727 100644 --- a/dlls/ddraw/surface.c +++ b/dlls/ddraw/surface.c @@ -679,11 +679,8 @@ static HRESULT WINAPI ddraw_surface7_Lock(IDirectDrawSurface7 *iface, } } - hr = IWineD3DSurface_LockRect(This->WineD3DSurface, - &LockedRect, - Rect, - Flags); - if(hr != D3D_OK) + hr = IWineD3DSurface_Map(This->WineD3DSurface, &LockedRect, Rect, Flags); + if (FAILED(hr)) { LeaveCriticalSection(&ddraw_cs); switch(hr) @@ -744,8 +741,8 @@ static HRESULT WINAPI ddraw_surface7_Unlock(IDirectDrawSurface7 *iface, RECT *pR TRACE("iface %p, rect %s.\n", iface, wine_dbgstr_rect(pRect)); EnterCriticalSection(&ddraw_cs); - hr = IWineD3DSurface_UnlockRect(This->WineD3DSurface); - if(SUCCEEDED(hr)) + hr = IWineD3DSurface_Unmap(This->WineD3DSurface); + if (SUCCEEDED(hr)) { This->surface_desc.lpSurface = NULL; } @@ -3297,7 +3294,7 @@ static HRESULT WINAPI d3d_texture2_Load(IDirect3DTexture2 *iface, IDirect3DTextu /* Copy the main memory texture into the surface that corresponds * to the OpenGL texture object. */ - hr = IWineD3DSurface_LockRect(src_surface->WineD3DSurface, &src_rect, NULL, 0); + hr = IWineD3DSurface_Map(src_surface->WineD3DSurface, &src_rect, NULL, 0); if (FAILED(hr)) { ERR("Failed to lock source surface, hr %#x.\n", hr); @@ -3305,11 +3302,11 @@ static HRESULT WINAPI d3d_texture2_Load(IDirect3DTexture2 *iface, IDirect3DTextu return D3DERR_TEXTURE_LOAD_FAILED; } - hr = IWineD3DSurface_LockRect(dst_surface->WineD3DSurface, &dst_rect, NULL, 0); + hr = IWineD3DSurface_Map(dst_surface->WineD3DSurface, &dst_rect, NULL, 0); if (FAILED(hr)) { ERR("Failed to lock destination surface, hr %#x.\n", hr); - IWineD3DSurface_UnlockRect(src_surface->WineD3DSurface); + IWineD3DSurface_Unmap(src_surface->WineD3DSurface); LeaveCriticalSection(&ddraw_cs); return D3DERR_TEXTURE_LOAD_FAILED; } @@ -3319,8 +3316,8 @@ static HRESULT WINAPI d3d_texture2_Load(IDirect3DTexture2 *iface, IDirect3DTextu else memcpy(dst_rect.pBits, src_rect.pBits, src_rect.Pitch * src_desc->dwHeight); - IWineD3DSurface_UnlockRect(src_surface->WineD3DSurface); - IWineD3DSurface_UnlockRect(dst_surface->WineD3DSurface); + IWineD3DSurface_Unmap(src_surface->WineD3DSurface); + IWineD3DSurface_Unmap(dst_surface->WineD3DSurface); } if (src_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP) diff --git a/dlls/wined3d/cubetexture.c b/dlls/wined3d/cubetexture.c index 2d2c04c2c21..a3170a195e4 100644 --- a/dlls/wined3d/cubetexture.c +++ b/dlls/wined3d/cubetexture.c @@ -358,7 +358,7 @@ static HRESULT WINAPI IWineD3DCubeTextureImpl_GetCubeMapSurface(IWineD3DCubeText return WINED3D_OK; } -static HRESULT WINAPI IWineD3DCubeTextureImpl_LockRect(IWineD3DCubeTexture *iface, +static HRESULT WINAPI IWineD3DCubeTextureImpl_Map(IWineD3DCubeTexture *iface, WINED3DCUBEMAP_FACES face, UINT level, WINED3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; @@ -373,10 +373,10 @@ static HRESULT WINAPI IWineD3DCubeTextureImpl_LockRect(IWineD3DCubeTexture *ifac return WINED3DERR_INVALIDCALL; } - return IWineD3DSurface_LockRect(surface, locked_rect, rect, flags); + return IWineD3DSurface_Map(surface, locked_rect, rect, flags); } -static HRESULT WINAPI IWineD3DCubeTextureImpl_UnlockRect(IWineD3DCubeTexture *iface, +static HRESULT WINAPI IWineD3DCubeTextureImpl_Unmap(IWineD3DCubeTexture *iface, WINED3DCUBEMAP_FACES face, UINT level) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; @@ -391,7 +391,7 @@ static HRESULT WINAPI IWineD3DCubeTextureImpl_UnlockRect(IWineD3DCubeTexture *if return WINED3DERR_INVALIDCALL; } - return IWineD3DSurface_UnlockRect(surface); + return IWineD3DSurface_Unmap(surface); } static HRESULT WINAPI IWineD3DCubeTextureImpl_AddDirtyRect(IWineD3DCubeTexture *iface, @@ -446,8 +446,8 @@ static const IWineD3DCubeTextureVtbl IWineD3DCubeTexture_Vtbl = /* IWineD3DCubeTexture */ IWineD3DCubeTextureImpl_GetLevelDesc, IWineD3DCubeTextureImpl_GetCubeMapSurface, - IWineD3DCubeTextureImpl_LockRect, - IWineD3DCubeTextureImpl_UnlockRect, + IWineD3DCubeTextureImpl_Map, + IWineD3DCubeTextureImpl_Unmap, IWineD3DCubeTextureImpl_AddDirtyRect }; diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index 209f87ddbcd..34a766f77dc 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -4918,22 +4918,23 @@ static HRESULT IWineD3DDeviceImpl_UpdateVolume(IWineD3DDevice *iface, /* TODO: Implement direct loading into the gl volume instead of using memcpy and * dirtification to improve loading performance. */ - hr = IWineD3DVolume_LockBox(pSourceVolume, &src, NULL, WINED3DLOCK_READONLY); - if(FAILED(hr)) return hr; - hr = IWineD3DVolume_LockBox(pDestinationVolume, &dst, NULL, WINED3DLOCK_DISCARD); - if(FAILED(hr)) { - IWineD3DVolume_UnlockBox(pSourceVolume); - return hr; + hr = IWineD3DVolume_Map(pSourceVolume, &src, NULL, WINED3DLOCK_READONLY); + if (FAILED(hr)) return hr; + hr = IWineD3DVolume_Map(pDestinationVolume, &dst, NULL, WINED3DLOCK_DISCARD); + if (FAILED(hr)) + { + IWineD3DVolume_Unmap(pSourceVolume); + return hr; } memcpy(dst.pBits, src.pBits, ((IWineD3DVolumeImpl *) pDestinationVolume)->resource.size); - hr = IWineD3DVolume_UnlockBox(pDestinationVolume); - if(FAILED(hr)) { - IWineD3DVolume_UnlockBox(pSourceVolume); - } else { - hr = IWineD3DVolume_UnlockBox(pSourceVolume); - } + hr = IWineD3DVolume_Unmap(pDestinationVolume); + if (FAILED(hr)) + IWineD3DVolume_Unmap(pSourceVolume); + else + hr = IWineD3DVolume_Unmap(pSourceVolume); + return hr; } @@ -5827,7 +5828,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetCursorProperties(IWineD3DDevice *ifa */ This->cursorWidth = s->currentDesc.Width; This->cursorHeight = s->currentDesc.Height; - if (SUCCEEDED(IWineD3DSurface_LockRect(cursor_image, &rect, NULL, WINED3DLOCK_READONLY))) + if (SUCCEEDED(IWineD3DSurface_Map(cursor_image, &rect, NULL, WINED3DLOCK_READONLY))) { const struct wined3d_gl_info *gl_info = &This->adapter->gl_info; const struct wined3d_format *format = wined3d_get_format(gl_info, WINED3DFMT_B8G8R8A8_UNORM); @@ -5847,7 +5848,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetCursorProperties(IWineD3DDevice *ifa mem = HeapAlloc(GetProcessHeap(), 0, width * height * bpp); for(i = 0; i < height; i++) memcpy(&mem[width * bpp * i], &bits[rect.Pitch * i], width * bpp); - IWineD3DSurface_UnlockRect(cursor_image); + IWineD3DSurface_Unmap(cursor_image); context = context_acquire(This, NULL); @@ -5903,7 +5904,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetCursorProperties(IWineD3DDevice *ifa * chunks. */ DWORD *maskBits = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (s->currentDesc.Width * s->currentDesc.Height / 8)); - IWineD3DSurface_LockRect(cursor_image, &lockedRect, NULL, + IWineD3DSurface_Map(cursor_image, &lockedRect, NULL, WINED3DLOCK_NO_DIRTY_UPDATE | WINED3DLOCK_READONLY); TRACE("width: %u height: %u.\n", s->currentDesc.Width, s->currentDesc.Height); @@ -5912,7 +5913,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetCursorProperties(IWineD3DDevice *ifa cursorInfo.yHotspot = YHotSpot; cursorInfo.hbmMask = CreateBitmap(s->currentDesc.Width, s->currentDesc.Height, 1, 1, maskBits); cursorInfo.hbmColor = CreateBitmap(s->currentDesc.Width, s->currentDesc.Height, 1, 32, lockedRect.pBits); - IWineD3DSurface_UnlockRect(cursor_image); + IWineD3DSurface_Unmap(cursor_image); /* Create our cursor and clean up. */ cursor = CreateIconIndirect(&cursorInfo); SetCursor(cursor); diff --git a/dlls/wined3d/surface.c b/dlls/wined3d/surface.c index 442ce757920..ac566b4c42f 100644 --- a/dlls/wined3d/surface.c +++ b/dlls/wined3d/surface.c @@ -1268,11 +1268,6 @@ static void read_from_framebuffer(IWineD3DSurfaceImpl *This, const RECT *rect, v return; } - /* Activate the surface. Set it up for blitting now, although not necessarily needed for LockRect. - * Certain graphics drivers seem to dislike some enabled states when reading from opengl, the blitting usage - * should help here. Furthermore unlockrect will need the context set up for blitting. The context manager will find - * context->last_was_blit set on the unlock. - */ context = context_acquire(device, This); context_apply_blit_state(context, device); gl_info = context->gl_info; @@ -1285,10 +1280,9 @@ static void read_from_framebuffer(IWineD3DSurfaceImpl *This, const RECT *rect, v */ if (surface_is_offscreen(This)) { - /* Locking the primary render target which is not on a swapchain(=offscreen render target). - * Read from the back buffer - */ - TRACE("Locking offscreen render target\n"); + /* Mapping the primary render target which is not on a swapchain. + * Read from the back buffer. */ + TRACE("Mapping offscreen render target.\n"); glReadBuffer(device->offscreenBuffer); srcIsUpsideDown = TRUE; } @@ -1296,7 +1290,7 @@ static void read_from_framebuffer(IWineD3DSurfaceImpl *This, const RECT *rect, v { /* Onscreen surfaces are always part of a swapchain */ GLenum buffer = surface_get_gl_buffer(This); - TRACE("Locking %#x buffer\n", buffer); + TRACE("Mapping %#x buffer.\n", buffer); glReadBuffer(buffer); checkGLcall("glReadBuffer"); srcIsUpsideDown = FALSE; @@ -1647,7 +1641,9 @@ static void surface_prepare_system_memory(IWineD3DSurfaceImpl *This) } } -static HRESULT WINAPI IWineD3DSurfaceImpl_LockRect(IWineD3DSurface *iface, WINED3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) { +static HRESULT WINAPI IWineD3DSurfaceImpl_Map(IWineD3DSurface *iface, + WINED3DLOCKED_RECT *pLockedRect, const RECT *pRect, DWORD Flags) +{ IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; IWineD3DDeviceImpl *device = This->resource.device; const RECT *pass_rect = pRect; @@ -1746,7 +1742,7 @@ lock_end: } } - return IWineD3DBaseSurfaceImpl_LockRect(iface, pLockedRect, pRect, Flags); + return IWineD3DBaseSurfaceImpl_Map(iface, pLockedRect, pRect, Flags); } static void flush_to_framebuffer_drawpixels(IWineD3DSurfaceImpl *This, GLenum fmt, GLenum type, UINT bpp, const BYTE *mem) { @@ -1846,7 +1842,8 @@ static void flush_to_framebuffer_drawpixels(IWineD3DSurfaceImpl *This, GLenum fm context_release(context); } -static HRESULT WINAPI IWineD3DSurfaceImpl_UnlockRect(IWineD3DSurface *iface) { +static HRESULT WINAPI IWineD3DSurfaceImpl_Unmap(IWineD3DSurface *iface) +{ IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; IWineD3DDeviceImpl *device = This->resource.device; BOOL fullsurface; @@ -1917,13 +1914,16 @@ static HRESULT WINAPI IWineD3DSurfaceImpl_UnlockRect(IWineD3DSurface *iface) { break; } - if(!fullsurface) { - /* Partial rectangle tracking is not commonly implemented, it is only done for render targets. Overwrite - * the flags to bring them back into a sane state. INSYSMEM was set before to tell LoadLocation where - * to read the rectangle from. Indrawable is set because all modifications from the partial sysmem copy - * are written back to the drawable, thus the surface is merged again in the drawable. The sysmem copy is - * not fully up to date because only a subrectangle was read in LockRect. - */ + if (!fullsurface) + { + /* Partial rectangle tracking is not commonly implemented, it is + * only done for render targets. Overwrite the flags to bring + * them back into a sane state. INSYSMEM was set before to tell + * surface_load_location() where to read the rectangle from. + * Indrawable is set because all modifications from the partial + * sysmem copy are written back to the drawable, thus the surface + * is merged again in the drawable. The sysmem copy is not fully + * up to date because only a subrectangle was read in Map(). */ This->Flags &= ~SFLAG_INSYSMEM; This->Flags |= SFLAG_INDRAWABLE; } @@ -2031,19 +2031,17 @@ static HRESULT WINAPI IWineD3DSurfaceImpl_GetDC(IWineD3DSurface *iface, HDC *pHD This->resource.allocatedMemory = This->dib.bitmap_data; } - /* Lock the surface */ - hr = IWineD3DSurface_LockRect(iface, - &lock, - NULL, - 0); + /* Map the surface */ + hr = IWineD3DSurface_Map(iface, &lock, NULL, 0); - if(This->Flags & SFLAG_PBO) { - /* Sync the DIB with the PBO. This can't be done earlier because LockRect activates the allocatedMemory */ + /* Sync the DIB with the PBO. This can't be done earlier because Map() + * activates the allocatedMemory. */ + if (This->Flags & SFLAG_PBO) memcpy(This->dib.bitmap_data, This->resource.allocatedMemory, This->dib.bitmap_size); - } - if(FAILED(hr)) { - ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr); + if (FAILED(hr)) + { + ERR("IWineD3DSurface_Map failed, hr %#x.\n", hr); /* keep the dib section */ return hr; } @@ -2105,7 +2103,7 @@ static HRESULT WINAPI IWineD3DSurfaceImpl_ReleaseDC(IWineD3DSurface *iface, HDC } /* we locked first, so unlock now */ - IWineD3DSurface_UnlockRect(iface); + IWineD3DSurface_Unmap(iface); This->Flags &= ~SFLAG_DCINUSE; @@ -2649,8 +2647,10 @@ static HRESULT WINAPI IWineD3DSurfaceImpl_SetMem(IWineD3DSurface *iface, void *M /* Now free the old memory if any */ HeapFree(GetProcessHeap(), 0, release); - } else if(This->Flags & SFLAG_USERPTR) { - /* LockRect and GetDC will re-create the dib section and allocated memory */ + } + else if (This->Flags & SFLAG_USERPTR) + { + /* Map and GetDC will re-create the dib section and allocated memory. */ This->resource.allocatedMemory = NULL; /* HeapMemory should be NULL already */ if (This->resource.heapMemory) @@ -4732,8 +4732,8 @@ const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl = IWineD3DBaseSurfaceImpl_GetType, /* IWineD3DSurface */ IWineD3DBaseSurfaceImpl_GetDesc, - IWineD3DSurfaceImpl_LockRect, - IWineD3DSurfaceImpl_UnlockRect, + IWineD3DSurfaceImpl_Map, + IWineD3DSurfaceImpl_Unmap, IWineD3DSurfaceImpl_GetDC, IWineD3DSurfaceImpl_ReleaseDC, IWineD3DSurfaceImpl_Flip, diff --git a/dlls/wined3d/surface_base.c b/dlls/wined3d/surface_base.c index e4dd853b0b3..1324acfddd7 100644 --- a/dlls/wined3d/surface_base.c +++ b/dlls/wined3d/surface_base.c @@ -823,16 +823,18 @@ static IWineD3DSurfaceImpl *surface_convert_format(IWineD3DSurfaceImpl *source, memset(&lock_src, 0, sizeof(lock_src)); memset(&lock_dst, 0, sizeof(lock_dst)); - hr = IWineD3DSurface_LockRect((IWineD3DSurface *) source, &lock_src, NULL, WINED3DLOCK_READONLY); - if(FAILED(hr)) { - ERR("Failed to lock the source surface\n"); + hr = IWineD3DSurface_Map((IWineD3DSurface *)source, &lock_src, NULL, WINED3DLOCK_READONLY); + if (FAILED(hr)) + { + ERR("Failed to lock the source surface.\n"); IWineD3DSurface_Release(ret); return NULL; } - hr = IWineD3DSurface_LockRect(ret, &lock_dst, NULL, WINED3DLOCK_READONLY); - if(FAILED(hr)) { + hr = IWineD3DSurface_Map(ret, &lock_dst, NULL, WINED3DLOCK_READONLY); + if (FAILED(hr)) + { ERR("Failed to lock the dest surface\n"); - IWineD3DSurface_UnlockRect((IWineD3DSurface *) source); + IWineD3DSurface_Unmap((IWineD3DSurface *)source); IWineD3DSurface_Release(ret); return NULL; } @@ -840,8 +842,8 @@ static IWineD3DSurfaceImpl *surface_convert_format(IWineD3DSurfaceImpl *source, conv->convert(lock_src.pBits, lock_dst.pBits, lock_src.Pitch, lock_dst.Pitch, source->currentDesc.Width, source->currentDesc.Height); - IWineD3DSurface_UnlockRect(ret); - IWineD3DSurface_UnlockRect((IWineD3DSurface *) source); + IWineD3DSurface_Unmap(ret); + IWineD3DSurface_Unmap((IWineD3DSurface *)source); return (IWineD3DSurfaceImpl *) ret; } @@ -1093,7 +1095,7 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_Blt(IWineD3DSurface *iface, const RECT *D if (src == This) { - IWineD3DSurface_LockRect(iface, &dlock, NULL, 0); + IWineD3DSurface_Map(iface, &dlock, NULL, 0); slock = dlock; sEntry = This->resource.format; dEntry = sEntry; @@ -1113,7 +1115,7 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_Blt(IWineD3DSurface *iface, const RECT *D goto release; } } - IWineD3DSurface_LockRect((IWineD3DSurface *)src, &slock, NULL, WINED3DLOCK_READONLY); + IWineD3DSurface_Map((IWineD3DSurface *)src, &slock, NULL, WINED3DLOCK_READONLY); sEntry = src->resource.format; } else @@ -1121,9 +1123,9 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_Blt(IWineD3DSurface *iface, const RECT *D sEntry = dEntry; } if (DestRect) - IWineD3DSurface_LockRect(iface, &dlock, &xdst, 0); + IWineD3DSurface_Map(iface, &dlock, &xdst, 0); else - IWineD3DSurface_LockRect(iface, &dlock, NULL, 0); + IWineD3DSurface_Map(iface, &dlock, NULL, 0); } if (!DDBltFx || !(DDBltFx->dwDDFX)) Flags &= ~WINEDDBLT_DDFX; @@ -1523,8 +1525,8 @@ error: } release: - IWineD3DSurface_UnlockRect(iface); - if (src && src != This) IWineD3DSurface_UnlockRect((IWineD3DSurface *)src); + IWineD3DSurface_Unmap(iface); + if (src && src != This) IWineD3DSurface_Unmap((IWineD3DSurface *)src); /* Release the converted surface if any */ if (src && src_surface != (IWineD3DSurface *)src) IWineD3DSurface_Release((IWineD3DSurface *)src); return ret; @@ -1624,8 +1626,8 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dst UnionRect(&lock_union, &lock_src, &lock_dst); /* Lock the union of the two rectangles */ - ret = IWineD3DSurface_LockRect(iface, &dlock, &lock_union, 0); - if(ret != WINED3D_OK) goto error; + ret = IWineD3DSurface_Map(iface, &dlock, &lock_union, 0); + if (FAILED(ret)) goto error; pitch = dlock.Pitch; slock.Pitch = dlock.Pitch; @@ -1638,10 +1640,10 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dst } else { - ret = IWineD3DSurface_LockRect(src_surface, &slock, &lock_src, WINED3DLOCK_READONLY); - if(ret != WINED3D_OK) goto error; - ret = IWineD3DSurface_LockRect(iface, &dlock, &lock_dst, 0); - if(ret != WINED3D_OK) goto error; + ret = IWineD3DSurface_Map(src_surface, &slock, &lock_src, WINED3DLOCK_READONLY); + if (FAILED(ret)) goto error; + ret = IWineD3DSurface_Map(iface, &dlock, &lock_dst, 0); + if (FAILED(ret)) goto error; sbuf = slock.pBits; dbuf = dlock.pBits; @@ -1795,18 +1797,19 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dst error: if (src == This) { - IWineD3DSurface_UnlockRect(iface); + IWineD3DSurface_Unmap(iface); } else { - IWineD3DSurface_UnlockRect(iface); - IWineD3DSurface_UnlockRect(src_surface); + IWineD3DSurface_Unmap(iface); + IWineD3DSurface_Unmap(src_surface); } return ret; } -HRESULT WINAPI IWineD3DBaseSurfaceImpl_LockRect(IWineD3DSurface *iface, WINED3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) +HRESULT WINAPI IWineD3DBaseSurfaceImpl_Map(IWineD3DSurface *iface, + WINED3DLOCKED_RECT *pLockedRect, const RECT *pRect, DWORD Flags) { IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; diff --git a/dlls/wined3d/surface_gdi.c b/dlls/wined3d/surface_gdi.c index a640b794ee5..9386a886730 100644 --- a/dlls/wined3d/surface_gdi.c +++ b/dlls/wined3d/surface_gdi.c @@ -109,26 +109,8 @@ static void WINAPI IWineGDISurfaceImpl_UnLoad(IWineD3DSurface *iface) ERR("(%p): Please report to wine-devel\n", iface); } -/***************************************************************************** - * IWineD3DSurface::LockRect, GDI version - * - * Locks the surface and returns a pointer to the surface memory - * - * Params: - * pLockedRect: Address to return the locking info at - * pRect: Rectangle to lock - * Flags: Some flags - * - * Returns: - * WINED3D_OK on success - * WINED3DERR_INVALIDCALL on errors - * - *****************************************************************************/ -static HRESULT WINAPI -IWineGDISurfaceImpl_LockRect(IWineD3DSurface *iface, - WINED3DLOCKED_RECT* pLockedRect, - CONST RECT* pRect, - DWORD Flags) +static HRESULT WINAPI IWineGDISurfaceImpl_Map(IWineD3DSurface *iface, + WINED3DLOCKED_RECT *pLockedRect, const RECT *pRect, DWORD Flags) { IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; @@ -149,29 +131,17 @@ IWineGDISurfaceImpl_LockRect(IWineD3DSurface *iface, This->resource.allocatedMemory = This->dib.bitmap_data; } - return IWineD3DBaseSurfaceImpl_LockRect(iface, pLockedRect, pRect, Flags); + return IWineD3DBaseSurfaceImpl_Map(iface, pLockedRect, pRect, Flags); } -/***************************************************************************** - * IWineD3DSurface::UnlockRect, GDI version - * - * Unlocks a surface. This implementation doesn't do much, except updating - * the window if the front buffer is unlocked - * - * Returns: - * WINED3D_OK on success - * WINED3DERR_INVALIDCALL on failure - * - *****************************************************************************/ -static HRESULT WINAPI -IWineGDISurfaceImpl_UnlockRect(IWineD3DSurface *iface) +static HRESULT WINAPI IWineGDISurfaceImpl_Unmap(IWineD3DSurface *iface) { IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface; TRACE("(%p)\n", This); if (!(This->Flags & SFLAG_LOCKED)) { - WARN("trying to Unlock an unlocked surf@%p\n", This); + WARN("Trying to unmap unmapped surfaces %p.\n", iface); return WINEDDERR_NOTLOCKED; } @@ -278,13 +248,11 @@ static HRESULT WINAPI IWineGDISurfaceImpl_GetDC(IWineD3DSurface *iface, HDC *pHD /* Should have a DIB section already */ - /* Lock the surface */ - hr = IWineD3DSurface_LockRect(iface, - &lock, - NULL, - 0); - if(FAILED(hr)) { - ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr); + /* Map the surface. */ + hr = IWineD3DSurface_Map(iface, &lock, NULL, 0); + if (FAILED(hr)) + { + ERR("IWineD3DSurface_Map failed, hr %#x.\n", hr); /* keep the dib section */ return hr; } @@ -338,7 +306,7 @@ static HRESULT WINAPI IWineGDISurfaceImpl_ReleaseDC(IWineD3DSurface *iface, HDC } /* we locked first, so unlock now */ - IWineD3DSurface_UnlockRect(iface); + IWineD3DSurface_Unmap(iface); This->Flags &= ~SFLAG_DCINUSE; @@ -466,8 +434,10 @@ static HRESULT WINAPI IWineGDISurfaceImpl_SetMem(IWineD3DSurface *iface, void *M /* Now free the old memory if any */ HeapFree(GetProcessHeap(), 0, release); - } else if(This->Flags & SFLAG_USERPTR) { - /* LockRect and GetDC will re-create the dib section and allocated memory */ + } + else if(This->Flags & SFLAG_USERPTR) + { + /* Map() and GetDC() will re-create the dib section and allocated memory. */ This->resource.allocatedMemory = NULL; This->Flags &= ~SFLAG_USERPTR; } @@ -504,8 +474,8 @@ const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl = IWineD3DBaseSurfaceImpl_GetType, /* IWineD3DSurface */ IWineD3DBaseSurfaceImpl_GetDesc, - IWineGDISurfaceImpl_LockRect, - IWineGDISurfaceImpl_UnlockRect, + IWineGDISurfaceImpl_Map, + IWineGDISurfaceImpl_Unmap, IWineGDISurfaceImpl_GetDC, IWineGDISurfaceImpl_ReleaseDC, IWineGDISurfaceImpl_Flip, diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index ce95567f547..a1d83e99d5c 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -376,7 +376,7 @@ static HRESULT WINAPI IWineD3DTextureImpl_GetSurfaceLevel(IWineD3DTexture *iface return WINED3D_OK; } -static HRESULT WINAPI IWineD3DTextureImpl_LockRect(IWineD3DTexture *iface, +static HRESULT WINAPI IWineD3DTextureImpl_Map(IWineD3DTexture *iface, UINT level, WINED3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; @@ -391,10 +391,10 @@ static HRESULT WINAPI IWineD3DTextureImpl_LockRect(IWineD3DTexture *iface, return WINED3DERR_INVALIDCALL; } - return IWineD3DSurface_LockRect(surface, locked_rect, rect, flags); + return IWineD3DSurface_Map(surface, locked_rect, rect, flags); } -static HRESULT WINAPI IWineD3DTextureImpl_UnlockRect(IWineD3DTexture *iface, UINT level) +static HRESULT WINAPI IWineD3DTextureImpl_Unmap(IWineD3DTexture *iface, UINT level) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; IWineD3DSurface *surface; @@ -407,7 +407,7 @@ static HRESULT WINAPI IWineD3DTextureImpl_UnlockRect(IWineD3DTexture *iface, UIN return WINED3DERR_INVALIDCALL; } - return IWineD3DSurface_UnlockRect(surface); + return IWineD3DSurface_Unmap(surface); } static HRESULT WINAPI IWineD3DTextureImpl_AddDirtyRect(IWineD3DTexture *iface, const RECT *dirty_rect) @@ -460,8 +460,8 @@ static const IWineD3DTextureVtbl IWineD3DTexture_Vtbl = /* IWineD3DTexture */ IWineD3DTextureImpl_GetLevelDesc, IWineD3DTextureImpl_GetSurfaceLevel, - IWineD3DTextureImpl_LockRect, - IWineD3DTextureImpl_UnlockRect, + IWineD3DTextureImpl_Map, + IWineD3DTextureImpl_Unmap, IWineD3DTextureImpl_AddDirtyRect }; diff --git a/dlls/wined3d/volume.c b/dlls/wined3d/volume.c index 8d42d547329..4b177a663ff 100644 --- a/dlls/wined3d/volume.c +++ b/dlls/wined3d/volume.c @@ -205,7 +205,9 @@ static void WINAPI IWineD3DVolumeImpl_GetDesc(IWineD3DVolume *iface, WINED3DVOLU desc->Depth = volume->currentDesc.Depth; } -static HRESULT WINAPI IWineD3DVolumeImpl_LockBox(IWineD3DVolume *iface, WINED3DLOCKED_BOX* pLockedVolume, CONST WINED3DBOX* pBox, DWORD Flags) { +static HRESULT WINAPI IWineD3DVolumeImpl_Map(IWineD3DVolume *iface, + WINED3DLOCKED_BOX *pLockedVolume, const WINED3DBOX *pBox, DWORD Flags) +{ IWineD3DVolumeImpl *This = (IWineD3DVolumeImpl *)iface; FIXME("(%p) : pBox=%p stub\n", This, pBox); @@ -257,7 +259,8 @@ static HRESULT WINAPI IWineD3DVolumeImpl_LockBox(IWineD3DVolume *iface, WINED3DL return WINED3D_OK; } -static HRESULT WINAPI IWineD3DVolumeImpl_UnlockBox(IWineD3DVolume *iface) { +static HRESULT WINAPI IWineD3DVolumeImpl_Unmap(IWineD3DVolume *iface) +{ IWineD3DVolumeImpl *This = (IWineD3DVolumeImpl *)iface; if (!This->locked) { @@ -321,8 +324,8 @@ static const IWineD3DVolumeVtbl IWineD3DVolume_Vtbl = IWineD3DVolumeImpl_GetType, /* IWineD3DVolume */ IWineD3DVolumeImpl_GetDesc, - IWineD3DVolumeImpl_LockBox, - IWineD3DVolumeImpl_UnlockBox, + IWineD3DVolumeImpl_Map, + IWineD3DVolumeImpl_Unmap, /* Internal interface */ IWineD3DVolumeImpl_LoadTexture, }; diff --git a/dlls/wined3d/volumetexture.c b/dlls/wined3d/volumetexture.c index a2c0c6d796a..c8f596da05c 100644 --- a/dlls/wined3d/volumetexture.c +++ b/dlls/wined3d/volumetexture.c @@ -293,7 +293,7 @@ static HRESULT WINAPI IWineD3DVolumeTextureImpl_GetVolumeLevel(IWineD3DVolumeTex return WINED3D_OK; } -static HRESULT WINAPI IWineD3DVolumeTextureImpl_LockBox(IWineD3DVolumeTexture *iface, +static HRESULT WINAPI IWineD3DVolumeTextureImpl_Map(IWineD3DVolumeTexture *iface, UINT level, WINED3DLOCKED_BOX *locked_box, const WINED3DBOX *box, DWORD flags) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; @@ -308,10 +308,10 @@ static HRESULT WINAPI IWineD3DVolumeTextureImpl_LockBox(IWineD3DVolumeTexture *i return WINED3DERR_INVALIDCALL; } - return IWineD3DVolume_LockBox(volume, locked_box, box, flags); + return IWineD3DVolume_Map(volume, locked_box, box, flags); } -static HRESULT WINAPI IWineD3DVolumeTextureImpl_UnlockBox(IWineD3DVolumeTexture *iface, UINT level) +static HRESULT WINAPI IWineD3DVolumeTextureImpl_Unmap(IWineD3DVolumeTexture *iface, UINT level) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; IWineD3DVolume *volume; @@ -324,7 +324,7 @@ static HRESULT WINAPI IWineD3DVolumeTextureImpl_UnlockBox(IWineD3DVolumeTexture return WINED3DERR_INVALIDCALL; } - return IWineD3DVolume_UnlockBox(volume); + return IWineD3DVolume_Unmap(volume); } static HRESULT WINAPI IWineD3DVolumeTextureImpl_AddDirtyBox(IWineD3DVolumeTexture *iface, const WINED3DBOX *dirty_box) @@ -378,8 +378,8 @@ static const IWineD3DVolumeTextureVtbl IWineD3DVolumeTexture_Vtbl = /* volume texture */ IWineD3DVolumeTextureImpl_GetLevelDesc, IWineD3DVolumeTextureImpl_GetVolumeLevel, - IWineD3DVolumeTextureImpl_LockBox, - IWineD3DVolumeTextureImpl_UnlockBox, + IWineD3DVolumeTextureImpl_Map, + IWineD3DVolumeTextureImpl_Unmap, IWineD3DVolumeTextureImpl_AddDirtyBox }; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index fc1fd080d78..77a512a4cc4 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2203,7 +2203,7 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_Blt(IWineD3DSurface *iface, const RECT *d const RECT *src_rect, DWORD flags, const WINEDDBLTFX *fx, WINED3DTEXTUREFILTERTYPE filter) DECLSPEC_HIDDEN; HRESULT WINAPI IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dstx, DWORD dsty, IWineD3DSurface *Source, const RECT *rsrc, DWORD trans) DECLSPEC_HIDDEN; -HRESULT WINAPI IWineD3DBaseSurfaceImpl_LockRect(IWineD3DSurface *iface, WINED3DLOCKED_RECT *pLockedRect, +HRESULT WINAPI IWineD3DBaseSurfaceImpl_Map(IWineD3DSurface *iface, WINED3DLOCKED_RECT *pLockedRect, const RECT *pRect, DWORD Flags) DECLSPEC_HIDDEN; const void *WINAPI IWineD3DBaseSurfaceImpl_GetData(IWineD3DSurface *iface) DECLSPEC_HIDDEN; diff --git a/include/wine/wined3d.idl b/include/wine/wined3d.idl index d990f707dfe..e024940ede5 100644 --- a/include/wine/wined3d.idl +++ b/include/wine/wined3d.idl @@ -2377,12 +2377,12 @@ interface IWineD3DSurface : IWineD3DResource void GetDesc( [out] WINED3DSURFACE_DESC *desc ); - HRESULT LockRect( + HRESULT Map( [out] WINED3DLOCKED_RECT *locked_rect, [in] const RECT *rect, [in] DWORD flags ); - HRESULT UnlockRect( + HRESULT Unmap( ); HRESULT GetDC( [out] HDC *dc @@ -2490,12 +2490,12 @@ interface IWineD3DVolume : IWineD3DResource void GetDesc( [out] WINED3DVOLUME_DESC *desc ); - HRESULT LockBox( + HRESULT Map( [out] WINED3DLOCKED_BOX *locked_box, [in] const WINED3DBOX *box, [in] DWORD flags ); - HRESULT UnlockBox( + HRESULT Unmap( ); HRESULT LoadTexture( [in] int gl_level, @@ -2551,13 +2551,13 @@ interface IWineD3DTexture : IWineD3DBaseTexture [in] UINT level, [out] IWineD3DSurface **surface ); - HRESULT LockRect( + HRESULT Map( [in] UINT level, [out] WINED3DLOCKED_RECT *locked_rect, [in] const RECT *rect, [in] DWORD flags ); - HRESULT UnlockRect( + HRESULT Unmap( [in] UINT level ); HRESULT AddDirtyRect( @@ -2581,14 +2581,14 @@ interface IWineD3DCubeTexture : IWineD3DBaseTexture [in] UINT level, [out] IWineD3DSurface **surface ); - HRESULT LockRect( + HRESULT Map( [in] WINED3DCUBEMAP_FACES face, [in] UINT level, [out] WINED3DLOCKED_RECT *locked_rect, [in] const RECT *rect, [in] DWORD flags ); - HRESULT UnlockRect( + HRESULT Unmap( [in] WINED3DCUBEMAP_FACES face, [in] UINT level ); @@ -2613,13 +2613,13 @@ interface IWineD3DVolumeTexture : IWineD3DBaseTexture [in] UINT level, [out] IWineD3DVolume **volume ); - HRESULT LockBox( + HRESULT Map( [in] UINT level, [out] WINED3DLOCKED_BOX *locked_box, [in] const WINED3DBOX *box, [in] DWORD flags ); - HRESULT UnlockBox( + HRESULT Unmap( [in] UINT level ); HRESULT AddDirtyBox(