if (ref == 0) {
TRACE("Releasing child %p\n", This->wineD3DCubeTexture);
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DCubeTexture_Destroy(This->wineD3DCubeTexture, D3D8CB_DestroySurface);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
IUnknown_Release(This->parentDevice);
HeapFree(GetProcessHeap(), 0, This);
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DCubeTexture_GetDevice(This->wineD3DCubeTexture, &wined3d_device);
if (SUCCEEDED(hr))
{
IWineD3DDevice_GetParent(wined3d_device, (IUnknown **)ppDevice);
IWineD3DDevice_Release(wined3d_device);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DCubeTexture_SetPrivateData(This->wineD3DCubeTexture,refguid,pData,SizeOfData,Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DCubeTexture_GetPrivateData(This->wineD3DCubeTexture,refguid,pData,pSizeOfData);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DCubeTexture_FreePrivateData(This->wineD3DCubeTexture,refguid);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DCubeTexture_SetPriority(This->wineD3DCubeTexture, PriorityNew);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DCubeTexture_GetPriority(This->wineD3DCubeTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
IDirect3DCubeTexture8Impl *This = (IDirect3DCubeTexture8Impl *)iface;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DCubeTexture_PreLoad(This->wineD3DCubeTexture);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
}
static D3DRESOURCETYPE WINAPI IDirect3DCubeTexture8Impl_GetType(LPDIRECT3DCUBETEXTURE8 iface) {
D3DRESOURCETYPE type;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
type = IWineD3DCubeTexture_GetType(This->wineD3DCubeTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return type;
}
DWORD lod;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
lod = IWineD3DCubeTexture_SetLOD(This->wineD3DCubeTexture, LODNew);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return lod;
}
DWORD lod;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
lod = IWineD3DCubeTexture_GetLOD((LPDIRECT3DBASETEXTURE8) This);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return lod;
}
DWORD cnt;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
cnt = IWineD3DCubeTexture_GetLevelCount(This->wineD3DCubeTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return cnt;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ /* As d3d8 and d3d9 structures differ, pass in ptrs to where data needs to go */
+ wined3ddesc.Format = (WINED3DFORMAT *)&pDesc->Format;
+ wined3ddesc.Type = (WINED3DRESOURCETYPE *)&pDesc->Type;
+ wined3ddesc.Usage = &pDesc->Usage;
+ wined3ddesc.Pool = (WINED3DPOOL *) &pDesc->Pool;
+ wined3ddesc.Size = &pDesc->Size;
+ wined3ddesc.MultiSampleType = (WINED3DMULTISAMPLE_TYPE *) &pDesc->MultiSampleType;
+ wined3ddesc.MultiSampleQuality = NULL; /* DirectX9 only */
+ wined3ddesc.Width = &pDesc->Width;
+ wined3ddesc.Height = &pDesc->Height;
+
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DCubeTexture_GetLevelDesc(This->wineD3DCubeTexture, Level, &wined3ddesc);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
- if (SUCCEEDED(hr))
- {
- pDesc->Format = d3dformat_from_wined3dformat(wined3ddesc.format);
- pDesc->Type = wined3ddesc.resource_type;
- pDesc->Usage = wined3ddesc.usage;
- pDesc->Pool = wined3ddesc.pool;
- pDesc->Size = wined3ddesc.size;
- pDesc->MultiSampleType = wined3ddesc.multisample_type;
- pDesc->Width = wined3ddesc.width;
- pDesc->Height = wined3ddesc.height;
- }
+ if (SUCCEEDED(hr)) pDesc->Format = d3dformat_from_wined3dformat(pDesc->Format);
return hr;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hrc = IWineD3DCubeTexture_GetCubeMapSurface(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES) FaceType, Level, &mySurface);
if (hrc == D3D_OK && NULL != ppCubeMapSurface) {
IWineD3DCubeTexture_GetParent(mySurface, (IUnknown **)ppCubeMapSurface);
IWineD3DCubeTexture_Release(mySurface);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hrc;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DCubeTexture_LockRect(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES) FaceType, Level, (WINED3DLOCKED_RECT *) pLockedRect, pRect, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DCubeTexture_UnlockRect(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES) FaceType, Level);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DCubeTexture_AddDirtyRect(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES) FaceType, pDirtyRect);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
#include "d3d8_private.h"
#include "wine/debug.h"
+static CRITICAL_SECTION_DEBUG d3d8_cs_debug =
+{
+ 0, 0, &d3d8_cs,
+ { &d3d8_cs_debug.ProcessLocksList,
+ &d3d8_cs_debug.ProcessLocksList },
+ 0, 0, { (DWORD_PTR)(__FILE__ ": d3d8_cs") }
+};
+CRITICAL_SECTION d3d8_cs = { &d3d8_cs_debug, -1, 0, 0, 0, 0 };
+
WINE_DEFAULT_DEBUG_CHANNEL(d3d8);
HRESULT WINAPI D3D8GetSWInfo(void) {
IDirect3D8Impl* object;
TRACE("SDKVersion = %x\n", SDKVersion);
- wined3d_mutex_lock();
-
+ EnterCriticalSection(&d3d8_cs);
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3D8Impl));
object->lpVtbl = &Direct3D8_Vtbl;
object->WineD3D = WineDirect3DCreate(8, (IUnknown *)object);
TRACE("Created Direct3D object @ %p, WineObj @ %p\n", object, object->WineD3D);
-
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
if (!object->WineD3D)
{
}
/***********************************************************************
- * ValidateVertexShader (D3D8.@)
+ * ValidateVertexShader (D3D8.@)
*
* I've seen reserved1 and reserved2 always passed as 0's
* bool seems always passed as 0 or 1, but other values work as well....
}
/***********************************************************************
- * ValidatePixelShader (D3D8.@)
+ * ValidatePixelShader (D3D8.@)
*
* PARAMS
* toto result?
_pD3D8Caps->PixelShaderVersion = _pWineCaps->PixelShaderVersion; \
_pD3D8Caps->MaxPixelShaderValue = _pWineCaps->PixelShader1xMaxValue;
-void fixup_caps(WINED3DCAPS *pWineCaps);
-
/* Direct3D8 Interfaces: */
typedef struct IDirect3DBaseTexture8Impl IDirect3DBaseTexture8Impl;
typedef struct IDirect3DVolumeTexture8Impl IDirect3DVolumeTexture8Impl;
/* Advance declaration of structures to satisfy compiler */
typedef struct IDirect3DVertexShader8Impl IDirect3DVertexShader8Impl;
+/* Global critical section */
+extern CRITICAL_SECTION d3d8_cs;
+
/* ===========================================================================
The interfaces themselves
=========================================================================== */
#define D3D8_INITIAL_HANDLE_TABLE_SIZE 64
#define D3D8_INVALID_HANDLE ~0U
-enum d3d8_handle_type
-{
- D3D8_HANDLE_FREE,
- D3D8_HANDLE_VS,
- D3D8_HANDLE_PS,
- D3D8_HANDLE_SB,
-};
-
-struct d3d8_handle_entry
-{
- void *object;
- enum d3d8_handle_type type;
-};
-
struct d3d8_handle_table
{
- struct d3d8_handle_entry *entries;
- struct d3d8_handle_entry *free_entries;
+ void **entries;
+ void **free_entries;
UINT table_size;
UINT entry_count;
};
case WINED3DFMT_X8L8V8U8: return D3DFMT_X8L8V8U8;
case WINED3DFMT_R8G8B8A8_SNORM: return D3DFMT_Q8W8V8U8;
case WINED3DFMT_R16G16_SNORM: return D3DFMT_V16U16;
- case WINED3DFMT_W11V11U10: return D3DFMT_W11V11U10;
case WINED3DFMT_A2W10V10U10: return D3DFMT_A2W10V10U10;
case WINED3DFMT_D16_LOCKABLE: return D3DFMT_D16_LOCKABLE;
case WINED3DFMT_D32: return D3DFMT_D32;
case D3DFMT_X8L8V8U8: return WINED3DFMT_X8L8V8U8;
case D3DFMT_Q8W8V8U8: return WINED3DFMT_R8G8B8A8_SNORM;
case D3DFMT_V16U16: return WINED3DFMT_R16G16_SNORM;
- case D3DFMT_W11V11U10: return WINED3DFMT_W11V11U10;
case D3DFMT_A2W10V10U10: return WINED3DFMT_A2W10V10U10;
case D3DFMT_D16_LOCKABLE: return WINED3DFMT_D16_LOCKABLE;
case D3DFMT_D32: return WINED3DFMT_D32;
}
/* Handle table functions */
-static DWORD d3d8_allocate_handle(struct d3d8_handle_table *t, void *object, enum d3d8_handle_type type)
+static DWORD d3d8_allocate_handle(struct d3d8_handle_table *t, void *object)
{
- struct d3d8_handle_entry *entry;
-
if (t->free_entries)
{
/* Use a free handle */
- entry = t->free_entries;
- if (entry->type != D3D8_HANDLE_FREE)
- {
- ERR("Handle %u(%p) is in the free list, but has type %#x.\n", (entry - t->entries), entry, entry->type);
- return D3D8_INVALID_HANDLE;
- }
- t->free_entries = entry->object;
- entry->object = object;
- entry->type = type;
-
+ void **entry = t->free_entries;
+ t->free_entries = *entry;
+ *entry = object;
return entry - t->entries;
}
{
/* Grow the table */
UINT new_size = t->table_size + (t->table_size >> 1);
- struct d3d8_handle_entry *new_entries = HeapReAlloc(GetProcessHeap(),
- 0, t->entries, new_size * sizeof(*t->entries));
- if (!new_entries)
- {
- ERR("Failed to grow the handle table.\n");
- return D3D8_INVALID_HANDLE;
- }
+ void **new_entries = HeapReAlloc(GetProcessHeap(), 0, t->entries, new_size * sizeof(void *));
+ if (!new_entries) return D3D8_INVALID_HANDLE;
t->entries = new_entries;
t->table_size = new_size;
}
- entry = &t->entries[t->entry_count];
- entry->object = object;
- entry->type = type;
-
+ t->entries[t->entry_count] = object;
return t->entry_count++;
}
-static void *d3d8_free_handle(struct d3d8_handle_table *t, DWORD handle, enum d3d8_handle_type type)
+static void *d3d8_free_handle(struct d3d8_handle_table *t, DWORD handle)
{
- struct d3d8_handle_entry *entry;
- void *object;
+ void **entry, *object;
- if (handle == D3D8_INVALID_HANDLE || handle >= t->entry_count)
- {
- WARN("Invalid handle %u passed.\n", handle);
- return NULL;
- }
+ if (handle >= t->entry_count) return NULL;
entry = &t->entries[handle];
- if (entry->type != type)
- {
- WARN("Handle %u(%p) is not of type %#x.\n", handle, entry, type);
- return NULL;
- }
-
- object = entry->object;
- entry->object = t->free_entries;
- entry->type = D3D8_HANDLE_FREE;
+ object = *entry;
+ *entry = t->free_entries;
t->free_entries = entry;
return object;
}
-static void *d3d8_get_object(struct d3d8_handle_table *t, DWORD handle, enum d3d8_handle_type type)
+static void *d3d8_get_object(struct d3d8_handle_table *t, DWORD handle)
{
- struct d3d8_handle_entry *entry;
-
- if (handle == D3D8_INVALID_HANDLE || handle >= t->entry_count)
- {
- WARN("Invalid handle %u passed.\n", handle);
- return NULL;
- }
-
- entry = &t->entries[handle];
- if (entry->type != type)
- {
- WARN("Handle %u(%p) is not of type %#x.\n", handle, entry, type);
- return NULL;
- }
-
- return entry->object;
+ if (handle >= t->entry_count) return NULL;
+ return t->entries[handle];
}
/* IDirect3D IUnknown parts follow: */
unsigned i;
TRACE("Releasing wined3d device %p\n", This->WineD3DDevice);
-
- wined3d_mutex_lock();
-
+ EnterCriticalSection(&d3d8_cs);
This->inDestruction = TRUE;
for(i = 0; i < This->numConvertedDecls; i++) {
IWineD3DDevice_Release(This->WineD3DDevice);
HeapFree(GetProcessHeap(), 0, This->handle_table.entries);
HeapFree(GetProcessHeap(), 0, This);
-
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
}
return ref;
}
HRESULT hr;
TRACE("(%p) : Relay\n", This);
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_TestCooperativeLevel(This->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetAvailableTextureMem(This->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) : Relay bytes(%d)\n", This, Bytes);
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_EvictManagedResources(This->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetDirect3D(This->WineD3DDevice, &pWineD3D);
if (hr == D3D_OK && pWineD3D != NULL)
{
FIXME("Call to IWineD3DDevice_GetDirect3D failed\n");
*ppD3D8 = NULL;
}
- wined3d_mutex_unlock();
-
TRACE("(%p) returning %p\n",This , *ppD3D8);
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
return D3DERR_INVALIDCALL; /* well this is what MSDN says to return */
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hrc = IWineD3DDevice_GetDeviceCaps(This->WineD3DDevice, pWineCaps);
- wined3d_mutex_unlock();
-
- fixup_caps(pWineCaps);
+ LeaveCriticalSection(&d3d8_cs);
WINECAPSTOD3D8CAPS(pCaps, pWineCaps)
HeapFree(GetProcessHeap(), 0, pWineCaps);
+ /* D3D8 doesn't support SM 2.0 or higher, so clamp to 1.x */
+ if(pCaps->PixelShaderVersion > D3DPS_VERSION(1,4)){
+ pCaps->PixelShaderVersion = D3DPS_VERSION(1,4);
+ }
+ if(pCaps->VertexShaderVersion > D3DVS_VERSION(1,1)){
+ pCaps->VertexShaderVersion = D3DVS_VERSION(1,1);
+ }
+ pCaps->MaxVertexShaderConst = min(D3D8_MAX_VERTEX_SHADER_CONSTANTF, pCaps->MaxVertexShaderConst);
+
TRACE("Returning %p %p\n", This, pCaps);
return hrc;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetDisplayMode(This->WineD3DDevice, 0, (WINED3DDISPLAYMODE *) pMode);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
if (SUCCEEDED(hr)) pMode->Format = d3dformat_from_wined3dformat(pMode->Format);
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetCreationParameters(This->WineD3DDevice, (WINED3DDEVICE_CREATION_PARAMETERS *) pParameters);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
return WINED3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_SetCursorProperties(This->WineD3DDevice,XHotSpot,YHotSpot,pSurface->wineD3DSurface);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DDevice_SetCursorPosition(This->WineD3DDevice, XScreenSpace, YScreenSpace, Flags);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
}
static BOOL WINAPI IDirect3DDevice8Impl_ShowCursor(LPDIRECT3DDEVICE8 iface, BOOL bShow) {
BOOL ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DDevice_ShowCursor(This->WineD3DDevice, bShow);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
localParameters.PresentationInterval = pPresentationParameters->FullScreen_PresentationInterval;
localParameters.AutoRestoreDisplayMode = TRUE;
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hrc = IWineD3DDevice_CreateSwapChain(This->WineD3DDevice, &localParameters,
&object->wineD3DSwapChain, (IUnknown *)object, SURFACE_OPENGL);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
pPresentationParameters->BackBufferWidth = localParameters.BackBufferWidth;
pPresentationParameters->BackBufferHeight = localParameters.BackBufferHeight;
localParameters.PresentationInterval = pPresentationParameters->FullScreen_PresentationInterval;
localParameters.AutoRestoreDisplayMode = TRUE;
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_Reset(This->WineD3DDevice, &localParameters);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
pPresentationParameters->BackBufferWidth = localParameters.BackBufferWidth;
pPresentationParameters->BackBufferHeight = localParameters.BackBufferHeight;
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_Present(This->WineD3DDevice, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
rc = IWineD3DDevice_GetBackBuffer(This->WineD3DDevice, 0, BackBuffer, (WINED3DBACKBUFFER_TYPE) Type, &retSurface);
if (rc == D3D_OK && NULL != retSurface && NULL != ppBackBuffer) {
IWineD3DSurface_GetParent(retSurface, (IUnknown **)ppBackBuffer);
IWineD3DSurface_Release(retSurface);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return rc;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetRasterStatus(This->WineD3DDevice, 0, (WINED3DRASTER_STATUS *) pRasterStatus);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
/* Note: D3DGAMMARAMP is compatible with WINED3DGAMMARAMP */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DDevice_SetGammaRamp(This->WineD3DDevice, 0, Flags, (CONST WINED3DGAMMARAMP *) pRamp);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
}
static void WINAPI IDirect3DDevice8Impl_GetGammaRamp(LPDIRECT3DDEVICE8 iface, D3DGAMMARAMP* pRamp) {
TRACE("(%p) Relay\n", This);
/* Note: D3DGAMMARAMP is compatible with WINED3DGAMMARAMP */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DDevice_GetGammaRamp(This->WineD3DDevice, 0, (WINED3DGAMMARAMP *) pRamp);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
}
static HRESULT WINAPI IDirect3DDevice8Impl_CreateTexture(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, UINT Levels, DWORD Usage,
object->lpVtbl = &Direct3DTexture8_Vtbl;
object->ref = 1;
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hrc = IWineD3DDevice_CreateTexture(This->WineD3DDevice, Width, Height, Levels, Usage & WINED3DUSAGE_MASK,
wined3dformat_from_d3dformat(Format), Pool, &object->wineD3DTexture, (IUnknown *)object);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
if (FAILED(hrc)) {
/* free up object */
object->lpVtbl = &Direct3DVolumeTexture8_Vtbl;
object->ref = 1;
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hrc = IWineD3DDevice_CreateVolumeTexture(This->WineD3DDevice, Width, Height, Depth, Levels,
Usage & WINED3DUSAGE_MASK, wined3dformat_from_d3dformat(Format),
Pool, &object->wineD3DVolumeTexture, (IUnknown *)object);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
if (hrc != D3D_OK) {
object->lpVtbl = &Direct3DCubeTexture8_Vtbl;
object->ref = 1;
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_CreateCubeTexture(This->WineD3DDevice, EdgeLength, Levels, Usage & WINED3DUSAGE_MASK,
wined3dformat_from_d3dformat(Format), Pool, &object->wineD3DCubeTexture, (IUnknown *)object);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
if (hr != D3D_OK){
object->lpVtbl = &Direct3DVertexBuffer8_Vtbl;
object->ref = 1;
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hrc = IWineD3DDevice_CreateVertexBuffer(This->WineD3DDevice, Size, Usage & WINED3DUSAGE_MASK,
0 /* fvf for ddraw only */, (WINED3DPOOL)Pool, &object->wineD3DVertexBuffer, (IUnknown *)object);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
object->fvf = FVF;
if (D3D_OK != hrc) {
object->ref = 1;
object->format = wined3dformat_from_d3dformat(Format);
TRACE("Calling wined3d create index buffer\n");
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hrc = IWineD3DDevice_CreateIndexBuffer(This->WineD3DDevice, Length, Usage & WINED3DUSAGE_MASK,
(WINED3DPOOL)Pool, &object->wineD3DIndexBuffer, (IUnknown *)object);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
if (D3D_OK != hrc) {
return hrc;
}
-static HRESULT IDirect3DDevice8Impl_CreateSurface(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height,
- D3DFORMAT Format, BOOL Lockable, BOOL Discard, UINT Level, IDirect3DSurface8 **ppSurface,
- UINT Usage, D3DPOOL Pool, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality)
-{
+static HRESULT IDirect3DDevice8Impl_CreateSurface(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, D3DFORMAT Format, BOOL Lockable, BOOL Discard, UINT Level, IDirect3DSurface8 **ppSurface,D3DRESOURCETYPE Type, UINT Usage,D3DPOOL Pool, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality) {
HRESULT hrc;
IDirect3DSurface8Impl *object;
IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
TRACE("(%p) : w(%d) h(%d) fmt(%d) surf@%p\n", This, Width, Height, Format, *ppSurface);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hrc = IWineD3DDevice_CreateSurface(This->WineD3DDevice, Width, Height, wined3dformat_from_d3dformat(Format),
- Lockable, Discard, Level, &object->wineD3DSurface, Usage & WINED3DUSAGE_MASK, (WINED3DPOOL)Pool,
- MultiSample, MultisampleQuality, SURFACE_OPENGL, (IUnknown *)object);
- wined3d_mutex_unlock();
-
+ Lockable, Discard, Level, &object->wineD3DSurface, Type, Usage & WINED3DUSAGE_MASK,
+ (WINED3DPOOL)Pool, MultiSample, MultisampleQuality, SURFACE_OPENGL, (IUnknown *)object);
+ LeaveCriticalSection(&d3d8_cs);
if (hrc != D3D_OK || NULL == object->wineD3DSurface) {
/* free up object */
FIXME("(%p) call to IWineD3DDevice_CreateSurface failed\n", This);
HRESULT hr;
TRACE("Relay\n");
- hr = IDirect3DDevice8Impl_CreateSurface(iface, Width, Height, Format, Lockable, FALSE /* Discard */,
- 0 /* Level */, ppSurface, D3DUSAGE_RENDERTARGET, D3DPOOL_DEFAULT, MultiSample, 0);
-
+ hr = IDirect3DDevice8Impl_CreateSurface(iface, Width, Height, Format, Lockable, FALSE /* Discard */, 0 /* Level */ , ppSurface, D3DRTYPE_SURFACE, D3DUSAGE_RENDERTARGET, D3DPOOL_DEFAULT, MultiSample, 0);
return hr;
}
TRACE("Relay\n");
/* TODO: Verify that Discard is false */
- hr = IDirect3DDevice8Impl_CreateSurface(iface, Width, Height, Format, TRUE /* Lockable */, FALSE,
- 0 /* Level */, ppSurface, D3DUSAGE_DEPTHSTENCIL, D3DPOOL_DEFAULT, MultiSample, 0);
-
+ hr = IDirect3DDevice8Impl_CreateSurface(iface, Width, Height, Format, TRUE /* Lockable */, FALSE, 0 /* Level */
+ ,ppSurface, D3DRTYPE_SURFACE, D3DUSAGE_DEPTHSTENCIL,
+ D3DPOOL_DEFAULT, MultiSample, 0);
return hr;
}
HRESULT hr;
TRACE("Relay\n");
- hr = IDirect3DDevice8Impl_CreateSurface(iface, Width, Height, Format, TRUE /* Lockable */, FALSE /* Discard */,
- 0 /* Level */, ppSurface, 0 /* Usage (undefined/none) */, D3DPOOL_SYSTEMMEM, D3DMULTISAMPLE_NONE,
- 0 /* MultisampleQuality */);
-
+ hr = IDirect3DDevice8Impl_CreateSurface(iface, Width, Height, Format, TRUE /* Loackable */ , FALSE /*Discard*/ , 0 /* Level */ , ppSurface,
+ D3DRTYPE_SURFACE, 0 /* Usage (undefined/none) */ , D3DPOOL_SYSTEMMEM, D3DMULTISAMPLE_NONE, 0 /* MultisampleQuality */);
return hr;
}
/* Check that the source texture is in WINED3DPOOL_SYSTEMMEM and the destination texture is in WINED3DPOOL_DEFAULT */
+ memset(&winedesc, 0, sizeof(winedesc));
- wined3d_mutex_lock();
+ winedesc.Format = &srcFormat;
+ winedesc.Width = &srcWidth;
+ winedesc.Height = &srcHeight;
+ winedesc.Size = &srcSize;
+ EnterCriticalSection(&d3d8_cs);
IWineD3DSurface_GetDesc(Source->wineD3DSurface, &winedesc);
- srcFormat = winedesc.format;
- srcWidth = winedesc.width;
- srcHeight = winedesc.height;
- srcSize = winedesc.size;
+ winedesc.Format = &destFormat;
+ winedesc.Width = &destWidth;
+ winedesc.Height = &destHeight;
+ winedesc.Size = NULL;
IWineD3DSurface_GetDesc(Dest->wineD3DSurface, &winedesc);
- destFormat = winedesc.format;
- destWidth = winedesc.width;
- destHeight = winedesc.height;
/* Check that the source and destination formats match */
if (srcFormat != destFormat && WINED3DFMT_UNKNOWN != destFormat) {
WARN("(%p) source %p format must match the dest %p format, returning WINED3DERR_INVALIDCALL\n", iface, pSourceSurface, pDestinationSurface);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
return WINED3DERR_INVALIDCALL;
} else if (WINED3DFMT_UNKNOWN == destFormat) {
TRACE("(%p) : Converting destination surface from WINED3DFMT_UNKNOWN to the source format\n", iface);
}
}
}
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_UpdateTexture(This->WineD3DDevice, ((IDirect3DBaseTexture8Impl *)pSourceTexture)->wineD3DBaseTexture, ((IDirect3DBaseTexture8Impl *)pDestinationTexture)->wineD3DBaseTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetFrontBufferData(This->WineD3DDevice, 0, destSurface->wineD3DSurface);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetDepthStencilSurface(This->WineD3DDevice, &original_ds);
if (hr == WINED3D_OK || hr == WINED3DERR_NOTFOUND)
}
if (original_ds) IWineD3DSurface_Release(original_ds);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
if (ppRenderTarget == NULL) {
return D3DERR_INVALIDCALL;
}
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetRenderTarget(This->WineD3DDevice, 0, &pRenderTarget);
if (hr == D3D_OK && pRenderTarget != NULL) {
FIXME("Call to IWineD3DDevice_GetRenderTarget failed\n");
*ppRenderTarget = NULL;
}
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr=IWineD3DDevice_GetDepthStencilSurface(This->WineD3DDevice,&pZStencilSurface);
if (hr == WINED3D_OK) {
IWineD3DSurface_GetParent(pZStencilSurface,(IUnknown**)ppZStencilSurface);
FIXME("Call to IWineD3DDevice_GetDepthStencilSurface failed with 0x%08x\n", hr);
*ppZStencilSurface = NULL;
}
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_BeginScene(This->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_EndScene(This->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DRECT is compatible with WINED3DRECT */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_Clear(This->WineD3DDevice, Count, (CONST WINED3DRECT*) pRects, Flags, Color, Z, Stencil);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DMATRIX is compatible with WINED3DMATRIX */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_SetTransform(This->WineD3DDevice, State, (CONST WINED3DMATRIX*) lpMatrix);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DMATRIX is compatible with WINED3DMATRIX */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetTransform(This->WineD3DDevice, State, (WINED3DMATRIX*) pMatrix);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DMATRIX is compatible with WINED3DMATRIX */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_MultiplyTransform(This->WineD3DDevice, State, (CONST WINED3DMATRIX*) pMatrix);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DVIEWPORT8 is compatible with WINED3DVIEWPORT */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_SetViewport(This->WineD3DDevice, (const WINED3DVIEWPORT *)pViewport);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DVIEWPORT8 is compatible with WINED3DVIEWPORT */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetViewport(This->WineD3DDevice, (WINED3DVIEWPORT *)pViewport);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DMATERIAL8 is compatible with WINED3DMATERIAL */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_SetMaterial(This->WineD3DDevice, (const WINED3DMATERIAL *)pMaterial);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DMATERIAL8 is compatible with WINED3DMATERIAL */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetMaterial(This->WineD3DDevice, (WINED3DMATERIAL *)pMaterial);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DLIGHT8 is compatible with WINED3DLIGHT */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_SetLight(This->WineD3DDevice, Index, (const WINED3DLIGHT *)pLight);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DLIGHT8 is compatible with WINED3DLIGHT */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetLight(This->WineD3DDevice, Index, (WINED3DLIGHT *)pLight);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_SetLightEnable(This->WineD3DDevice, Index, Enable);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetLightEnable(This->WineD3DDevice, Index, pEnable);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_SetClipPlane(This->WineD3DDevice, Index, pPlane);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetClipPlane(This->WineD3DDevice, Index, pPlane);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_SetRenderState(This->WineD3DDevice, State, Value);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetRenderState(This->WineD3DDevice, State, pValue);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p)\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_BeginStateBlock(This->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
/* Tell wineD3D to endstateblock before anything else (in case we run out
* of memory later and cause locking problems)
*/
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_EndStateBlock(This->WineD3DDevice , &wineD3DStateBlock);
if (hr != D3D_OK) {
WARN("IWineD3DDevice_EndStateBlock returned an error\n");
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
object->wineD3DStateBlock = wineD3DStateBlock;
- *pToken = d3d8_allocate_handle(&This->handle_table, object, D3D8_HANDLE_SB);
- wined3d_mutex_unlock();
+ *pToken = d3d8_allocate_handle(&This->handle_table, object);
+ LeaveCriticalSection(&d3d8_cs);
if (*pToken == D3D8_INVALID_HANDLE)
{
TRACE("(%p) %#x Relay\n", This, Token);
- wined3d_mutex_lock();
- pSB = d3d8_get_object(&This->handle_table, Token - 1, D3D8_HANDLE_SB);
+ EnterCriticalSection(&d3d8_cs);
+ pSB = d3d8_get_object(&This->handle_table, Token - 1);
if (!pSB)
{
WARN("Invalid handle (%#x) passed.\n", Token);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
return D3DERR_INVALIDCALL;
}
hr = IWineD3DStateBlock_Apply(pSB->wineD3DStateBlock);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) %#x Relay\n", This, Token);
- wined3d_mutex_lock();
- pSB = d3d8_get_object(&This->handle_table, Token - 1, D3D8_HANDLE_SB);
+ EnterCriticalSection(&d3d8_cs);
+ pSB = d3d8_get_object(&This->handle_table, Token - 1);
if (!pSB)
{
WARN("Invalid handle (%#x) passed.\n", Token);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
return D3DERR_INVALIDCALL;
}
hr = IWineD3DStateBlock_Capture(pSB->wineD3DStateBlock);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
- pSB = d3d8_free_handle(&This->handle_table, Token - 1, D3D8_HANDLE_SB);
- wined3d_mutex_unlock();
+ EnterCriticalSection(&d3d8_cs);
+ pSB = d3d8_free_handle(&This->handle_table, Token - 1);
+ LeaveCriticalSection(&d3d8_cs);
if (!pSB)
{
object->lpVtbl = &Direct3DStateBlock8_Vtbl;
object->ref = 1;
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_CreateStateBlock(This->WineD3DDevice, (WINED3DSTATEBLOCKTYPE)Type,
&object->wineD3DStateBlock, (IUnknown *)object);
if (FAILED(hr))
{
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
ERR("IWineD3DDevice_CreateStateBlock failed, hr %#x\n", hr);
HeapFree(GetProcessHeap(), 0, object);
return hr;
}
- *handle = d3d8_allocate_handle(&This->handle_table, object, D3D8_HANDLE_SB);
- wined3d_mutex_unlock();
+ *handle = d3d8_allocate_handle(&This->handle_table, object);
+ LeaveCriticalSection(&d3d8_cs);
if (*handle == D3D8_INVALID_HANDLE)
{
HRESULT hr;
TRACE("(%p) Relay\n" , This);
/* FIXME: Verify that D3DCLIPSTATUS8 ~= WINED3DCLIPSTATUS */
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_SetClipStatus(This->WineD3DDevice, (const WINED3DCLIPSTATUS *)pClipStatus);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetClipStatus(This->WineD3DDevice, (WINED3DCLIPSTATUS *)pClipStatus);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
rc = IWineD3DDevice_GetTexture(This->WineD3DDevice, Stage, &retTexture);
if (rc == D3D_OK && NULL != retTexture) {
IWineD3DBaseTexture_GetParent(retTexture, (IUnknown **)ppTexture);
FIXME("Call to get texture (%d) failed (%p)\n", Stage, retTexture);
*ppTexture = NULL;
}
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
return rc;
}
HRESULT hr;
TRACE("(%p) Relay %d %p\n" , This, Stage, pTexture);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_SetTexture(This->WineD3DDevice, Stage,
pTexture==NULL ? NULL : ((IDirect3DBaseTexture8Impl *)pTexture)->wineD3DBaseTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
+
if (l->sampler_state) hr = IWineD3DDevice_GetSamplerState(This->WineD3DDevice, Stage, l->state, pValue);
else hr = IWineD3DDevice_GetTextureStageState(This->WineD3DDevice, Stage, l->state, pValue);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
+
if (l->sampler_state) hr = IWineD3DDevice_SetSamplerState(This->WineD3DDevice, Stage, l->state, Value);
else hr = IWineD3DDevice_SetTextureStageState(This->WineD3DDevice, Stage, l->state, Value);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_ValidateDevice(This->WineD3DDevice, pNumPasses);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_SetPaletteEntries(This->WineD3DDevice, PaletteNumber, pEntries);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetPaletteEntries(This->WineD3DDevice, PaletteNumber, pEntries);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_SetCurrentTexturePalette(This->WineD3DDevice, PaletteNumber);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetCurrentTexturePalette(This->WineD3DDevice, PaletteNumber);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DDevice_SetPrimitiveType(This->WineD3DDevice, PrimitiveType);
hr = IWineD3DDevice_DrawPrimitive(This->WineD3DDevice, StartVertex,
vertex_count_from_primitive_count(PrimitiveType, PrimitiveCount));
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DDevice_SetPrimitiveType(This->WineD3DDevice, PrimitiveType);
hr = IWineD3DDevice_DrawIndexedPrimitive(This->WineD3DDevice, MinVertexIndex, NumVertices,
startIndex, vertex_count_from_primitive_count(PrimitiveType, primCount));
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DDevice_SetPrimitiveType(This->WineD3DDevice, PrimitiveType);
hr = IWineD3DDevice_DrawPrimitiveUP(This->WineD3DDevice,
vertex_count_from_primitive_count(PrimitiveType, PrimitiveCount),
pVertexStreamZeroData, VertexStreamZeroStride);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DDevice_SetPrimitiveType(This->WineD3DDevice, PrimitiveType);
hr = IWineD3DDevice_DrawIndexedPrimitiveUP(This->WineD3DDevice, MinVertexIndex, NumVertexIndices,
vertex_count_from_primitive_count(PrimitiveType, PrimitiveCount), pIndexData,
wined3dformat_from_d3dformat(IndexDataFormat), pVertexStreamZeroData, VertexStreamZeroStride);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
IDirect3DVertexBuffer8Impl *dest = (IDirect3DVertexBuffer8Impl *) pDestBuffer;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_ProcessVertices(This->WineD3DDevice,SrcStartIndex, DestIndex, VertexCount, dest->wineD3DVertexBuffer, NULL, Flags, dest->fvf);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
CopyMemory(object->elements, declaration, object->elements_size);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_CreateVertexDeclaration(This->WineD3DDevice, &object->wined3d_vertex_declaration,
(IUnknown *)object, wined3d_elements, wined3d_element_count);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
HeapFree(GetProcessHeap(), 0, wined3d_elements);
if (FAILED(hr)) {
IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
HRESULT hrc = D3D_OK;
IDirect3DVertexShader8Impl *object;
+ IWineD3DVertexDeclaration *wined3d_vertex_declaration;
const DWORD *token = pDeclaration;
DWORD handle;
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
- handle = d3d8_allocate_handle(&This->handle_table, object, D3D8_HANDLE_VS);
+ EnterCriticalSection(&d3d8_cs);
+ handle = d3d8_allocate_handle(&This->handle_table, object);
if (handle == D3D8_INVALID_HANDLE)
{
ERR("Failed to allocate shader handle\n");
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
IDirect3DVertexDeclaration8_Release(object->vertex_declaration);
HeapFree(GetProcessHeap(), 0, object);
*ppShader = 0;
*ppShader = ((IDirect3DVertexDeclaration8Impl *)object->vertex_declaration)->shader_handle = shader_handle;
}
+ wined3d_vertex_declaration = ((IDirect3DVertexDeclaration8Impl *)object->vertex_declaration)->wined3d_vertex_declaration;
+
if (pFunction)
{
/* Usage is missing ... Use SetRenderState to set the sw vp render state in SetVertexShader */
- hrc = IWineD3DDevice_CreateVertexShader(This->WineD3DDevice, pFunction,
- NULL /* output signature */, &object->wineD3DVertexShader, (IUnknown *)object);
+ hrc = IWineD3DDevice_CreateVertexShader(This->WineD3DDevice, wined3d_vertex_declaration,
+ pFunction, &object->wineD3DVertexShader, (IUnknown *)object);
if (FAILED(hrc))
{
/* free up object */
FIXME("Call to IWineD3DDevice_CreateVertexShader failed\n");
- d3d8_free_handle(&This->handle_table, handle, D3D8_HANDLE_VS);
+ d3d8_free_handle(&This->handle_table, handle);
IDirect3DVertexDeclaration8_Release(object->vertex_declaration);
HeapFree(GetProcessHeap(), 0, object);
*ppShader = 0;
}
}
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
return hrc;
}
if (VS_HIGHESTFIXEDFXF >= pShader) {
TRACE("Setting FVF, %#x\n", pShader);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DDevice_SetVertexDeclaration(This->WineD3DDevice,
IDirect3DDevice8Impl_FindDecl(This, pShader)->wined3d_vertex_declaration);
IWineD3DDevice_SetVertexShader(This->WineD3DDevice, NULL);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return D3D_OK;
}
TRACE("Setting shader\n");
- wined3d_mutex_lock();
- shader = d3d8_get_object(&This->handle_table, pShader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS);
+ EnterCriticalSection(&d3d8_cs);
+ shader = d3d8_get_object(&This->handle_table, pShader - (VS_HIGHESTFIXEDFXF + 1));
if (!shader)
{
WARN("Invalid handle (%#x) passed.\n", pShader);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return D3DERR_INVALIDCALL;
}
hr = IWineD3DDevice_SetVertexDeclaration(This->WineD3DDevice,
((IDirect3DVertexDeclaration8Impl *)shader->vertex_declaration)->wined3d_vertex_declaration);
if (SUCCEEDED(hr)) hr = IWineD3DDevice_SetVertexShader(This->WineD3DDevice, shader->wineD3DVertexShader);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
TRACE("Returning hr %#x\n", hr);
HRESULT hrc;
TRACE("(%p) : Relay device@%p\n", This, This->WineD3DDevice);
+ EnterCriticalSection(&d3d8_cs);
- wined3d_mutex_lock();
hrc = IWineD3DDevice_GetVertexDeclaration(This->WineD3DDevice, &wined3d_declaration);
if (FAILED(hrc))
{
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
WARN("(%p) : Call to IWineD3DDevice_GetVertexDeclaration failed %#x (device %p)\n",
This, hrc, This->WineD3DDevice);
return hrc;
if (!wined3d_declaration)
{
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
*ppShader = 0;
return D3D_OK;
}
hrc = IWineD3DVertexDeclaration_GetParent(wined3d_declaration, (IUnknown **)&d3d8_declaration);
IWineD3DVertexDeclaration_Release(wined3d_declaration);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
if (SUCCEEDED(hrc))
{
*ppShader = ((IDirect3DVertexDeclaration8Impl *)d3d8_declaration)->shader_handle;
TRACE("(%p) : pShader %#x\n", This, pShader);
- wined3d_mutex_lock();
- shader = d3d8_free_handle(&This->handle_table, pShader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS);
+ EnterCriticalSection(&d3d8_cs);
+
+ shader = d3d8_free_handle(&This->handle_table, pShader - (VS_HIGHESTFIXEDFXF + 1));
if (!shader)
{
WARN("Invalid handle (%#x) passed.\n", pShader);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return D3DERR_INVALIDCALL;
}
IWineD3DVertexShader_Release(cur);
}
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
if (IUnknown_Release((IUnknown *)shader))
{
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_SetVertexShaderConstantF(This->WineD3DDevice, Register, pConstantData, ConstantCount);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetVertexShaderConstantF(This->WineD3DDevice, Register, pConstantData, ConstantCount);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) : pVertexShader 0x%08x, pData %p, *pSizeOfData %u\n", This, pVertexShader, pData, *pSizeOfData);
- wined3d_mutex_lock();
- shader = d3d8_get_object(&This->handle_table, pVertexShader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS);
- wined3d_mutex_unlock();
+ EnterCriticalSection(&d3d8_cs);
+ shader = d3d8_get_object(&This->handle_table, pVertexShader - (VS_HIGHESTFIXEDFXF + 1));
+ LeaveCriticalSection(&d3d8_cs);
if (!shader)
{
WARN("Invalid handle (%#x) passed.\n", pVertexShader);
TRACE("(%p) : pVertexShader %#x, pData %p, pSizeOfData %p\n", This, pVertexShader, pData, pSizeOfData);
- wined3d_mutex_lock();
- shader = d3d8_get_object(&This->handle_table, pVertexShader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS);
+ EnterCriticalSection(&d3d8_cs);
+
+ shader = d3d8_get_object(&This->handle_table, pVertexShader - (VS_HIGHESTFIXEDFXF + 1));
if (!shader)
{
WARN("Invalid handle (%#x) passed.\n", pVertexShader);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return D3DERR_INVALIDCALL;
}
if (!shader->wineD3DVertexShader)
{
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
*pSizeOfData = 0;
return D3D_OK;
}
hr = IWineD3DVertexShader_GetFunction(shader->wineD3DVertexShader, pData, pSizeOfData);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
IDirect3DIndexBuffer8Impl *ib = (IDirect3DIndexBuffer8Impl *)pIndexData;
TRACE("(%p) Relay\n", This);
+ EnterCriticalSection(&d3d8_cs);
/* WineD3D takes an INT(due to d3d9), but d3d8 uses UINTs. Do I have to add a check here that
* the UINT doesn't cause an overflow in the INT? It seems rather unlikely because such large
* vertex buffers can't be created to address them with an index that requires the 32nd bit
* (4 Byte minimum vertex size * 2^31-1 -> 8 gb buffer. The index sign would be the least
* problem)
*/
- wined3d_mutex_lock();
IWineD3DDevice_SetBaseVertexIndex(This->WineD3DDevice, baseVertexIndex);
hr = IWineD3DDevice_SetIndices(This->WineD3DDevice,
ib ? ib->wineD3DIndexBuffer : NULL,
ib ? ib->format : WINED3DFMT_UNKNOWN);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
return D3DERR_INVALIDCALL;
}
+ EnterCriticalSection(&d3d8_cs);
/* The case from UINT to INT is safe because d3d8 will never set negative values */
- wined3d_mutex_lock();
IWineD3DDevice_GetBaseVertexIndex(This->WineD3DDevice, (INT *) pBaseVertexIndex);
rc = IWineD3DDevice_GetIndices(This->WineD3DDevice, &retIndexData);
if (SUCCEEDED(rc) && retIndexData) {
if (FAILED(rc)) FIXME("Call to GetIndices failed\n");
*ppIndexData = NULL;
}
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
return rc;
}
object->ref = 1;
object->lpVtbl = &Direct3DPixelShader8_Vtbl;
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_CreatePixelShader(This->WineD3DDevice, pFunction,
NULL, &object->wineD3DPixelShader, (IUnknown *)object);
if (FAILED(hr))
{
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
FIXME("(%p) call to IWineD3DDevice_CreatePixelShader failed\n", This);
HeapFree(GetProcessHeap(), 0 , object);
*ppShader = 0;
return hr;
}
- handle = d3d8_allocate_handle(&This->handle_table, object, D3D8_HANDLE_PS);
- wined3d_mutex_unlock();
-
+ handle = d3d8_allocate_handle(&This->handle_table, object);
+ LeaveCriticalSection(&d3d8_cs);
if (handle == D3D8_INVALID_HANDLE)
{
ERR("Failed to allocate shader handle\n");
TRACE("(%p) : pShader %#x\n", This, pShader);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
if (!pShader)
{
hr = IWineD3DDevice_SetPixelShader(This->WineD3DDevice, NULL);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
- shader = d3d8_get_object(&This->handle_table, pShader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_PS);
+ shader = d3d8_get_object(&This->handle_table, pShader - (VS_HIGHESTFIXEDFXF + 1));
if (!shader)
{
WARN("Invalid handle (%#x) passed.\n", pShader);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
return D3DERR_INVALIDCALL;
}
TRACE("(%p) : Setting shader %p\n", This, shader);
hr = IWineD3DDevice_SetPixelShader(This->WineD3DDevice, shader->wineD3DPixelShader);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hrc = IWineD3DDevice_GetPixelShader(This->WineD3DDevice, &object);
if (D3D_OK == hrc && NULL != object) {
IDirect3DPixelShader8Impl *d3d8_shader;
} else {
*ppShader = 0;
}
- wined3d_mutex_unlock();
TRACE("(%p) : returning %#x\n", This, *ppShader);
-
+ LeaveCriticalSection(&d3d8_cs);
return hrc;
}
TRACE("(%p) : pShader %#x\n", This, pShader);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
- shader = d3d8_free_handle(&This->handle_table, pShader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_PS);
+ shader = d3d8_free_handle(&This->handle_table, pShader - (VS_HIGHESTFIXEDFXF + 1));
if (!shader)
{
WARN("Invalid handle (%#x) passed.\n", pShader);
- wined3d_mutex_unlock();
- return D3D_OK;
+ LeaveCriticalSection(&d3d8_cs);
+ return D3DERR_INVALIDCALL;
}
IWineD3DDevice_GetPixelShader(This->WineD3DDevice, &cur);
IWineD3DPixelShader_Release(cur);
}
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
if (IUnknown_Release((IUnknown *)shader))
{
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_SetPixelShaderConstantF(This->WineD3DDevice, Register, pConstantData, ConstantCount);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_GetPixelShaderConstantF(This->WineD3DDevice, Register, pConstantData, ConstantCount);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) : pPixelShader %#x, pData %p, pSizeOfData %p\n", This, pPixelShader, pData, pSizeOfData);
- wined3d_mutex_lock();
- shader = d3d8_get_object(&This->handle_table, pPixelShader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_PS);
+ EnterCriticalSection(&d3d8_cs);
+ shader = d3d8_get_object(&This->handle_table, pPixelShader - (VS_HIGHESTFIXEDFXF + 1));
if (!shader)
{
WARN("Invalid handle (%#x) passed.\n", pPixelShader);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return D3DERR_INVALIDCALL;
}
hr = IWineD3DPixelShader_GetFunction(shader->wineD3DPixelShader, pData, pSizeOfData);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_DrawRectPatch(This->WineD3DDevice, Handle, pNumSegs, (CONST WINED3DRECTPATCH_INFO *)pRectPatchInfo);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_DrawTriPatch(This->WineD3DDevice, Handle, pNumSegs, (CONST WINED3DTRIPATCH_INFO *)pTriPatchInfo);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_DeletePatch(This->WineD3DDevice, Handle);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DDevice_SetStreamSource(This->WineD3DDevice, StreamNumber,
NULL == pStreamData ? NULL : ((IDirect3DVertexBuffer8Impl *)pStreamData)->wineD3DVertexBuffer,
0/* Offset in bytes */, Stride);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
rc = IWineD3DDevice_GetStreamSource(This->WineD3DDevice, StreamNumber, &retStream, 0 /* Offset in bytes */, pStride);
if (rc == D3D_OK && NULL != retStream) {
IWineD3DBuffer_GetParent(retStream, (IUnknown **)pStream);
}
*pStream = NULL;
}
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
return rc;
}
hr = IDirect3DDevice8Impl_CreateSurface((IDirect3DDevice8 *)This, width, height,
d3dformat_from_wined3dformat(format), lockable, FALSE /* Discard */, level,
- (IDirect3DSurface8 **)&d3d_surface, usage, pool, D3DMULTISAMPLE_NONE, 0 /* MultisampleQuality */);
+ (IDirect3DSurface8 **)&d3d_surface, D3DRTYPE_SURFACE, usage, pool,
+ D3DMULTISAMPLE_NONE, 0 /* MultisampleQuality */);
if (FAILED(hr))
{
ERR("(%p) CreateSurface failed, returning %#x\n", iface, hr);
if (ref == 0) {
TRACE("Releasing wined3d %p\n", This->WineD3D);
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3D_Release(This->WineD3D);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
HeapFree(GetProcessHeap(), 0, This);
}
HRESULT hr;
TRACE("(%p)->(%p)\n", This, pInitializeFunction);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3D_RegisterSoftwareDevice(This->WineD3D, pInitializeFunction);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p)\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3D_GetAdapterCount(This->WineD3D);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
-static HRESULT WINAPI IDirect3D8Impl_GetAdapterIdentifier(LPDIRECT3D8 iface,
- UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER8 *pIdentifier)
-{
+static HRESULT WINAPI IDirect3D8Impl_GetAdapterIdentifier (LPDIRECT3D8 iface,
+ UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER8* pIdentifier) {
IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
WINED3DADAPTER_IDENTIFIER adapter_id;
HRESULT hr;
TRACE("(%p)->(%d,%08x, %p\n", This, Adapter, Flags, pIdentifier);
+ EnterCriticalSection(&d3d8_cs);
+ /* dx8 and dx9 have different structures to be filled in, with incompatible
+ layouts so pass in pointers to the places to be filled via an internal
+ structure */
+ adapter_id.Driver = pIdentifier->Driver;
+ adapter_id.Description = pIdentifier->Description;
+ adapter_id.DeviceName = NULL; /* d3d9 only */
+ adapter_id.DriverVersion = &pIdentifier->DriverVersion;
+ adapter_id.VendorId = &pIdentifier->VendorId;
+ adapter_id.DeviceId = &pIdentifier->DeviceId;
+ adapter_id.SubSysId = &pIdentifier->SubSysId;
+ adapter_id.Revision = &pIdentifier->Revision;
+ adapter_id.DeviceIdentifier = &pIdentifier->DeviceIdentifier;
+ adapter_id.WHQLLevel = &pIdentifier->WHQLLevel;
- adapter_id.driver = pIdentifier->Driver;
- adapter_id.driver_size = sizeof(pIdentifier->Driver);
- adapter_id.description = pIdentifier->Description;
- adapter_id.description_size = sizeof(pIdentifier->Description);
- adapter_id.device_name = NULL; /* d3d9 only */
- adapter_id.device_name_size = 0; /* d3d9 only */
-
- wined3d_mutex_lock();
hr = IWineD3D_GetAdapterIdentifier(This->WineD3D, Adapter, Flags, &adapter_id);
- wined3d_mutex_unlock();
-
- pIdentifier->DriverVersion = adapter_id.driver_version;
- pIdentifier->VendorId = adapter_id.vendor_id;
- pIdentifier->DeviceId = adapter_id.device_id;
- pIdentifier->SubSysId = adapter_id.subsystem_id;
- pIdentifier->Revision = adapter_id.revision;
- memcpy(&pIdentifier->DeviceIdentifier, &adapter_id.device_identifier, sizeof(pIdentifier->DeviceIdentifier));
- pIdentifier->WHQLLevel = adapter_id.whql_level;
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p)->(%d)\n", This, Adapter);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3D_GetAdapterModeCount(This->WineD3D, Adapter, 0 /* format */);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p)->(%d, %d, %p)\n", This, Adapter, Mode, pMode);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3D_EnumAdapterModes(This->WineD3D, Adapter, WINED3DFMT_UNKNOWN, Mode, (WINED3DDISPLAYMODE *) pMode);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
if (SUCCEEDED(hr)) pMode->Format = d3dformat_from_wined3dformat(pMode->Format);
HRESULT hr;
TRACE("(%p)->(%d,%p)\n", This, Adapter, pMode);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3D_GetAdapterDisplayMode(This->WineD3D, Adapter, (WINED3DDISPLAYMODE *) pMode);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
if (SUCCEEDED(hr)) pMode->Format = d3dformat_from_wined3dformat(pMode->Format);
HRESULT hr;
TRACE("(%p)->(%d, %d, %d, %d, %s)\n", This, Adapter, CheckType, DisplayFormat, BackBufferFormat, Windowed ? "true" : "false");
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3D_CheckDeviceType(This->WineD3D, Adapter, CheckType, wined3dformat_from_d3dformat(DisplayFormat),
wined3dformat_from_d3dformat(BackBufferFormat), Windowed);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
WINED3DRESOURCETYPE WineD3DRType;
TRACE("(%p)->(%d, %d, %d, %08x, %d, %d)\n", This, Adapter, DeviceType, AdapterFormat, Usage, RType, CheckFormat);
- if(CheckFormat == D3DFMT_R8G8B8)
- {
- /* See comment in dlls/d3d9/directx.c, IDirect3D9Impl_CheckDeviceFormat for details */
- WARN("D3DFMT_R8G8B8 is not available on windows, returning D3DERR_NOTAVAILABLE\n");
- return D3DERR_NOTAVAILABLE;
- }
-
-
switch(RType) {
case D3DRTYPE_VERTEXBUFFER:
case D3DRTYPE_INDEXBUFFER:
break;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3D_CheckDeviceFormat(This->WineD3D, Adapter, DeviceType, wined3dformat_from_d3dformat(AdapterFormat),
Usage, WineD3DRType, wined3dformat_from_d3dformat(CheckFormat), SURFACE_OPENGL);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
-static HRESULT WINAPI IDirect3D8Impl_CheckDeviceMultiSampleType(IDirect3D8 *iface, UINT Adapter,
- D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType)
-{
+static HRESULT WINAPI IDirect3D8Impl_CheckDeviceMultiSampleType(LPDIRECT3D8 iface,
+ UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat,
+ BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType) {
IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
HRESULT hr;
TRACE("(%p)-<(%d, %d, %d, %s, %d)\n", This, Adapter, DeviceType, SurfaceFormat, Windowed ? "true" : "false", MultiSampleType);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3D_CheckDeviceMultiSampleType(This->WineD3D, Adapter, DeviceType,
wined3dformat_from_d3dformat(SurfaceFormat), Windowed, (WINED3DMULTISAMPLE_TYPE) MultiSampleType, NULL);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
-static HRESULT WINAPI IDirect3D8Impl_CheckDepthStencilMatch(IDirect3D8 *iface, UINT Adapter, D3DDEVTYPE DeviceType,
- D3DFORMAT AdapterFormat, D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat)
-{
+static HRESULT WINAPI IDirect3D8Impl_CheckDepthStencilMatch(LPDIRECT3D8 iface,
+ UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat,
+ D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat) {
IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
HRESULT hr;
TRACE("(%p)-<(%d, %d, %d, %d, %d)\n", This, Adapter, DeviceType, AdapterFormat, RenderTargetFormat, DepthStencilFormat);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3D_CheckDepthStencilMatch(This->WineD3D, Adapter, DeviceType,
wined3dformat_from_d3dformat(AdapterFormat), wined3dformat_from_d3dformat(RenderTargetFormat),
wined3dformat_from_d3dformat(DepthStencilFormat));
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
-void fixup_caps(WINED3DCAPS *caps)
-{
- /* D3D8 doesn't support SM 2.0 or higher, so clamp to 1.x */
- if (caps->PixelShaderVersion > D3DPS_VERSION(1,4)) {
- caps->PixelShaderVersion = D3DPS_VERSION(1,4);
- }
- if (caps->VertexShaderVersion > D3DVS_VERSION(1,1)) {
- caps->VertexShaderVersion = D3DVS_VERSION(1,1);
- }
- caps->MaxVertexShaderConst = min(D3D8_MAX_VERTEX_SHADER_CONSTANTF, caps->MaxVertexShaderConst);
-
- caps->StencilCaps &= ~WINED3DSTENCILCAPS_TWOSIDED;
-}
-
static HRESULT WINAPI IDirect3D8Impl_GetDeviceCaps(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS8* pCaps) {
IDirect3D8Impl *This = (IDirect3D8Impl *)iface;
HRESULT hrc = D3D_OK;
if(pWineCaps == NULL){
return D3DERR_INVALIDCALL; /*well this is what MSDN says to return*/
}
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hrc = IWineD3D_GetDeviceCaps(This->WineD3D, Adapter, DeviceType, pWineCaps);
- wined3d_mutex_unlock();
-
- fixup_caps(pWineCaps);
+ LeaveCriticalSection(&d3d8_cs);
WINECAPSTOD3D8CAPS(pCaps, pWineCaps)
HeapFree(GetProcessHeap(), 0, pWineCaps);
+ /* D3D8 doesn't support SM 2.0 or higher, so clamp to 1.x */
+ if(pCaps->PixelShaderVersion > D3DPS_VERSION(1,4)){
+ pCaps->PixelShaderVersion = D3DPS_VERSION(1,4);
+ }
+ if(pCaps->VertexShaderVersion > D3DVS_VERSION(1,1)){
+ pCaps->VertexShaderVersion = D3DVS_VERSION(1,1);
+ }
+ pCaps->MaxVertexShaderConst = min(D3D8_MAX_VERTEX_SHADER_CONSTANTF, pCaps->MaxVertexShaderConst);
+
TRACE("(%p) returning %p\n", This, pCaps);
return hrc;
}
HMONITOR ret;
TRACE("(%p)->(%d)\n", This, Adapter);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3D_GetAdapterMonitor(This->WineD3D, Adapter);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
*ppReturnedDeviceInterface = (IDirect3DDevice8 *)object;
/* Allocate an associated WineD3DDevice object */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3D_CreateDevice(This->WineD3D, Adapter, DeviceType, hFocusWindow, BehaviourFlags,
(IUnknown *)object, (IWineD3DDeviceParent *)&object->device_parent_vtbl, &object->WineD3DDevice);
if (hr != D3D_OK) {
HeapFree(GetProcessHeap(), 0, object);
*ppReturnedDeviceInterface = NULL;
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
}
hr = IWineD3DDevice_Init3D(object->WineD3DDevice, &localParameters);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
pPresentationParameters->BackBufferWidth = localParameters.BackBufferWidth;
pPresentationParameters->BackBufferHeight = localParameters.BackBufferHeight;
object->decls = HeapAlloc(GetProcessHeap(), 0, object->declArraySize * sizeof(*object->decls));
if(!object->decls) {
ERR("Out of memory\n");
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DDevice_Release(object->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
HeapFree(GetProcessHeap(), 0, object);
*ppReturnedDeviceInterface = NULL;
hr = E_OUTOFMEMORY;
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DBuffer_Release(This->wineD3DIndexBuffer);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
IUnknown_Release(This->parentDevice);
HeapFree(GetProcessHeap(), 0, This);
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DBuffer_GetDevice(This->wineD3DIndexBuffer, &wined3d_device);
if (SUCCEEDED(hr))
{
IWineD3DDevice_GetParent(wined3d_device, (IUnknown **)ppDevice);
IWineD3DDevice_Release(wined3d_device);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DBuffer_SetPrivateData(This->wineD3DIndexBuffer, refguid, pData, SizeOfData, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DBuffer_GetPrivateData(This->wineD3DIndexBuffer, refguid, pData, pSizeOfData);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DBuffer_FreePrivateData(This->wineD3DIndexBuffer, refguid);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DBuffer_SetPriority(This->wineD3DIndexBuffer, PriorityNew);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DBuffer_GetPriority(This->wineD3DIndexBuffer);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
IDirect3DIndexBuffer8Impl *This = (IDirect3DIndexBuffer8Impl *)iface;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DBuffer_PreLoad(This->wineD3DIndexBuffer);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
}
static D3DRESOURCETYPE WINAPI IDirect3DIndexBuffer8Impl_GetType(LPDIRECT3DINDEXBUFFER8 iface) {
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DBuffer_Map(This->wineD3DIndexBuffer, OffsetToLock, SizeToLock, ppbData, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DBuffer_Unmap(This->wineD3DIndexBuffer);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
WINED3DBUFFER_DESC desc;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DBuffer_GetDesc(This->wineD3DIndexBuffer, &desc);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
if (SUCCEEDED(hr)) {
pDesc->Format = d3dformat_from_wined3dformat(This->format);
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DPixelShader_Release(This->wineD3DPixelShader);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
HeapFree(GetProcessHeap(), 0, This);
}
return ref;
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DStateBlock_Release(This->wineD3DStateBlock);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
HeapFree(GetProcessHeap(), 0, This);
}
return ref;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
+
hr = IWineD3DStateBlock_GetDevice(This->wineD3DStateBlock, &wined3d_device);
if (SUCCEEDED(hr))
{
IWineD3DDevice_GetParent(wined3d_device, (IUnknown **)ppDevice);
IWineD3DDevice_Release(wined3d_device);
}
- wined3d_mutex_unlock();
+
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
+
hr = IWineD3DStateBlock_Capture(This->wineD3DStateBlock);
- wined3d_mutex_unlock();
+
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
+
hr = IWineD3DStateBlock_Apply(This->wineD3DStateBlock);
- wined3d_mutex_unlock();
+
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
if (This->parentDevice) IUnknown_Release(This->parentDevice);
/* Implicit surfaces are destroyed with the device, not if refcount reaches 0. */
if (!This->isImplicit) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DSurface_Release(This->wineD3DSurface);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
HeapFree(GetProcessHeap(), 0, This);
}
}
HRESULT hr;
TRACE("(%p)->(%p)\n", This, ppDevice);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DSurface_GetDevice(This->wineD3DSurface, &wined3d_device);
if (SUCCEEDED(hr))
{
IWineD3DDevice_GetParent(wined3d_device, (IUnknown **)ppDevice);
IWineD3DDevice_Release(wined3d_device);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DSurface_SetPrivateData(This->wineD3DSurface, refguid, pData, SizeOfData, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DSurface_GetPrivateData(This->wineD3DSurface, refguid, pData, pSizeOfData);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DSurface_FreePrivateData(This->wineD3DSurface, refguid);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ /* As d3d8 and d3d9 structures differ, pass in ptrs to where data needs to go */
+ memset(&wined3ddesc, 0, sizeof(wined3ddesc));
+ wined3ddesc.Format = (WINED3DFORMAT *)&pDesc->Format;
+ wined3ddesc.Type = (WINED3DRESOURCETYPE *)&pDesc->Type;
+ wined3ddesc.Usage = &pDesc->Usage;
+ wined3ddesc.Pool = (WINED3DPOOL *) &pDesc->Pool;
+ wined3ddesc.Size = &pDesc->Size;
+ wined3ddesc.MultiSampleType = (WINED3DMULTISAMPLE_TYPE *) &pDesc->MultiSampleType;
+ wined3ddesc.Width = &pDesc->Width;
+ wined3ddesc.Height = &pDesc->Height;
+
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DSurface_GetDesc(This->wineD3DSurface, &wined3ddesc);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
- if (SUCCEEDED(hr))
- {
- pDesc->Format = d3dformat_from_wined3dformat(wined3ddesc.format);
- pDesc->Type = wined3ddesc.resource_type;
- pDesc->Usage = wined3ddesc.usage;
- pDesc->Pool = wined3ddesc.pool;
- pDesc->Size = wined3ddesc.size;
- pDesc->MultiSampleType = wined3ddesc.multisample_type;
- pDesc->Width = wined3ddesc.width;
- pDesc->Height = wined3ddesc.height;
- }
+ if (SUCCEEDED(hr)) pDesc->Format = d3dformat_from_wined3dformat(pDesc->Format);
return hr;
}
TRACE("(%p) Relay\n", This);
TRACE("(%p) calling IWineD3DSurface_LockRect %p %p %p %d\n", This, This->wineD3DSurface, pLockedRect, pRect, Flags);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
if (pRect) {
D3DSURFACE_DESC desc;
IDirect3DSurface8_GetDesc(iface, &desc);
|| (pRect->right > desc.Width)
|| (pRect->bottom > desc.Height)) {
WARN("Trying to lock an invalid rectangle, returning D3DERR_INVALIDCALL\n");
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return D3DERR_INVALIDCALL;
}
}
hr = IWineD3DSurface_LockRect(This->wineD3DSurface, (WINED3DLOCKED_RECT *) pLockedRect, pRect, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DSurface_UnlockRect(This->wineD3DSurface);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
switch(hr)
{
case WINEDDERR_NOTLOCKED: return D3DERR_INVALIDCALL;
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DSwapChain_Destroy(This->wineD3DSwapChain, D3D8CB_DestroyRenderTarget);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
if (This->parentDevice) IUnknown_Release(This->parentDevice);
HeapFree(GetProcessHeap(), 0, This);
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DSwapChain_Present(This->wineD3DSwapChain, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion, 0);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hrc = IWineD3DSwapChain_GetBackBuffer(This->wineD3DSwapChain, iBackBuffer, (WINED3DBACKBUFFER_TYPE )Type, &mySurface);
if (hrc == D3D_OK && NULL != mySurface) {
IWineD3DSurface_GetParent(mySurface, (IUnknown **)ppBackBuffer);
IWineD3DSurface_Release(mySurface);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hrc;
}
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DTexture_Destroy(This->wineD3DTexture, D3D8CB_DestroySurface);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
IUnknown_Release(This->parentDevice);
HeapFree(GetProcessHeap(), 0, This);
}
IWineD3DDevice *wined3d_device;
HRESULT hr;
TRACE("(%p) Relay\n", This);
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DTexture_GetDevice(This->wineD3DTexture, &wined3d_device);
if (SUCCEEDED(hr))
{
IWineD3DDevice_GetParent(wined3d_device, (IUnknown **)ppDevice);
IWineD3DDevice_Release(wined3d_device);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DTexture_SetPrivateData(This->wineD3DTexture, refguid, pData, SizeOfData, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DTexture_GetPrivateData(This->wineD3DTexture, refguid, pData, pSizeOfData);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DTexture_FreePrivateData(This->wineD3DTexture, refguid);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DTexture_SetPriority(This->wineD3DTexture, PriorityNew);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DTexture_GetPriority(This->wineD3DTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
IDirect3DTexture8Impl *This = (IDirect3DTexture8Impl *)iface;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DTexture_PreLoad(This->wineD3DTexture);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
}
static D3DRESOURCETYPE WINAPI IDirect3DTexture8Impl_GetType(LPDIRECT3DTEXTURE8 iface) {
D3DRESOURCETYPE type;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
type = IWineD3DTexture_GetType(This->wineD3DTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return type;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DTexture_SetLOD(This->wineD3DTexture, LODNew);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DTexture_GetLOD(This->wineD3DTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DTexture_GetLevelCount(This->wineD3DTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
WINED3DSURFACE_DESC wined3ddesc;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ /* As d3d8 and d3d9 structures differ, pass in ptrs to where data needs to go */
+ memset(&wined3ddesc, 0, sizeof(wined3ddesc));
+ wined3ddesc.Format = (WINED3DFORMAT *)&pDesc->Format;
+ wined3ddesc.Type = (WINED3DRESOURCETYPE *)&pDesc->Type;
+ wined3ddesc.Usage = &pDesc->Usage;
+ wined3ddesc.Pool = (WINED3DPOOL *) &pDesc->Pool;
+ wined3ddesc.Size = &pDesc->Size;
+ wined3ddesc.MultiSampleType = (WINED3DMULTISAMPLE_TYPE *) &pDesc->MultiSampleType;
+ wined3ddesc.Width = &pDesc->Width;
+ wined3ddesc.Height = &pDesc->Height;
+
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DTexture_GetLevelDesc(This->wineD3DTexture, Level, &wined3ddesc);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
- if (SUCCEEDED(hr))
- {
- pDesc->Format = d3dformat_from_wined3dformat(wined3ddesc.format);
- pDesc->Type = wined3ddesc.resource_type;
- pDesc->Usage = wined3ddesc.usage;
- pDesc->Pool = wined3ddesc.pool;
- pDesc->Size = wined3ddesc.size;
- pDesc->MultiSampleType = wined3ddesc.multisample_type;
- pDesc->Width = wined3ddesc.width;
- pDesc->Height = wined3ddesc.height;
- }
+ if (SUCCEEDED(hr)) pDesc->Format = d3dformat_from_wined3dformat(pDesc->Format);
return hr;
}
IWineD3DSurface *mySurface = NULL;
TRACE("(%p) Relay\n", This);
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hrc = IWineD3DTexture_GetSurfaceLevel(This->wineD3DTexture, Level, &mySurface);
if (hrc == D3D_OK && NULL != ppSurfaceLevel) {
IWineD3DSurface_GetParent(mySurface, (IUnknown **)ppSurfaceLevel);
IWineD3DSurface_Release(mySurface);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hrc;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DTexture_LockRect(This->wineD3DTexture, Level, (WINED3DLOCKED_RECT *) pLockedRect, pRect, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DTexture_UnlockRect(This->wineD3DTexture, Level);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DTexture_AddDirtyRect(This->wineD3DTexture, pDirtyRect);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DBuffer_Release(This->wineD3DVertexBuffer);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
IUnknown_Release(This->parentDevice);
HeapFree(GetProcessHeap(), 0, This);
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DBuffer_GetDevice(This->wineD3DVertexBuffer, &wined3d_device);
if (SUCCEEDED(hr))
{
IWineD3DDevice_GetParent(wined3d_device, (IUnknown **)ppDevice);
IWineD3DDevice_Release(wined3d_device);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DBuffer_SetPrivateData(This->wineD3DVertexBuffer, refguid, pData, SizeOfData, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DBuffer_GetPrivateData(This->wineD3DVertexBuffer, refguid, pData, pSizeOfData);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DBuffer_FreePrivateData(This->wineD3DVertexBuffer, refguid);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DBuffer_SetPriority(This->wineD3DVertexBuffer, PriorityNew);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DBuffer_GetPriority(This->wineD3DVertexBuffer);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
IDirect3DVertexBuffer8Impl *This = (IDirect3DVertexBuffer8Impl *)iface;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DBuffer_PreLoad(This->wineD3DVertexBuffer);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
}
static D3DRESOURCETYPE WINAPI IDirect3DVertexBuffer8Impl_GetType(LPDIRECT3DVERTEXBUFFER8 iface) {
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DBuffer_Map(This->wineD3DVertexBuffer, OffsetToLock, SizeToLock, ppbData, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DBuffer_Unmap(This->wineD3DVertexBuffer);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
WINED3DBUFFER_DESC desc;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DBuffer_GetDesc(This->wineD3DVertexBuffer, &desc);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
if (SUCCEEDED(hr)) {
pDesc->Type = D3DRTYPE_VERTEXBUFFER;
TRACE("(%p) : Releasing to %d\n", This, ref_count);
if (!ref_count) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DVertexDeclaration_Release(This->wined3d_vertex_declaration);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
HeapFree(GetProcessHeap(), 0, This->elements);
HeapFree(GetProcessHeap(), 0, This);
}
IDirect3DVertexDeclaration8_Release(This->vertex_declaration);
if (This->wineD3DVertexShader)
{
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DVertexShader_Release(This->wineD3DVertexShader);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
}
HeapFree(GetProcessHeap(), 0, This);
}
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DVolume_Release(This->wineD3DVolume);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
HeapFree(GetProcessHeap(), 0, This);
}
IDirect3DVolume8Impl *This = (IDirect3DVolume8Impl *)iface;
IWineD3DDevice *myDevice = NULL;
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DVolume_GetDevice(This->wineD3DVolume, &myDevice);
IWineD3DDevice_GetParent(myDevice, (IUnknown **)ppDevice);
IWineD3DDevice_Release(myDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return D3D_OK;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DVolume_SetPrivateData(This->wineD3DVolume, refguid, pData, SizeOfData, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DVolume_GetPrivateData(This->wineD3DVolume, refguid, pData, pSizeOfData);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DVolume_FreePrivateData(This->wineD3DVolume, refguid);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ /* As d3d8 and d3d9 structures differ, pass in ptrs to where data needs to go */
+ wined3ddesc.Format = (WINED3DFORMAT *)&pDesc->Format;
+ wined3ddesc.Type = (WINED3DRESOURCETYPE *)&pDesc->Type;
+ wined3ddesc.Usage = &pDesc->Usage;
+ wined3ddesc.Pool = (WINED3DPOOL *) &pDesc->Pool;
+ wined3ddesc.Size = &pDesc->Size;
+ wined3ddesc.Width = &pDesc->Width;
+ wined3ddesc.Height = &pDesc->Height;
+ wined3ddesc.Depth = &pDesc->Depth;
+
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DVolume_GetDesc(This->wineD3DVolume, &wined3ddesc);
- wined3d_mutex_unlock();
-
- if (SUCCEEDED(hr))
- {
- pDesc->Format = d3dformat_from_wined3dformat(wined3ddesc.Format);
- pDesc->Type = wined3ddesc.Type;
- pDesc->Usage = wined3ddesc.Usage;
- pDesc->Pool = wined3ddesc.Pool;
- pDesc->Size = wined3ddesc.Size;
- pDesc->Width = wined3ddesc.Width;
- pDesc->Height = wined3ddesc.Height;
- pDesc->Depth = wined3ddesc.Depth;
- }
+ LeaveCriticalSection(&d3d8_cs);
+
+ if (SUCCEEDED(hr)) pDesc->Format = d3dformat_from_wined3dformat(pDesc->Format);
return hr;
}
HRESULT hr;
TRACE("(%p) relay %p %p %p %d\n", This, This->wineD3DVolume, pLockedVolume, pBox, Flags);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DVolume_LockBox(This->wineD3DVolume, (WINED3DLOCKED_BOX *) pLockedVolume, (CONST WINED3DBOX *) pBox, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) relay %p\n", This, This->wineD3DVolume);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DVolume_UnlockBox(This->wineD3DVolume);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DVolumeTexture_Destroy(This->wineD3DVolumeTexture, D3D8CB_DestroyVolume);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
IUnknown_Release(This->parentDevice);
HeapFree(GetProcessHeap(), 0, This);
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DVolumeTexture_GetDevice(This->wineD3DVolumeTexture, &wined3d_device);
if (SUCCEEDED(hr))
{
IWineD3DDevice_GetParent(wined3d_device, (IUnknown **)ppDevice);
IWineD3DDevice_Release(wined3d_device);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DVolumeTexture_SetPrivateData(This->wineD3DVolumeTexture, refguid, pData, SizeOfData, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DVolumeTexture_GetPrivateData(This->wineD3DVolumeTexture, refguid, pData, pSizeOfData);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DVolumeTexture_FreePrivateData(This->wineD3DVolumeTexture, refguid);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DVolumeTexture_SetPriority(This->wineD3DVolumeTexture, PriorityNew);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DVolumeTexture_GetPriority(This->wineD3DVolumeTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
IDirect3DVolumeTexture8Impl *This = (IDirect3DVolumeTexture8Impl *)iface;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
IWineD3DVolumeTexture_PreLoad(This->wineD3DVolumeTexture);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
}
static D3DRESOURCETYPE WINAPI IDirect3DVolumeTexture8Impl_GetType(LPDIRECT3DVOLUMETEXTURE8 iface) {
D3DRESOURCETYPE type;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
type = IWineD3DVolumeTexture_GetType(This->wineD3DVolumeTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return type;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DVolumeTexture_SetLOD(This->wineD3DVolumeTexture, LODNew);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DVolumeTexture_GetLOD(This->wineD3DVolumeTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
ret = IWineD3DVolumeTexture_GetLevelCount(This->wineD3DVolumeTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return ret;
}
static HRESULT WINAPI IDirect3DVolumeTexture8Impl_GetLevelDesc(LPDIRECT3DVOLUMETEXTURE8 iface, UINT Level, D3DVOLUME_DESC* pDesc) {
IDirect3DVolumeTexture8Impl *This = (IDirect3DVolumeTexture8Impl *)iface;
WINED3DVOLUME_DESC wined3ddesc;
+ UINT tmpInt = -1;
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ /* As d3d8 and d3d8 structures differ, pass in ptrs to where data needs to go */
+ wined3ddesc.Format = (WINED3DFORMAT *)&pDesc->Format;
+ wined3ddesc.Type = (WINED3DRESOURCETYPE *)&pDesc->Type;
+ wined3ddesc.Usage = &pDesc->Usage;
+ wined3ddesc.Pool = (WINED3DPOOL *) &pDesc->Pool;
+ wined3ddesc.Size = &tmpInt;
+ wined3ddesc.Width = &pDesc->Width;
+ wined3ddesc.Height = &pDesc->Height;
+ wined3ddesc.Depth = &pDesc->Depth;
+
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DVolumeTexture_GetLevelDesc(This->wineD3DVolumeTexture, Level, &wined3ddesc);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d8_cs);
- if (SUCCEEDED(hr))
- {
- pDesc->Format = d3dformat_from_wined3dformat(wined3ddesc.Format);
- pDesc->Type = wined3ddesc.Type;
- pDesc->Usage = wined3ddesc.Usage;
- pDesc->Pool = wined3ddesc.Pool;
- pDesc->Size = wined3ddesc.Size;
- pDesc->Width = wined3ddesc.Width;
- pDesc->Height = wined3ddesc.Height;
- pDesc->Depth = wined3ddesc.Depth;
- }
+ if (SUCCEEDED(hr)) pDesc->Format = d3dformat_from_wined3dformat(pDesc->Format);
return hr;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hrc = IWineD3DVolumeTexture_GetVolumeLevel(This->wineD3DVolumeTexture, Level, &myVolume);
if (hrc == D3D_OK && NULL != ppVolumeLevel) {
IWineD3DVolumeTexture_GetParent(myVolume, (IUnknown **)ppVolumeLevel);
IWineD3DVolumeTexture_Release(myVolume);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hrc;
}
HRESULT hr;
TRACE("(%p) Relay %p %p %p %d\n", This, This->wineD3DVolumeTexture, pLockedVolume, pBox,Flags);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DVolumeTexture_LockBox(This->wineD3DVolumeTexture, Level, (WINED3DLOCKED_BOX *) pLockedVolume, (CONST WINED3DBOX *) pBox, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay %p %d\n", This, This->wineD3DVolumeTexture, Level);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DVolumeTexture_UnlockBox(This->wineD3DVolumeTexture, Level);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d8_cs);
hr = IWineD3DVolumeTexture_AddDirtyBox(This->wineD3DVolumeTexture, (CONST WINED3DBOX *) pDirtyBox);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d8_cs);
return hr;
}
if (ref == 0) {
TRACE("Releasing child %p\n", This->wineD3DCubeTexture);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DCubeTexture_Destroy(This->wineD3DCubeTexture, D3D9CB_DestroySurface);
IDirect3DDevice9Ex_Release(This->parentDevice);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
HeapFree(GetProcessHeap(), 0, This);
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DCubeTexture_GetDevice(This->wineD3DCubeTexture, &wined3d_device);
if (SUCCEEDED(hr))
{
IWineD3DDevice_GetParent(wined3d_device, (IUnknown **)ppDevice);
IWineD3DDevice_Release(wined3d_device);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DCubeTexture_SetPrivateData(This->wineD3DCubeTexture,refguid,pData,SizeOfData,Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DCubeTexture_GetPrivateData(This->wineD3DCubeTexture,refguid,pData,pSizeOfData);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DCubeTexture_FreePrivateData(This->wineD3DCubeTexture,refguid);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DCubeTexture_SetPriority(This->wineD3DCubeTexture, PriorityNew);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DCubeTexture_GetPriority(This->wineD3DCubeTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DCubeTexture_PreLoad(This->wineD3DCubeTexture);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
}
static D3DRESOURCETYPE WINAPI IDirect3DCubeTexture9Impl_GetType(LPDIRECT3DCUBETEXTURE9 iface) {
D3DRESOURCETYPE ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DCubeTexture_GetType(This->wineD3DCubeTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DCubeTexture_SetLOD(This->wineD3DCubeTexture, LODNew);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DCubeTexture_GetLOD(This->wineD3DCubeTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DCubeTexture_GetLevelCount(This->wineD3DCubeTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DCubeTexture_SetAutoGenFilterType(This->wineD3DCubeTexture, (WINED3DTEXTUREFILTERTYPE) FilterType);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
D3DTEXTUREFILTERTYPE ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = (D3DTEXTUREFILTERTYPE) IWineD3DCubeTexture_GetAutoGenFilterType(This->wineD3DCubeTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DCubeTexture_GenerateMipSubLevels(This->wineD3DCubeTexture);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
}
/* IDirect3DCubeTexture9 Interface follow: */
static HRESULT WINAPI IDirect3DCubeTexture9Impl_GetLevelDesc(LPDIRECT3DCUBETEXTURE9 iface, UINT Level, D3DSURFACE_DESC* pDesc) {
IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl *)iface;
- WINED3DSURFACE_DESC wined3ddesc;
+ WINED3DSURFACE_DESC wined3ddesc;
+ UINT tmpInt = -1;
+ WINED3DFORMAT format;
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ /* As d3d8 and d3d9 structures differ, pass in ptrs to where data needs to go */
+ wined3ddesc.Format = &format;
+ wined3ddesc.Type = (WINED3DRESOURCETYPE *) &pDesc->Type;
+ wined3ddesc.Usage = &pDesc->Usage;
+ wined3ddesc.Pool = (WINED3DPOOL *) &pDesc->Pool;
+ wined3ddesc.Size = &tmpInt;
+ wined3ddesc.MultiSampleType = (WINED3DMULTISAMPLE_TYPE *) &pDesc->MultiSampleType;
+ wined3ddesc.MultiSampleQuality = &pDesc->MultiSampleQuality;
+ wined3ddesc.Width = &pDesc->Width;
+ wined3ddesc.Height = &pDesc->Height;
+
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DCubeTexture_GetLevelDesc(This->wineD3DCubeTexture, Level, &wined3ddesc);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
- if (SUCCEEDED(hr))
- {
- pDesc->Format = d3dformat_from_wined3dformat(wined3ddesc.format);
- pDesc->Type = wined3ddesc.resource_type;
- pDesc->Usage = wined3ddesc.usage;
- pDesc->Pool = wined3ddesc.pool;
- pDesc->MultiSampleType = wined3ddesc.multisample_type;
- pDesc->MultiSampleQuality = wined3ddesc.multisample_quality;
- pDesc->Width = wined3ddesc.width;
- pDesc->Height = wined3ddesc.height;
- }
+ if (SUCCEEDED(hr)) pDesc->Format = d3dformat_from_wined3dformat(format);
return hr;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DCubeTexture_GetCubeMapSurface(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES) FaceType, Level, &mySurface);
if (hrc == D3D_OK && NULL != ppCubeMapSurface) {
IWineD3DCubeTexture_GetParent(mySurface, (IUnknown **)ppCubeMapSurface);
IWineD3DCubeTexture_Release(mySurface);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hrc;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DCubeTexture_LockRect(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES) FaceType, Level, (WINED3DLOCKED_RECT *) pLockedRect, pRect, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DCubeTexture_UnlockRect(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES) FaceType, Level);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DCubeTexture_AddDirtyRect(This->wineD3DCubeTexture, (WINED3DCUBEMAP_FACES) FaceType, pDirtyRect);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
}
object->lpVtbl = &Direct3DCubeTexture9_Vtbl;
object->ref = 1;
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_CreateCubeTexture(This->WineD3DDevice, EdgeLength, Levels, Usage,
wined3dformat_from_d3dformat(Format), Pool, &object->wineD3DCubeTexture, (IUnknown *)object);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
if (hr != D3D_OK){
#include "initguid.h"
#include "d3d9_private.h"
+static CRITICAL_SECTION_DEBUG d3d9_cs_debug =
+{
+ 0, 0, &d3d9_cs,
+ { &d3d9_cs_debug.ProcessLocksList,
+ &d3d9_cs_debug.ProcessLocksList },
+ 0, 0, { (DWORD_PTR)(__FILE__ ": d3d9_cs") }
+};
+CRITICAL_SECTION d3d9_cs = { &d3d9_cs_debug, -1, 0, 0, 0, 0 };
+
WINE_DEFAULT_DEBUG_CHANNEL(d3d9);
static int D3DPERF_event_level = 0;
object->lpVtbl = &Direct3D9_Vtbl;
object->ref = 1;
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
object->WineD3D = WineDirect3DCreate(9, (IUnknown *)object);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
TRACE("SDKVersion = %x, Created Direct3D object @ %p, WineObj @ %p\n", SDKVersion, object, object->WineD3D);
*
* Copyright 2002-2003 Jason Edmeades
* Copyright 2002-2003 Raphael Junqueira
- * Copyright 2005 Oliver Stieber
+ * Copyright 2005 Oliver Stieber
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
extern HRESULT vdecl_convert_fvf(
DWORD FVF,
D3DVERTEXELEMENT9** ppVertexElements);
+extern CRITICAL_SECTION d3d9_cs;
D3DFORMAT d3dformat_from_wined3dformat(WINED3DFORMAT format);
WINED3DFORMAT wined3dformat_from_d3dformat(D3DFORMAT format);
/* IDirect3DResource9 fields */
IWineD3DBaseTexture *wineD3DBaseTexture;
+
} IDirect3DBaseTexture9Impl;
/* --------------------- */
unsigned i;
This->inDestruction = TRUE;
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
for(i = 0; i < This->numConvertedDecls; i++) {
/* Unless Wine is buggy or the app has a bug the refcount will be 0, because decls hold a reference to the
* device
IWineD3DDevice_Uninit3D(This->WineD3DDevice, D3D9CB_DestroyDepthStencilSurface, D3D9CB_DestroySwapChain);
IWineD3DDevice_Release(This->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
HeapFree(GetProcessHeap(), 0, This);
}
return ref;
HRESULT hr;
TRACE("(%p)\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_TestCooperativeLevel(This->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
if(hr == WINED3D_OK && This->notreset) {
TRACE("D3D9 Device is marked not reset\n");
hr = D3DERR_DEVICENOTRESET;
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetAvailableTextureMem(This->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) : Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_EvictManagedResources(This->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetDirect3D(This->WineD3DDevice, &pWineD3D);
if (hr == D3D_OK && pWineD3D != NULL)
{
*ppD3D9 = NULL;
}
TRACE("(%p) returning %p\n", This, *ppD3D9);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
}
memset(pCaps, 0, sizeof(*pCaps));
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DDevice_GetDeviceCaps(This->WineD3DDevice, pWineCaps);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
WINECAPSTOD3D9CAPS(pCaps, pWineCaps)
HeapFree(GetProcessHeap(), 0, pWineCaps);
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetDisplayMode(This->WineD3DDevice, iSwapChain, (WINED3DDISPLAYMODE *) pMode);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
if (SUCCEEDED(hr)) pMode->Format = d3dformat_from_wined3dformat(pMode->Format);
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetCreationParameters(This->WineD3DDevice, (WINED3DDEVICE_CREATION_PARAMETERS *) pParameters);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
return WINED3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetCursorProperties(This->WineD3DDevice, XHotSpot, YHotSpot, pSurface->wineD3DSurface);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DDevice_SetCursorPosition(This->WineD3DDevice, XScreenSpace, YScreenSpace, Flags);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
}
static BOOL WINAPI IDirect3DDevice9Impl_ShowCursor(LPDIRECT3DDEVICE9EX iface, BOOL bShow) {
BOOL ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DDevice_ShowCursor(This->WineD3DDevice, bShow);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
static HRESULT WINAPI reset_enum_callback(IWineD3DResource *resource, void *data) {
BOOL *resources_ok = data;
- D3DRESOURCETYPE type;
+ WINED3DRESOURCETYPE type;
HRESULT ret = S_OK;
WINED3DSURFACE_DESC surface_desc;
WINED3DVOLUME_DESC volume_desc;
D3DINDEXBUFFER_DESC index_desc;
D3DVERTEXBUFFER_DESC vertex_desc;
- WINED3DPOOL pool;
+ WINED3DFORMAT dummy_format;
+ WINED3DMULTISAMPLE_TYPE dummy_multisampletype;
+ DWORD dummy_dword;
+ WINED3DPOOL pool = WINED3DPOOL_SCRATCH; /* a harmless pool */
IDirect3DResource9 *parent;
IWineD3DResource_GetParent(resource, (IUnknown **) &parent);
type = IDirect3DResource9_GetType(parent);
switch(type) {
case D3DRTYPE_SURFACE:
+ surface_desc.Format = &dummy_format;
+ surface_desc.Type = &type;
+ surface_desc.Usage = &dummy_dword;
+ surface_desc.Pool = &pool;
+ surface_desc.Size = &dummy_dword;
+ surface_desc.MultiSampleType = &dummy_multisampletype;
+ surface_desc.MultiSampleQuality = &dummy_dword;
+ surface_desc.Width = &dummy_dword;
+ surface_desc.Height = &dummy_dword;
+
IWineD3DSurface_GetDesc((IWineD3DSurface *) resource, &surface_desc);
- pool = surface_desc.pool;
break;
case D3DRTYPE_VOLUME:
+ volume_desc.Format = &dummy_format;
+ volume_desc.Type = &type;
+ volume_desc.Usage = &dummy_dword;
+ volume_desc.Pool = &pool;
+ volume_desc.Size = &dummy_dword;
+ volume_desc.Width = &dummy_dword;
+ volume_desc.Height = &dummy_dword;
+ volume_desc.Depth = &dummy_dword;
IWineD3DVolume_GetDesc((IWineD3DVolume *) resource, &volume_desc);
- pool = volume_desc.Pool;
break;
case D3DRTYPE_INDEXBUFFER:
* is a D3DPOOL_DEFAULT surface or volume as well
*/
default:
- pool = WINED3DPOOL_SCRATCH; /* a harmless pool */
break;
}
* Unsetting them is no problem, because the states are supposed to be reset anyway. If the validation
* below fails, the device is considered "lost", and _Reset and _Release are the only allowed calls
*/
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DDevice_SetIndices(This->WineD3DDevice, NULL, WINED3DFMT_UNKNOWN);
for(i = 0; i < 16; i++) {
IWineD3DDevice_SetStreamSource(This->WineD3DDevice, i, NULL, 0, 0);
if(!resources_ok) {
WARN("The application is holding D3DPOOL_DEFAULT resources, rejecting reset\n");
This->notreset = TRUE;
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return WINED3DERR_INVALIDCALL;
}
This->notreset = FALSE;
}
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_Present(This->WineD3DDevice, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
rc = IWineD3DDevice_GetBackBuffer(This->WineD3DDevice, iSwapChain, BackBuffer, (WINED3DBACKBUFFER_TYPE) Type, &retSurface);
if (rc == D3D_OK && NULL != retSurface && NULL != ppBackBuffer) {
IWineD3DSurface_GetParent(retSurface, (IUnknown **)ppBackBuffer);
IWineD3DSurface_Release(retSurface);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return rc;
}
static HRESULT WINAPI IDirect3DDevice9Impl_GetRasterStatus(LPDIRECT3DDEVICE9EX iface, UINT iSwapChain, D3DRASTER_STATUS* pRasterStatus) {
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetRasterStatus(This->WineD3DDevice, iSwapChain, (WINED3DRASTER_STATUS *) pRasterStatus);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetDialogBoxMode(This->WineD3DDevice, bEnableDialogs);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
-static void WINAPI IDirect3DDevice9Impl_SetGammaRamp(IDirect3DDevice9Ex *iface, UINT iSwapChain,
- DWORD Flags, const D3DGAMMARAMP *pRamp)
-{
+static void WINAPI IDirect3DDevice9Impl_SetGammaRamp(LPDIRECT3DDEVICE9EX iface, UINT iSwapChain, DWORD Flags, CONST D3DGAMMARAMP* pRamp) {
+
IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
TRACE("(%p) Relay\n", This);
+ EnterCriticalSection(&d3d9_cs);
/* Note: D3DGAMMARAMP is compatible with WINED3DGAMMARAMP */
- wined3d_mutex_lock();
IWineD3DDevice_SetGammaRamp(This->WineD3DDevice, iSwapChain, Flags, (CONST WINED3DGAMMARAMP *)pRamp);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
}
static void WINAPI IDirect3DDevice9Impl_GetGammaRamp(LPDIRECT3DDEVICE9EX iface, UINT iSwapChain, D3DGAMMARAMP* pRamp) {
IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
TRACE("(%p) Relay\n", This);
+ EnterCriticalSection(&d3d9_cs);
/* Note: D3DGAMMARAMP is compatible with WINED3DGAMMARAMP */
- wined3d_mutex_lock();
IWineD3DDevice_GetGammaRamp(This->WineD3DDevice, iSwapChain, (WINED3DGAMMARAMP *) pRamp);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
}
-static HRESULT IDirect3DDevice9Impl_CreateSurface(LPDIRECT3DDEVICE9EX iface, UINT Width, UINT Height,
- D3DFORMAT Format, BOOL Lockable, BOOL Discard, UINT Level, IDirect3DSurface9 **ppSurface,
- UINT Usage, D3DPOOL Pool, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality)
-{
+static HRESULT IDirect3DDevice9Impl_CreateSurface(LPDIRECT3DDEVICE9EX iface, UINT Width, UINT Height, D3DFORMAT Format, BOOL Lockable, BOOL Discard, UINT Level, IDirect3DSurface9 **ppSurface,D3DRESOURCETYPE Type, UINT Usage, D3DPOOL Pool, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality,HANDLE* pSharedHandle ) {
HRESULT hrc;
IDirect3DSurface9Impl *object;
IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
TRACE("(%p) Relay\n", This);
-
- if (MultisampleQuality > 0)
- {
+
+ if(MultisampleQuality > 0){
FIXME("MultisampleQuality set to %d, bstituting 0\n", MultisampleQuality);
- MultisampleQuality = 0;
+ /*
+ MultisampleQuality
+ [in] Quality level. The valid range is between zero and one less than the level returned by pQualityLevels used by IDirect3D9::CheckDeviceMultiSampleType. Passing a larger value returns the error D3DERR_INVALIDCALL. The MultisampleQuality values of paired render targets, depth stencil surfaces, and the MultiSample type must all match.
+ */
+
+ MultisampleQuality=0;
}
/*FIXME: Check MAX bounds of MultisampleQuality*/
TRACE("(%p) : w(%d) h(%d) fmt(%d) surf@%p\n", This, Width, Height, Format, *ppSurface);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DDevice_CreateSurface(This->WineD3DDevice, Width, Height, wined3dformat_from_d3dformat(Format),
- Lockable, Discard, Level, &object->wineD3DSurface, Usage & WINED3DUSAGE_MASK, (WINED3DPOOL)Pool,
- MultiSample, MultisampleQuality, SURFACE_OPENGL, (IUnknown *)object);
- wined3d_mutex_unlock();
+ Lockable, Discard, Level, &object->wineD3DSurface, Type, Usage & WINED3DUSAGE_MASK,
+ (WINED3DPOOL)Pool, MultiSample, MultisampleQuality, SURFACE_OPENGL, (IUnknown *)object);
+ LeaveCriticalSection(&d3d9_cs);
if (hrc != D3D_OK || NULL == object->wineD3DSurface) {
return hrc;
}
-static HRESULT WINAPI IDirect3DDevice9Impl_CreateRenderTarget(IDirect3DDevice9Ex *iface, UINT Width, UINT Height,
- D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality, BOOL Lockable,
- IDirect3DSurface9 **ppSurface, HANDLE *pSharedHandle)
-{
+
+
+static HRESULT WINAPI IDirect3DDevice9Impl_CreateRenderTarget(LPDIRECT3DDEVICE9EX iface, UINT Width, UINT Height,
+ D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample,
+ DWORD MultisampleQuality, BOOL Lockable,
+ IDirect3DSurface9 **ppSurface, HANDLE* pSharedHandle) {
HRESULT hr;
TRACE("Relay\n");
- hr = IDirect3DDevice9Impl_CreateSurface(iface, Width, Height, Format, Lockable, FALSE /* Discard */,
- 0 /* Level */, ppSurface, D3DUSAGE_RENDERTARGET, D3DPOOL_DEFAULT, MultiSample, MultisampleQuality);
-
- return hr;
+ hr = IDirect3DDevice9Impl_CreateSurface(iface,Width,Height,Format,Lockable,FALSE/*Discard*/, 0/*Level*/, ppSurface,D3DRTYPE_SURFACE,D3DUSAGE_RENDERTARGET,D3DPOOL_DEFAULT,MultiSample,MultisampleQuality,pSharedHandle);
+ return hr;
}
static HRESULT WINAPI IDirect3DDevice9Impl_CreateDepthStencilSurface(LPDIRECT3DDEVICE9EX iface, UINT Width, UINT Height,
HRESULT hr;
TRACE("Relay\n");
- hr = IDirect3DDevice9Impl_CreateSurface(iface, Width, Height, Format, TRUE /* Lockable */, Discard,
- 0 /* Level */, ppSurface, D3DUSAGE_DEPTHSTENCIL, D3DPOOL_DEFAULT, MultiSample, MultisampleQuality);
-
- return hr;
+ hr = IDirect3DDevice9Impl_CreateSurface(iface,Width,Height,Format,TRUE/* Lockable */,Discard, 0/* Level */
+ ,ppSurface,D3DRTYPE_SURFACE,D3DUSAGE_DEPTHSTENCIL,
+ D3DPOOL_DEFAULT,MultiSample,MultisampleQuality,pSharedHandle);
+ return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_UpdateSurface(This->WineD3DDevice, ((IDirect3DSurface9Impl *)pSourceSurface)->wineD3DSurface, pSourceRect, ((IDirect3DSurface9Impl *)pDestinationSurface)->wineD3DSurface, pDestPoint);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_UpdateTexture(This->WineD3DDevice, ((IDirect3DBaseTexture9Impl *)pSourceTexture)->wineD3DBaseTexture, ((IDirect3DBaseTexture9Impl *)pDestinationTexture)->wineD3DBaseTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p)->(%p,%p)\n" , This, renderTarget, destSurface);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSurface_BltFast(destSurface->wineD3DSurface, 0, 0, renderTarget->wineD3DSurface, NULL, WINEDDBLTFAST_NOCOLORKEY);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetFrontBufferData(This->WineD3DDevice, iSwapChain, destSurface->wineD3DSurface);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p)->(%p,%p,%p,%p,%d)\n" , This, src, pSourceRect, dst, pDestRect, Filter);
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSurface_Blt(dst->wineD3DSurface, pDestRect, src->wineD3DSurface, pSourceRect, 0, NULL, Filter);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ memset(&desc, 0, sizeof(desc));
+ desc.Usage = &usage;
+ desc.Pool = &pool;
+ desc.Type = &restype;
+ EnterCriticalSection(&d3d9_cs);
IWineD3DSurface_GetDesc(surface->wineD3DSurface, &desc);
- usage = desc.usage;
- pool = desc.pool;
- restype = desc.resource_type;
/* This method is only allowed with surfaces that are render targets, or offscreen plain surfaces
* in D3DPOOL_DEFAULT
*/
- if(!(usage & WINED3DUSAGE_RENDERTARGET) && (pool != WINED3DPOOL_DEFAULT || restype != WINED3DRTYPE_SURFACE)) {
- wined3d_mutex_unlock();
+ if(!(usage & WINED3DUSAGE_RENDERTARGET) && (pool != D3DPOOL_DEFAULT || restype != D3DRTYPE_SURFACE)) {
+ LeaveCriticalSection(&d3d9_cs);
WARN("Surface is not a render target, or not a stand-alone D3DPOOL_DEFAULT surface\n");
return D3DERR_INVALIDCALL;
}
/* Colorfill can only be used on rendertarget surfaces, or offscreen plain surfaces in D3DPOOL_DEFAULT */
/* Note: D3DRECT is compatible with WINED3DRECT */
hr = IWineD3DDevice_ColorFill(This->WineD3DDevice, surface->wineD3DSurface, (CONST WINED3DRECT*)pRect, color);
-
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
if(Pool == D3DPOOL_MANAGED ){
FIXME("Attempting to create a managed offscreen plain surface\n");
return D3DERR_INVALIDCALL;
- }
+ }
/*
'Off-screen plain surfaces are always lockable, regardless of their pool types.'
but then...
D3DPOOL_DEFAULT is the appropriate pool for use with the IDirect3DDevice9::StretchRect and IDirect3DDevice9::ColorFill.
Why, their always lockable?
- should I change the usage to dynamic?
+ should I change the usage to dynamic?
*/
- hr = IDirect3DDevice9Impl_CreateSurface(iface, Width, Height, Format, TRUE /* Lockable */, FALSE /* Discard */,
- 0 /* Level */, ppSurface, 0 /* Usage (undefined/none) */, (WINED3DPOOL)Pool, D3DMULTISAMPLE_NONE,
- 0 /* MultisampleQuality */);
+ hr = IDirect3DDevice9Impl_CreateSurface(iface,Width,Height,Format,TRUE/*Loackable*/,FALSE/*Discard*/,0/*Level*/ , ppSurface,D3DRTYPE_SURFACE, 0/*Usage (undefined/none)*/,(WINED3DPOOL) Pool,D3DMULTISAMPLE_NONE,0/*MultisampleQuality*/,pSharedHandle);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetRenderTarget(This->WineD3DDevice, RenderTargetIndex, pSurface ? pSurface->wineD3DSurface : NULL);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
static HRESULT WINAPI IDirect3DDevice9Impl_GetRenderTarget(LPDIRECT3DDEVICE9EX iface, DWORD RenderTargetIndex, IDirect3DSurface9 **ppRenderTarget) {
IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
+ HRESULT hr = D3D_OK;
IWineD3DSurface *pRenderTarget;
- HRESULT hr;
TRACE("(%p) Relay\n" , This);
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
-
+ EnterCriticalSection(&d3d9_cs);
hr=IWineD3DDevice_GetRenderTarget(This->WineD3DDevice,RenderTargetIndex,&pRenderTarget);
- if (FAILED(hr))
- {
- FIXME("Call to IWineD3DDevice_GetRenderTarget failed, hr %#x\n", hr);
- }
- else if (!pRenderTarget)
- {
- *ppRenderTarget = NULL;
- }
- else
- {
- IWineD3DSurface_GetParent(pRenderTarget, (IUnknown **)ppRenderTarget);
+ if (hr == D3D_OK && pRenderTarget != NULL) {
+ IWineD3DSurface_GetParent(pRenderTarget,(IUnknown**)ppRenderTarget);
IWineD3DSurface_Release(pRenderTarget);
+ } else {
+ FIXME("Call to IWineD3DDevice_GetRenderTarget failed\n");
+ *ppRenderTarget = NULL;
}
-
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
pSurface = (IDirect3DSurface9Impl*)pZStencilSurface;
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetDepthStencilSurface(This->WineD3DDevice, NULL==pSurface ? NULL : pSurface->wineD3DSurface);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetDepthStencilSurface(This->WineD3DDevice,&pZStencilSurface);
if (hr == WINED3D_OK) {
IWineD3DSurface_GetParent(pZStencilSurface,(IUnknown**)ppZStencilSurface);
WARN("Call to IWineD3DDevice_GetDepthStencilSurface failed with 0x%08x\n", hr);
*ppZStencilSurface = NULL;
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_BeginScene(This->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_EndScene(This->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DRECT is compatible with WINED3DRECT */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_Clear(This->WineD3DDevice, Count, (CONST WINED3DRECT*) pRects, Flags, Color, Z, Stencil);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DMATRIX is compatible with WINED3DMATRIX */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetTransform(This->WineD3DDevice, State, (CONST WINED3DMATRIX*) lpMatrix);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
+ EnterCriticalSection(&d3d9_cs);
/* Note: D3DMATRIX is compatible with WINED3DMATRIX */
- wined3d_mutex_lock();
hr = IWineD3DDevice_GetTransform(This->WineD3DDevice, State, (WINED3DMATRIX*) pMatrix);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DMATRIX is compatible with WINED3DMATRIX */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_MultiplyTransform(This->WineD3DDevice, State, (CONST WINED3DMATRIX*) pMatrix);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DVIEWPORT9 is compatible with WINED3DVIEWPORT */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetViewport(This->WineD3DDevice, (const WINED3DVIEWPORT *)pViewport);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DVIEWPORT9 is compatible with WINED3DVIEWPORT */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetViewport(This->WineD3DDevice, (WINED3DVIEWPORT *)pViewport);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DMATERIAL9 is compatible with WINED3DMATERIAL */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetMaterial(This->WineD3DDevice, (const WINED3DMATERIAL *)pMaterial);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DMATERIAL9 is compatible with WINED3DMATERIAL */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetMaterial(This->WineD3DDevice, (WINED3DMATERIAL *)pMaterial);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DLIGHT9 is compatible with WINED3DLIGHT */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetLight(This->WineD3DDevice, Index, (const WINED3DLIGHT *)pLight);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* Note: D3DLIGHT9 is compatible with WINED3DLIGHT */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetLight(This->WineD3DDevice, Index, (WINED3DLIGHT *)pLight);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetLightEnable(This->WineD3DDevice, Index, Enable);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetLightEnable(This->WineD3DDevice, Index, pEnable);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetClipPlane(This->WineD3DDevice, Index, pPlane);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetClipPlane(This->WineD3DDevice, Index, pPlane);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetRenderState(This->WineD3DDevice, State, Value);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetRenderState(This->WineD3DDevice, State, pValue);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetClipStatus(This->WineD3DDevice, (const WINED3DCLIPSTATUS *)pClipStatus);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetClipStatus(This->WineD3DDevice, (WINED3DCLIPSTATUS *)pClipStatus);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
rc = IWineD3DDevice_GetTexture(This->WineD3DDevice, Stage, &retTexture);
if (SUCCEEDED(rc) && NULL != retTexture) {
IWineD3DBaseTexture_GetParent(retTexture, (IUnknown **)ppTexture);
}
*ppTexture = NULL;
}
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
return rc;
}
HRESULT hr;
TRACE("(%p) Relay %d %p\n" , This, Stage, pTexture);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetTexture(This->WineD3DDevice, Stage,
pTexture==NULL ? NULL:((IDirect3DBaseTexture9Impl *)pTexture)->wineD3DBaseTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetTextureStageState(This->WineD3DDevice, Stage, tss_lookup[Type], pValue);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetTextureStageState(This->WineD3DDevice, Stage, tss_lookup[Type], Value);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
-static HRESULT WINAPI IDirect3DDevice9Impl_GetSamplerState(IDirect3DDevice9Ex *iface, DWORD Sampler,
- D3DSAMPLERSTATETYPE Type, DWORD *pValue)
-{
- IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
+static HRESULT WINAPI IDirect3DDevice9Impl_GetSamplerState(LPDIRECT3DDEVICE9EX iface, DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD* pValue) {
+ IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetSamplerState(This->WineD3DDevice, Sampler, Type, pValue);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetSamplerState(This->WineD3DDevice, Sampler, Type, Value);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_ValidateDevice(This->WineD3DDevice, pNumPasses);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
-static HRESULT WINAPI IDirect3DDevice9Impl_SetPaletteEntries(IDirect3DDevice9Ex *iface, UINT PaletteNumber,
- const PALETTEENTRY *pEntries)
-{
- IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
+static HRESULT WINAPI IDirect3DDevice9Impl_SetPaletteEntries(LPDIRECT3DDEVICE9EX iface, UINT PaletteNumber, CONST PALETTEENTRY* pEntries) {
+ IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetPaletteEntries(This->WineD3DDevice, PaletteNumber, pEntries);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetPaletteEntries(This->WineD3DDevice, PaletteNumber, pEntries);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetCurrentTexturePalette(This->WineD3DDevice, PaletteNumber);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetCurrentTexturePalette(This->WineD3DDevice, PaletteNumber);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetScissorRect(This->WineD3DDevice, pRect);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetScissorRect(This->WineD3DDevice, pRect);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetSoftwareVertexProcessing(This->WineD3DDevice, bSoftware);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
BOOL ret;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DDevice_GetSoftwareVertexProcessing(This->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetNPatchMode(This->WineD3DDevice, nSegments);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
float ret;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DDevice_GetNPatchMode(This->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
-static HRESULT WINAPI IDirect3DDevice9Impl_DrawPrimitive(IDirect3DDevice9Ex *iface, D3DPRIMITIVETYPE PrimitiveType,
- UINT StartVertex, UINT PrimitiveCount)
-{
- IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
+static HRESULT WINAPI IDirect3DDevice9Impl_DrawPrimitive(LPDIRECT3DDEVICE9EX iface, D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount) {
+ IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DDevice_SetPrimitiveType(This->WineD3DDevice, PrimitiveType);
hr = IWineD3DDevice_DrawPrimitive(This->WineD3DDevice, StartVertex,
vertex_count_from_primitive_count(PrimitiveType, PrimitiveCount));
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n" , This);
/* D3D8 passes the baseVertexIndex in SetIndices, and due to the stateblock functions wined3d has to work that way */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DDevice_SetBaseVertexIndex(This->WineD3DDevice, BaseVertexIndex);
IWineD3DDevice_SetPrimitiveType(This->WineD3DDevice, PrimitiveType);
hr = IWineD3DDevice_DrawIndexedPrimitive(This->WineD3DDevice, MinVertexIndex, NumVertices,
startIndex, vertex_count_from_primitive_count(PrimitiveType, primCount));
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
-static HRESULT WINAPI IDirect3DDevice9Impl_DrawPrimitiveUP(IDirect3DDevice9Ex *iface, D3DPRIMITIVETYPE PrimitiveType,
- UINT PrimitiveCount, const void *pVertexStreamZeroData, UINT VertexStreamZeroStride)
-{
- IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
+static HRESULT WINAPI IDirect3DDevice9Impl_DrawPrimitiveUP(LPDIRECT3DDEVICE9EX iface, D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride) {
+ IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DDevice_SetPrimitiveType(This->WineD3DDevice, PrimitiveType);
hr = IWineD3DDevice_DrawPrimitiveUP(This->WineD3DDevice,
vertex_count_from_primitive_count(PrimitiveType, PrimitiveCount),
pVertexStreamZeroData, VertexStreamZeroStride);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DDevice_SetPrimitiveType(This->WineD3DDevice, PrimitiveType);
hr = IWineD3DDevice_DrawIndexedPrimitiveUP(This->WineD3DDevice, MinVertexIndex, NumVertexIndices,
vertex_count_from_primitive_count(PrimitiveType, PrimitiveCount), pIndexData,
wined3dformat_from_d3dformat(IndexDataFormat), pVertexStreamZeroData, VertexStreamZeroStride);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
IDirect3DVertexBuffer9Impl *dest = (IDirect3DVertexBuffer9Impl *) pDestBuffer;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_ProcessVertices(This->WineD3DDevice,SrcStartIndex, DestIndex, VertexCount, dest->wineD3DVertexBuffer, Decl ? Decl->wineD3DVertexDeclaration : NULL, Flags, dest->fvf);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
return D3D_OK;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
decl = getConvertedDecl(This, FVF);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
if (!decl)
{
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetStreamSource(This->WineD3DDevice, StreamNumber,
- pStreamData ? ((IDirect3DVertexBuffer9Impl *)pStreamData)->wineD3DVertexBuffer : NULL,
- OffsetInBytes, Stride);
- wined3d_mutex_unlock();
-
+ pStreamData==NULL ? NULL:((IDirect3DVertexBuffer9Impl *)pStreamData)->wineD3DVertexBuffer,
+ OffsetInBytes, Stride);
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
rc = IWineD3DDevice_GetStreamSource(This->WineD3DDevice, StreamNumber, &retStream, OffsetInBytes, pStride);
if (rc == D3D_OK && NULL != retStream) {
IWineD3DBuffer_GetParent(retStream, (IUnknown **)pStream);
}
*pStream = NULL;
}
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
return rc;
}
-static HRESULT WINAPI IDirect3DDevice9Impl_SetStreamSourceFreq(IDirect3DDevice9Ex *iface, UINT StreamNumber,
- UINT Divider)
-{
- IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
+static HRESULT WINAPI IDirect3DDevice9Impl_SetStreamSourceFreq(LPDIRECT3DDEVICE9EX iface, UINT StreamNumber, UINT Divider) {
+ IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetStreamSourceFreq(This->WineD3DDevice, StreamNumber, Divider);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n" , This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetStreamSourceFreq(This->WineD3DDevice, StreamNumber, Divider);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
IDirect3DIndexBuffer9Impl *ib = (IDirect3DIndexBuffer9Impl *) pIndexData;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetIndices(This->WineD3DDevice,
ib ? ib->wineD3DIndexBuffer : NULL,
ib ? ib->format : WINED3DFMT_UNKNOWN);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
rc = IWineD3DDevice_GetIndices(This->WineD3DDevice, &retIndexData);
if (SUCCEEDED(rc) && retIndexData) {
IWineD3DBuffer_GetParent(retIndexData, (IUnknown **)ppIndexData);
if (FAILED(rc)) FIXME("Call to GetIndices failed\n");
*ppIndexData = NULL;
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return rc;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_DrawRectPatch(This->WineD3DDevice, Handle, pNumSegs, (CONST WINED3DRECTPATCH_INFO *)pRectPatchInfo);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_DrawTriPatch(This->WineD3DDevice, Handle, pNumSegs, (CONST WINED3DTRIPATCH_INFO *)pTriPatchInfo);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_DeletePatch(This->WineD3DDevice, Handle);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
"\tpool %#x, level %u, face %u, surface %p\n",
iface, superior, width, height, format, usage, pool, level, face, surface);
- if (pool == WINED3DPOOL_DEFAULT && !(usage & D3DUSAGE_DYNAMIC))
- lockable = FALSE;
+ if (pool == D3DPOOL_DEFAULT && !(usage & D3DUSAGE_DYNAMIC)) lockable = FALSE;
hr = IDirect3DDevice9Impl_CreateSurface((IDirect3DDevice9Ex *)This, width, height,
d3dformat_from_wined3dformat(format), lockable, FALSE /* Discard */, level,
- (IDirect3DSurface9 **)&d3d_surface, usage, pool, D3DMULTISAMPLE_NONE, 0 /* MultisampleQuality */);
+ (IDirect3DSurface9 **)&d3d_surface, D3DRTYPE_SURFACE, usage, pool,
+ D3DMULTISAMPLE_NONE, 0 /* MultisampleQuality */, NULL);
if (FAILED(hr))
{
ERR("(%p) CreateSurface failed, returning %#x\n", iface, hr);
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3D_Release(This->WineD3D);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
HeapFree(GetProcessHeap(), 0, This);
}
HRESULT hr;
TRACE("(%p)->(%p)\n", This, pInitializeFunction);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3D_RegisterSoftwareDevice(This->WineD3D, pInitializeFunction);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("%p\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3D_GetAdapterCount(This->WineD3D);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
WINED3DADAPTER_IDENTIFIER adapter_id;
HRESULT hr;
- adapter_id.driver = pIdentifier->Driver;
- adapter_id.driver_size = sizeof(pIdentifier->Driver);
- adapter_id.description = pIdentifier->Description;
- adapter_id.description_size = sizeof(pIdentifier->Description);
- adapter_id.device_name = pIdentifier->DeviceName;
- adapter_id.device_name_size = sizeof(pIdentifier->DeviceName);
-
- wined3d_mutex_lock();
+ /* dx8 and dx9 have different structures to be filled in, with incompatible
+ layouts so pass in pointers to the places to be filled via an internal
+ structure */
+ adapter_id.Driver = pIdentifier->Driver;
+ adapter_id.Description = pIdentifier->Description;
+ adapter_id.DeviceName = pIdentifier->DeviceName;
+ adapter_id.DriverVersion = &pIdentifier->DriverVersion;
+ adapter_id.VendorId = &pIdentifier->VendorId;
+ adapter_id.DeviceId = &pIdentifier->DeviceId;
+ adapter_id.SubSysId = &pIdentifier->SubSysId;
+ adapter_id.Revision = &pIdentifier->Revision;
+ adapter_id.DeviceIdentifier = &pIdentifier->DeviceIdentifier;
+ adapter_id.WHQLLevel = &pIdentifier->WHQLLevel;
+
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3D_GetAdapterIdentifier(This->WineD3D, Adapter, Flags, &adapter_id);
- wined3d_mutex_unlock();
-
- pIdentifier->DriverVersion = adapter_id.driver_version;
- pIdentifier->VendorId = adapter_id.vendor_id;
- pIdentifier->DeviceId = adapter_id.device_id;
- pIdentifier->SubSysId = adapter_id.subsystem_id;
- pIdentifier->Revision = adapter_id.revision;
- memcpy(&pIdentifier->DeviceIdentifier, &adapter_id.device_identifier, sizeof(pIdentifier->DeviceIdentifier));
- pIdentifier->WHQLLevel = adapter_id.whql_level;
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
return 0;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3D_GetAdapterModeCount(This->WineD3D, Adapter, wined3dformat_from_d3dformat(Format));
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
if(Format != D3DFMT_X8R8G8B8 && Format != D3DFMT_R5G6B5)
return D3DERR_INVALIDCALL;
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3D_EnumAdapterModes(This->WineD3D, Adapter, wined3dformat_from_d3dformat(Format),
Mode, (WINED3DDISPLAYMODE *) pMode);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
if (SUCCEEDED(hr)) pMode->Format = d3dformat_from_wined3dformat(pMode->Format);
IDirect3D9Impl *This = (IDirect3D9Impl *)iface;
HRESULT hr;
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3D_GetAdapterDisplayMode(This->WineD3D, Adapter, (WINED3DDISPLAYMODE *) pMode);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
if (SUCCEEDED(hr)) pMode->Format = d3dformat_from_wined3dformat(pMode->Format);
return hr;
}
-static HRESULT WINAPI IDirect3D9Impl_CheckDeviceType(IDirect3D9Ex *iface, UINT Adapter,
- D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat, D3DFORMAT BackBufferFormat, BOOL Windowed)
-{
+static HRESULT WINAPI IDirect3D9Impl_CheckDeviceType(LPDIRECT3D9EX iface,
+ UINT Adapter, D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat,
+ D3DFORMAT BackBufferFormat, BOOL Windowed) {
IDirect3D9Impl *This = (IDirect3D9Impl *)iface;
HRESULT hr;
TRACE("(%p)->(%d, %d, %d, %d, %s\n", This, Adapter, CheckType, DisplayFormat,
BackBufferFormat, Windowed ? "true" : "false");
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3D_CheckDeviceType(This->WineD3D, Adapter, CheckType, wined3dformat_from_d3dformat(DisplayFormat),
wined3dformat_from_d3dformat(BackBufferFormat), Windowed);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
-static HRESULT WINAPI IDirect3D9Impl_CheckDeviceFormat(IDirect3D9Ex *iface, UINT Adapter, D3DDEVTYPE DeviceType,
- D3DFORMAT AdapterFormat, DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat)
-{
+static HRESULT WINAPI IDirect3D9Impl_CheckDeviceFormat(LPDIRECT3D9EX iface,
+ UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat,
+ DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat) {
IDirect3D9Impl *This = (IDirect3D9Impl *)iface;
HRESULT hr;
WINED3DRESOURCETYPE WineD3DRType;
TRACE("%p\n", This);
- /* This format is nothing special and it is supported perfectly.
- * However, ati and nvidia driver on windows do not mark this format as
- * supported (tested with the dxCapsViewer) and pretending to
- * support this format uncovers a bug in Battlefield 1942 (fonts are missing)
- * So do the same as Windows drivers and pretend not to support it on dx8 and 9
- */
- if(CheckFormat == D3DFMT_R8G8B8)
- {
- WARN("D3DFMT_R8G8B8 is not available on windows, returning D3DERR_NOTAVAILABLE\n");
- return D3DERR_NOTAVAILABLE;
- }
-
switch(RType) {
case D3DRTYPE_VERTEXBUFFER:
case D3DRTYPE_INDEXBUFFER:
break;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3D_CheckDeviceFormat(This->WineD3D, Adapter, DeviceType, wined3dformat_from_d3dformat(AdapterFormat),
Usage, WineD3DRType, wined3dformat_from_d3dformat(CheckFormat), SURFACE_OPENGL);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
-static HRESULT WINAPI IDirect3D9Impl_CheckDeviceMultiSampleType(IDirect3D9Ex *iface, UINT Adapter,
- D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType,
- DWORD *pQualityLevels)
-{
+static HRESULT WINAPI IDirect3D9Impl_CheckDeviceMultiSampleType(LPDIRECT3D9EX iface,
+ UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat,
+ BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType, DWORD* pQualityLevels) {
IDirect3D9Impl *This = (IDirect3D9Impl *)iface;
HRESULT hr;
TRACE("%p\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3D_CheckDeviceMultiSampleType(This->WineD3D, Adapter, DeviceType,
wined3dformat_from_d3dformat(SurfaceFormat), Windowed, MultiSampleType, pQualityLevels);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
-static HRESULT WINAPI IDirect3D9Impl_CheckDepthStencilMatch(IDirect3D9Ex *iface, UINT Adapter,
- D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat)
-{
+static HRESULT WINAPI IDirect3D9Impl_CheckDepthStencilMatch(LPDIRECT3D9EX iface,
+ UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat,
+ D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat) {
IDirect3D9Impl *This = (IDirect3D9Impl *)iface;
HRESULT hr;
TRACE("%p\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3D_CheckDepthStencilMatch(This->WineD3D, Adapter, DeviceType,
wined3dformat_from_d3dformat(AdapterFormat), wined3dformat_from_d3dformat(RenderTargetFormat),
wined3dformat_from_d3dformat(DepthStencilFormat));
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("%p\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3D_CheckDeviceFormatConversion(This->WineD3D, Adapter, DeviceType,
wined3dformat_from_d3dformat(SourceFormat), wined3dformat_from_d3dformat(TargetFormat));
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
return D3DERR_INVALIDCALL; /*well this is what MSDN says to return*/
}
memset(pCaps, 0, sizeof(*pCaps));
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3D_GetDeviceCaps(This->WineD3D, Adapter, DeviceType, pWineCaps);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
WINECAPSTOD3D9CAPS(pCaps, pWineCaps)
HeapFree(GetProcessHeap(), 0, pWineCaps);
HMONITOR ret;
TRACE("%p\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3D_GetAdapterMonitor(This->WineD3D, Adapter);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
*ppReturnedDeviceInterface = (IDirect3DDevice9 *)object;
/* Allocate an associated WineD3DDevice object */
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3D_CreateDevice(This->WineD3D, Adapter, DeviceType, hFocusWindow, BehaviourFlags,
(IUnknown *)object, (IWineD3DDeviceParent *)&object->device_parent_vtbl, &object->WineD3DDevice);
if (hr != D3D_OK) {
HeapFree(GetProcessHeap(), 0, object);
*ppReturnedDeviceInterface = NULL;
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
* can be used without further checking
*/
object->convertedDecls = HeapAlloc(GetProcessHeap(), 0, 0);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DBuffer_Release(This->wineD3DIndexBuffer);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
IDirect3DDevice9Ex_Release(This->parentDevice);
HeapFree(GetProcessHeap(), 0, This);
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DBuffer_GetDevice(This->wineD3DIndexBuffer, &wined3d_device);
if (SUCCEEDED(hr))
{
IWineD3DDevice_GetParent(wined3d_device, (IUnknown **)ppDevice);
IWineD3DDevice_Release(wined3d_device);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DBuffer_SetPrivateData(This->wineD3DIndexBuffer, refguid, pData, SizeOfData, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DBuffer_GetPrivateData(This->wineD3DIndexBuffer, refguid, pData, pSizeOfData);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DBuffer_FreePrivateData(This->wineD3DIndexBuffer, refguid);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DBuffer_SetPriority(This->wineD3DIndexBuffer, PriorityNew);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DBuffer_GetPriority(This->wineD3DIndexBuffer);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl *)iface;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DBuffer_PreLoad(This->wineD3DIndexBuffer);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
}
static D3DRESOURCETYPE WINAPI IDirect3DIndexBuffer9Impl_GetType(LPDIRECT3DINDEXBUFFER9 iface) {
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DBuffer_Map(This->wineD3DIndexBuffer, OffsetToLock, SizeToLock, (BYTE **)ppbData, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DBuffer_Unmap(This->wineD3DIndexBuffer);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
WINED3DBUFFER_DESC desc;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DBuffer_GetDesc(This->wineD3DIndexBuffer, &desc);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
if (SUCCEEDED(hr)) {
pDesc->Format = d3dformat_from_wined3dformat(This->format);
/* IDirect3DDevice9 IDirect3DIndexBuffer9 Methods follow: */
-HRESULT WINAPI IDirect3DDevice9Impl_CreateIndexBuffer(IDirect3DDevice9Ex *iface, UINT Length, DWORD Usage,
- D3DFORMAT Format, D3DPOOL Pool, IDirect3DIndexBuffer9 **ppIndexBuffer, HANDLE *pSharedHandle)
-{
+HRESULT WINAPI IDirect3DDevice9Impl_CreateIndexBuffer(LPDIRECT3DDEVICE9EX iface,
+ UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool,
+ IDirect3DIndexBuffer9** ppIndexBuffer, HANDLE* pSharedHandle) {
+
IDirect3DIndexBuffer9Impl *object;
IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
HRESULT hrc = D3D_OK;
-
+
TRACE("(%p) Relay\n", This);
/* Allocate the storage for the device */
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
object->ref = 1;
object->format = wined3dformat_from_d3dformat(Format);
TRACE("Calling wined3d create index buffer\n");
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DDevice_CreateIndexBuffer(This->WineD3DDevice, Length, Usage & WINED3DUSAGE_MASK,
(WINED3DPOOL)Pool, &object->wineD3DIndexBuffer, (IUnknown *)object);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
if (hrc != D3D_OK) {
/* free up object */
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DPixelShader_Release(This->wineD3DPixelShader);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
IDirect3DDevice9Ex_Release(This->parentDevice);
HeapFree(GetProcessHeap(), 0, This);
}
TRACE("(%p) : Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DPixelShader_GetDevice(This->wineD3DPixelShader, &myDevice);
IWineD3DDevice_GetParent(myDevice, (IUnknown **)ppDevice);
IWineD3DDevice_Release(myDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
TRACE("(%p) returning (%p)\n", This, *ppDevice);
return D3D_OK;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DPixelShader_GetFunction(This->wineD3DPixelShader, pData, pSizeOfData);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
object->ref = 1;
object->lpVtbl = &Direct3DPixelShader9_Vtbl;
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DDevice_CreatePixelShader(This->WineD3DDevice, pFunction, NULL,
&object->wineD3DPixelShader, (IUnknown *)object);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
+ if (hrc != D3D_OK) {
- if (hrc != D3D_OK)
- {
/* free up object */
FIXME("(%p) call to IWineD3DDevice_CreatePixelShader failed\n", This);
HeapFree(GetProcessHeap(), 0 , object);
IDirect3DPixelShader9Impl *shader = (IDirect3DPixelShader9Impl *)pShader;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DDevice_SetPixelShader(This->WineD3DDevice, shader == NULL ? NULL :shader->wineD3DPixelShader);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return D3D_OK;
}
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DDevice_GetPixelShader(This->WineD3DDevice, &object);
if (SUCCEEDED(hrc))
{
{
WARN("(%p) : Call to IWineD3DDevice_GetPixelShader failed %u (device %p)\n", This, hrc, This->WineD3DDevice);
}
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
TRACE("(%p) : returning %p\n", This, *ppShader);
return hrc;
HRESULT WINAPI IDirect3DDevice9Impl_SetPixelShaderConstantF(LPDIRECT3DDEVICE9EX iface, UINT Register, CONST float* pConstantData, UINT Vector4fCount) {
IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
HRESULT hr;
- TRACE("(%p) Relay\n", This);
+ TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetPixelShaderConstantF(This->WineD3DDevice, Register, pConstantData, Vector4fCount);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetPixelShaderConstantF(This->WineD3DDevice, Register, pConstantData, Vector4fCount);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetPixelShaderConstantI(This->WineD3DDevice, Register, pConstantData, Vector4iCount);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetPixelShaderConstantI(This->WineD3DDevice, Register, pConstantData, Vector4iCount);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetPixelShaderConstantB(This->WineD3DDevice, Register, pConstantData, BoolCount);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetPixelShaderConstantB(This->WineD3DDevice, Register, pConstantData, BoolCount);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DQuery_Release(This->wineD3DQuery);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
IDirect3DDevice9Ex_Release(This->parentDevice);
HeapFree(GetProcessHeap(), 0, This);
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DQuery_GetDevice(This->wineD3DQuery, &pDevice);
if(hr != D3D_OK){
*ppDevice = NULL;
hr = IWineD3DDevice_GetParent(pDevice, (IUnknown **)ppDevice);
IWineD3DDevice_Release(pDevice);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DQuery_GetType(This->wineD3DQuery);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DQuery_GetDataSize(This->wineD3DQuery);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DQuery_Issue(This->wineD3DQuery, dwIssueFlags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DQuery_GetData(This->wineD3DQuery, pData, dwSize, dwGetDataFlags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
if (!ppQuery)
{
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_CreateQuery(This->WineD3DDevice, Type, NULL, NULL);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
object->lpVtbl = &Direct3DQuery9_Vtbl;
object->ref = 1;
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_CreateQuery(This->WineD3DDevice, Type, &object->wineD3DQuery, (IUnknown *)object);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
if (FAILED(hr)) {
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DStateBlock_Release(This->wineD3DStateBlock);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
IDirect3DDevice9Ex_Release(This->parentDevice);
HeapFree(GetProcessHeap(), 0, This);
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DStateBlock_GetDevice(This->wineD3DStateBlock, &wined3d_device);
if (SUCCEEDED(hr))
{
IWineD3DDevice_GetParent(wined3d_device, (IUnknown **)ppDevice);
IWineD3DDevice_Release(wined3d_device);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
static HRESULT WINAPI IDirect3DStateBlock9Impl_Capture(LPDIRECT3DSTATEBLOCK9 iface) {
IDirect3DStateBlock9Impl *This = (IDirect3DStateBlock9Impl *)iface;
HRESULT hr;
- TRACE("(%p) Relay\n", This);
+ TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DStateBlock_Capture(This->wineD3DStateBlock);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DStateBlock_Apply(This->wineD3DStateBlock);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
IDirect3DStateBlock9Impl* object;
HRESULT hrc = D3D_OK;
-
+
TRACE("(%p) Relay\n", This);
if(Type != D3DSBT_ALL && Type != D3DSBT_PIXELSTATE &&
WARN("Unexpected stateblock type, returning D3DERR_INVALIDCALL\n");
return D3DERR_INVALIDCALL;
}
-
+
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DStateBlock9Impl));
if (NULL == object) return E_OUTOFMEMORY;
object->lpVtbl = &Direct3DStateBlock9_Vtbl;
object->ref = 1;
-
- wined3d_mutex_lock();
+
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DDevice_CreateStateBlock(This->WineD3DDevice, (WINED3DSTATEBLOCKTYPE)Type, &object->wineD3DStateBlock, (IUnknown*)object);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
if(hrc != D3D_OK){
FIXME("(%p) Call to IWineD3DDevice_CreateStateBlock failed.\n", This);
HeapFree(GetProcessHeap(), 0, object);
return hrc;
}
-HRESULT WINAPI IDirect3DDevice9Impl_BeginStateBlock(IDirect3DDevice9Ex *iface)
-{
- IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
+HRESULT WINAPI IDirect3DDevice9Impl_BeginStateBlock(LPDIRECT3DDEVICE9EX iface) {
+ IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_BeginStateBlock(This->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
-HRESULT WINAPI IDirect3DDevice9Impl_EndStateBlock(IDirect3DDevice9Ex *iface, IDirect3DStateBlock9 **ppSB)
-{
- IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
- IWineD3DStateBlock *wineD3DStateBlock;
- IDirect3DStateBlock9Impl *object;
+HRESULT WINAPI IDirect3DDevice9Impl_EndStateBlock(LPDIRECT3DDEVICE9EX iface, IDirect3DStateBlock9** ppSB) {
+ IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
HRESULT hr;
+ IWineD3DStateBlock* wineD3DStateBlock;
+ IDirect3DStateBlock9Impl* object;
- TRACE("(%p) Relay\n", This);
-
+ TRACE("(%p) Relay\n", This);
+
/* Tell wineD3D to endstateblock before anything else (in case we run out
- * of memory later and cause locking problems) */
- wined3d_mutex_lock();
+ * of memory later and cause locking problems)
+ */
+ EnterCriticalSection(&d3d9_cs);
hr=IWineD3DDevice_EndStateBlock(This->WineD3DDevice,&wineD3DStateBlock);
- wined3d_mutex_unlock();
-
- if (hr!= D3D_OK)
- {
+ LeaveCriticalSection(&d3d9_cs);
+ if(hr!= D3D_OK){
WARN("IWineD3DDevice_EndStateBlock returned an error\n");
return hr;
- }
+ }
/* allocate a new IDirectD3DStateBlock */
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DStateBlock9Impl));
+ object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY ,sizeof(IDirect3DStateBlock9Impl));
if (!object) return E_OUTOFMEMORY;
object->ref = 1;
object->lpVtbl = &Direct3DStateBlock9_Vtbl;
if (ref == 0) {
if (This->parentDevice) IDirect3DDevice9Ex_Release(This->parentDevice);
if (!This->isImplicit) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DSurface_Release(This->wineD3DSurface);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
HeapFree(GetProcessHeap(), 0, This);
}
}
HRESULT hr;
TRACE("(%p)->(%p)\n", This, ppDevice);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSurface_GetDevice(This->wineD3DSurface, &wined3d_device);
if (SUCCEEDED(hr))
{
IWineD3DDevice_GetParent(wined3d_device, (IUnknown **)ppDevice);
IWineD3DDevice_Release(wined3d_device);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSurface_SetPrivateData(This->wineD3DSurface, refguid, pData, SizeOfData, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSurface_GetPrivateData(This->wineD3DSurface, refguid, pData, pSizeOfData);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSurface_FreePrivateData(This->wineD3DSurface, refguid);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSurface_SetPriority(This->wineD3DSurface, PriorityNew);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSurface_GetPriority(This->wineD3DSurface);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DSurface_PreLoad(This->wineD3DSurface);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
+ return ;
}
static D3DRESOURCETYPE WINAPI IDirect3DSurface9Impl_GetType(LPDIRECT3DSURFACE9 iface) {
D3DRESOURCETYPE ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DSurface_GetType(This->wineD3DSurface);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
static HRESULT WINAPI IDirect3DSurface9Impl_GetDesc(LPDIRECT3DSURFACE9 iface, D3DSURFACE_DESC* pDesc) {
IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl *)iface;
- WINED3DSURFACE_DESC wined3ddesc;
+ WINED3DSURFACE_DESC wined3ddesc;
+ UINT tmpInt = -1;
+ WINED3DFORMAT format;
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ /* As d3d8 and d3d9 structures differ, pass in ptrs to where data needs to go */
+ wined3ddesc.Format = &format;
+ wined3ddesc.Type = (WINED3DRESOURCETYPE *)&pDesc->Type;
+ wined3ddesc.Usage = &pDesc->Usage;
+ wined3ddesc.Pool = (WINED3DPOOL *) &pDesc->Pool;
+ wined3ddesc.Size = &tmpInt;
+ wined3ddesc.MultiSampleType = (WINED3DMULTISAMPLE_TYPE *) &pDesc->MultiSampleType;
+ wined3ddesc.MultiSampleQuality = &pDesc->MultiSampleQuality;
+ wined3ddesc.Width = &pDesc->Width;
+ wined3ddesc.Height = &pDesc->Height;
+
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSurface_GetDesc(This->wineD3DSurface, &wined3ddesc);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
- if (SUCCEEDED(hr))
- {
- pDesc->Format = d3dformat_from_wined3dformat(wined3ddesc.format);
- pDesc->Type = wined3ddesc.resource_type;
- pDesc->Usage = wined3ddesc.usage;
- pDesc->Pool = wined3ddesc.pool;
- pDesc->MultiSampleType = wined3ddesc.multisample_type;
- pDesc->MultiSampleQuality = wined3ddesc.multisample_quality;
- pDesc->Width = wined3ddesc.width;
- pDesc->Height = wined3ddesc.height;
- }
+ if (SUCCEEDED(hr)) pDesc->Format = d3dformat_from_wined3dformat(format);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
TRACE("(%p) calling IWineD3DSurface_LockRect %p %p %p %d\n", This, This->wineD3DSurface, pLockedRect, pRect, Flags);
hr = IWineD3DSurface_LockRect(This->wineD3DSurface, (WINED3DLOCKED_RECT *) pLockedRect, pRect, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSurface_UnlockRect(This->wineD3DSurface);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
switch(hr)
{
case WINEDDERR_NOTLOCKED: return D3DERR_INVALIDCALL;
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSurface_GetDC(This->wineD3DSurface, phdc);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSurface_ReleaseDC(This->wineD3DSurface, hdc);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
switch(hr) {
case WINEDDERR_NODC: return WINED3DERR_INVALIDCALL;
default: return hr;
if (ref == 0) {
if (This->parentDevice) IDirect3DDevice9Ex_Release(This->parentDevice);
if (!This->isImplicit) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DSwapChain_Destroy(This->wineD3DSwapChain, D3D9CB_DestroyRenderTarget);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
HeapFree(GetProcessHeap(), 0, This);
}
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSwapChain_Present(This->wineD3DSwapChain, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion, dwFlags);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSwapChain_GetFrontBufferData(This->wineD3DSwapChain, ((IDirect3DSurface9Impl *)pDestSurface)->wineD3DSurface);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DSwapChain_GetBackBuffer(This->wineD3DSwapChain, iBackBuffer, (WINED3DBACKBUFFER_TYPE) Type, &mySurface);
if (hrc == D3D_OK && NULL != mySurface) {
IWineD3DSurface_GetParent(mySurface, (IUnknown **)ppBackBuffer);
IWineD3DSurface_Release(mySurface);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
/* Do not touch the **ppBackBuffer pointer otherwise! (see device test) */
return hrc;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSwapChain_GetRasterStatus(This->wineD3DSwapChain, (WINED3DRASTER_STATUS *) pRasterStatus);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSwapChain_GetDisplayMode(This->wineD3DSwapChain, (WINED3DDISPLAYMODE *) pMode);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
if (SUCCEEDED(hr)) pMode->Format = d3dformat_from_wined3dformat(pMode->Format);
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DSwapChain_GetDevice(This->wineD3DSwapChain, &device);
if (hrc == D3D_OK && NULL != device) {
IWineD3DDevice_GetParent(device, (IUnknown **)ppDevice);
IWineD3DDevice_Release(device);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hrc;
}
TRACE("(%p)->(%p): Relay\n", This, pPresentationParameters);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DSwapChain_GetPresentParameters(This->wineD3DSwapChain, &winePresentParameters);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
pPresentationParameters->BackBufferWidth = winePresentParameters.BackBufferWidth;
pPresentationParameters->BackBufferHeight = winePresentParameters.BackBufferHeight;
localParameters.PresentationInterval = pPresentationParameters->PresentationInterval;
localParameters.AutoRestoreDisplayMode = TRUE;
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DDevice_CreateSwapChain(This->WineD3DDevice, &localParameters,
&object->wineD3DSwapChain, (IUnknown*)object, SURFACE_OPENGL);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
pPresentationParameters->BackBufferWidth = localParameters.BackBufferWidth;
pPresentationParameters->BackBufferHeight = localParameters.BackBufferHeight;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DDevice_GetSwapChain(This->WineD3DDevice, iSwapChain, &swapchain);
if (hrc == D3D_OK && NULL != swapchain) {
IWineD3DSwapChain_GetParent(swapchain, (IUnknown **)pSwapChain);
} else {
*pSwapChain = NULL;
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hrc;
}
UINT ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DDevice_GetNumberOfSwapChains(This->WineD3DDevice);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DTexture_Destroy(This->wineD3DTexture, D3D9CB_DestroySurface);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
IDirect3DDevice9Ex_Release(This->parentDevice);
HeapFree(GetProcessHeap(), 0, This);
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DTexture_GetDevice(This->wineD3DTexture, &wined3d_device);
if (SUCCEEDED(hr))
{
IWineD3DDevice_GetParent(wined3d_device, (IUnknown **)ppDevice);
IWineD3DDevice_Release(wined3d_device);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DTexture_SetPrivateData(This->wineD3DTexture, refguid, pData, SizeOfData, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DTexture_GetPrivateData(This->wineD3DTexture, refguid, pData, pSizeOfData);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DTexture_FreePrivateData(This->wineD3DTexture, refguid);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DTexture_SetPriority(This->wineD3DTexture, PriorityNew);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DTexture_GetPriority(This->wineD3DTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DTexture_PreLoad(This->wineD3DTexture);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
}
static D3DRESOURCETYPE WINAPI IDirect3DTexture9Impl_GetType(LPDIRECT3DTEXTURE9 iface) {
HRESULT ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DTexture_GetType(This->wineD3DTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DTexture_SetLOD(This->wineD3DTexture, LODNew);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DTexture_GetLOD(This->wineD3DTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
DWORD ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = IWineD3DTexture_GetLevelCount(This->wineD3DTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DTexture_SetAutoGenFilterType(This->wineD3DTexture, (WINED3DTEXTUREFILTERTYPE) FilterType);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
D3DTEXTUREFILTERTYPE ret;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
ret = (D3DTEXTUREFILTERTYPE) IWineD3DTexture_GetAutoGenFilterType(This->wineD3DTexture);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return ret;
}
IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DTexture_GenerateMipSubLevels(This->wineD3DTexture);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
}
/* IDirect3DTexture9 Interface follow: */
static HRESULT WINAPI IDirect3DTexture9Impl_GetLevelDesc(LPDIRECT3DTEXTURE9 iface, UINT Level, D3DSURFACE_DESC* pDesc) {
IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl *)iface;
- WINED3DSURFACE_DESC wined3ddesc;
- HRESULT hr;
+
+ WINED3DSURFACE_DESC wined3ddesc;
+ UINT tmpInt = -1;
+ HRESULT hr;
+ WINED3DFORMAT format;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ /* As d3d8 and d3d9 structures differ, pass in ptrs to where data needs to go */
+ wined3ddesc.Format = &format;
+ wined3ddesc.Type = (WINED3DRESOURCETYPE *)&pDesc->Type;
+ wined3ddesc.Usage = &pDesc->Usage;
+ wined3ddesc.Pool = (WINED3DPOOL *) &pDesc->Pool;
+ wined3ddesc.Size = &tmpInt; /* required for d3d8 */
+ wined3ddesc.MultiSampleType = (WINED3DMULTISAMPLE_TYPE *) &pDesc->MultiSampleType;
+ wined3ddesc.MultiSampleQuality = &pDesc->MultiSampleQuality;
+ wined3ddesc.Width = &pDesc->Width;
+ wined3ddesc.Height = &pDesc->Height;
+
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DTexture_GetLevelDesc(This->wineD3DTexture, Level, &wined3ddesc);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
- if (SUCCEEDED(hr))
- {
- pDesc->Format = d3dformat_from_wined3dformat(wined3ddesc.format);
- pDesc->Type = wined3ddesc.resource_type;
- pDesc->Usage = wined3ddesc.usage;
- pDesc->Pool = wined3ddesc.pool;
- pDesc->MultiSampleType = wined3ddesc.multisample_type;
- pDesc->MultiSampleQuality = wined3ddesc.multisample_quality;
- pDesc->Width = wined3ddesc.width;
- pDesc->Height = wined3ddesc.height;
- }
+ if (SUCCEEDED(hr)) pDesc->Format = d3dformat_from_wined3dformat(format);
return hr;
}
IWineD3DSurface *mySurface = NULL;
TRACE("(%p) Relay\n", This);
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DTexture_GetSurfaceLevel(This->wineD3DTexture, Level, &mySurface);
if (hrc == D3D_OK && NULL != ppSurfaceLevel) {
IWineD3DSurface_GetParent(mySurface, (IUnknown **)ppSurfaceLevel);
IWineD3DSurface_Release(mySurface);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hrc;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DTexture_LockRect(This->wineD3DTexture, Level, (WINED3DLOCKED_RECT *) pLockedRect, pRect, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DTexture_UnlockRect(This->wineD3DTexture, Level);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DTexture_AddDirtyRect(This->wineD3DTexture, pDirtyRect);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
IDirect3DTexture9Impl *object;
IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
HRESULT hrc = D3D_OK;
-
+
TRACE("(%p) : W(%d) H(%d), Lvl(%d) d(%d), Fmt(%#x), Pool(%d)\n", This, Width, Height, Levels, Usage, Format, Pool);
/* Allocate the storage for the device */
object->lpVtbl = &Direct3DTexture9_Vtbl;
object->ref = 1;
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DDevice_CreateTexture(This->WineD3DDevice, Width, Height, Levels, Usage & WINED3DUSAGE_MASK,
wined3dformat_from_d3dformat(Format), Pool, &object->wineD3DTexture, (IUnknown *)object);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
+ if (FAILED(hrc)) {
- if (FAILED(hrc))
- {
/* free up object */
WARN("(%p) call to IWineD3DDevice_CreateTexture failed\n", This);
HeapFree(GetProcessHeap(), 0, object);
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DBuffer_Release(This->wineD3DVertexBuffer);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
IDirect3DDevice9Ex_Release(This->parentDevice);
HeapFree(GetProcessHeap(), 0, This);
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DBuffer_GetDevice(This->wineD3DVertexBuffer, &wined3d_device);
if (SUCCEEDED(hr))
{
IWineD3DDevice_GetParent(wined3d_device, (IUnknown **)ppDevice);
IWineD3DDevice_Release(wined3d_device);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DBuffer_SetPrivateData(This->wineD3DVertexBuffer, refguid, pData, SizeOfData, Flags);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DBuffer_GetPrivateData(This->wineD3DVertexBuffer, refguid, pData, pSizeOfData);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DBuffer_FreePrivateData(This->wineD3DVertexBuffer, refguid);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DBuffer_SetPriority(This->wineD3DVertexBuffer, PriorityNew);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DBuffer_GetPriority(This->wineD3DVertexBuffer);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl *)iface;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DBuffer_PreLoad(This->wineD3DVertexBuffer);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
+ return ;
}
static D3DRESOURCETYPE WINAPI IDirect3DVertexBuffer9Impl_GetType(LPDIRECT3DVERTEXBUFFER9 iface) {
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DBuffer_Map(This->wineD3DVertexBuffer, OffsetToLock, SizeToLock, (BYTE **)ppbData, Flags);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DBuffer_Unmap(This->wineD3DVertexBuffer);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
WINED3DBUFFER_DESC desc;
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DBuffer_GetDesc(This->wineD3DVertexBuffer, &desc);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
if (SUCCEEDED(hr)) {
pDesc->Format = D3DFMT_VERTEXDATA;
/* IDirect3DDevice9 IDirect3DVertexBuffer9 Methods follow: */
-HRESULT WINAPI IDirect3DDevice9Impl_CreateVertexBuffer(IDirect3DDevice9Ex *iface, UINT Size, DWORD Usage,
- DWORD FVF, D3DPOOL Pool, IDirect3DVertexBuffer9** ppVertexBuffer, HANDLE* pSharedHandle)
-{
+HRESULT WINAPI IDirect3DDevice9Impl_CreateVertexBuffer(LPDIRECT3DDEVICE9EX iface,
+ UINT Size, DWORD Usage, DWORD FVF, D3DPOOL Pool,
+ IDirect3DVertexBuffer9** ppVertexBuffer, HANDLE* pSharedHandle) {
+
IDirect3DVertexBuffer9Impl *object;
IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
HRESULT hrc = D3D_OK;
object->lpVtbl = &Direct3DVertexBuffer9_Vtbl;
object->ref = 1;
object->fvf = FVF;
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DDevice_CreateVertexBuffer(This->WineD3DDevice, Size, Usage & WINED3DUSAGE_MASK,
0 /* fvf for ddraw only */, (WINED3DPOOL) Pool, &(object->wineD3DVertexBuffer), (IUnknown *)object);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
+
if (hrc != D3D_OK) {
/* free up object */
/* convert the declaration */
elements = HeapAlloc(GetProcessHeap(), 0, size * sizeof(D3DVERTEXELEMENT9));
- if (!elements) return D3DERR_OUTOFVIDEOMEMORY;
+ if (!elements)
+ return D3DERR_OUTOFVIDEOMEMORY;
elements[size-1] = end_element;
idx = 0;
/* Should not happen unless wine has a bug or the application releases references it does not own */
ERR("Destroying vdecl with ref != 0\n");
}
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DVertexDeclaration_Release(This->wineD3DVertexDeclaration);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
HeapFree(GetProcessHeap(), 0, This->elements);
HeapFree(GetProcessHeap(), 0, This);
}
TRACE("(%p) : Relay\n", iface);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DVertexDeclaration_GetDevice(This->wineD3DVertexDeclaration, &myDevice);
if (hr == D3D_OK && myDevice != NULL) {
hr = IWineD3DDevice_GetParent(myDevice, (IUnknown **)ppDevice);
IWineD3DDevice_Release(myDevice);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
}
/* IDirect3DDevice9 IDirect3DVertexDeclaration9 Methods follow: */
-HRESULT WINAPI IDirect3DDevice9Impl_CreateVertexDeclaration(IDirect3DDevice9Ex *iface,
- const D3DVERTEXELEMENT9 *pVertexElements, IDirect3DVertexDeclaration9 **ppDecl)
-{
+HRESULT WINAPI IDirect3DDevice9Impl_CreateVertexDeclaration(LPDIRECT3DDEVICE9EX iface, CONST D3DVERTEXELEMENT9* pVertexElements, IDirect3DVertexDeclaration9** ppDecl) {
+
IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
IDirect3DVertexDeclaration9Impl *object = NULL;
WINED3DVERTEXELEMENT* wined3d_elements;
CopyMemory(object->elements, pVertexElements, element_count * sizeof(D3DVERTEXELEMENT9));
object->element_count = element_count;
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_CreateVertexDeclaration(This->WineD3DDevice, &object->wineD3DVertexDeclaration,
(IUnknown *)object, wined3d_elements, wined3d_element_count);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
HeapFree(GetProcessHeap(), 0, wined3d_elements);
TRACE("(%p) : Relay\n", iface);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetVertexDeclaration(This->WineD3DDevice, pDeclImpl == NULL ? NULL : pDeclImpl->wineD3DVertexDeclaration);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
}
*ppDecl = NULL;
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetVertexDeclaration(This->WineD3DDevice, &pTest);
if (hr == D3D_OK && NULL != pTest) {
IWineD3DVertexDeclaration_GetParent(pTest, (IUnknown **)ppDecl);
} else {
*ppDecl = NULL;
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
TRACE("(%p) : returning %p\n", This, *ppDecl);
return hr;
}
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DVertexShader_Release(This->wineD3DVertexShader);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
IDirect3DDevice9Ex_Release(This->parentDevice);
HeapFree(GetProcessHeap(), 0, This);
}
HRESULT hr;
TRACE("(%p) : Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DVertexShader_GetDevice(This->wineD3DVertexShader, &myDevice);
if (WINED3D_OK == hr && myDevice != NULL) {
hr = IWineD3DDevice_GetParent(myDevice, (IUnknown **)ppDevice);
} else {
*ppDevice = NULL;
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
TRACE("(%p) returning (%p)\n", This, *ppDevice);
return hr;
}
HRESULT hr;
TRACE("(%p) : Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DVertexShader_GetFunction(This->wineD3DVertexShader, pData, pSizeOfData);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
object->ref = 1;
object->lpVtbl = &Direct3DVertexShader9_Vtbl;
-
- wined3d_mutex_lock();
- hrc= IWineD3DDevice_CreateVertexShader(This->WineD3DDevice, pFunction,
- NULL /* output signature */, &object->wineD3DVertexShader, (IUnknown *)object);
- wined3d_mutex_unlock();
+ EnterCriticalSection(&d3d9_cs);
+ hrc= IWineD3DDevice_CreateVertexShader(This->WineD3DDevice, NULL /* declaration */, pFunction, &object->wineD3DVertexShader, (IUnknown *)object);
+ LeaveCriticalSection(&d3d9_cs);
if (FAILED(hrc)) {
HRESULT hrc = D3D_OK;
TRACE("(%p) : Relay\n", This);
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DDevice_SetVertexShader(This->WineD3DDevice, pShader==NULL?NULL:((IDirect3DVertexShader9Impl *)pShader)->wineD3DVertexShader);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
TRACE("(%p) : returning hr(%u)\n", This, hrc);
return hrc;
HRESULT hrc = D3D_OK;
TRACE("(%p) : Relay device@%p\n", This, This->WineD3DDevice);
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hrc = IWineD3DDevice_GetVertexShader(This->WineD3DDevice, &pShader);
if (SUCCEEDED(hrc))
{
{
WARN("(%p) : Call to IWineD3DDevice_GetVertexShader failed %u (device %p)\n", This, hrc, This->WineD3DDevice);
}
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
TRACE("(%p) : returning %p\n", This, *ppShader);
return hrc;
}
return D3DERR_INVALIDCALL;
}
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetVertexShaderConstantF(This->WineD3DDevice, Register, pConstantData, Vector4fCount);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
}
TRACE("(%p) : Relay\n", This);
-
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetVertexShaderConstantF(This->WineD3DDevice, Register, pConstantData, Vector4fCount);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) : Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetVertexShaderConstantI(This->WineD3DDevice, Register, pConstantData, Vector4iCount);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) : Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetVertexShaderConstantI(This->WineD3DDevice, Register, pConstantData, Vector4iCount);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) : Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_SetVertexShaderConstantB(This->WineD3DDevice, Register, pConstantData, BoolCount);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
HRESULT hr;
TRACE("(%p) : Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DDevice_GetVertexShaderConstantB(This->WineD3DDevice, Register, pConstantData, BoolCount);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) : ReleaseRef to %d\n", This, ref);
if (ref == 0) {
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DVolume_Release(This->wineD3DVolume);
- wined3d_mutex_unlock();
-
+ LeaveCriticalSection(&d3d9_cs);
HeapFree(GetProcessHeap(), 0, This);
}
TRACE("iface %p, ppDevice %p\n", iface, ppDevice);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
IWineD3DVolume_GetDevice(This->wineD3DVolume, &myDevice);
IWineD3DDevice_GetParent(myDevice, (IUnknown **)ppDevice);
IWineD3DDevice_Release(myDevice);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
return D3D_OK;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DVolume_SetPrivateData(This->wineD3DVolume, refguid, pData, SizeOfData, Flags);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DVolume_GetPrivateData(This->wineD3DVolume, refguid, pData, pSizeOfData);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
TRACE("(%p) Relay\n", This);
- wined3d_mutex_lock();
+ EnterCriticalSection(&d3d9_cs);
hr = IWineD3DVolume_FreePrivateData(This->wineD3DVolume, refguid);
- wined3d_mutex_unlock();
+ LeaveCriticalSection(&d3d9_cs);
return hr;
}
projects / reactos.git / commitdiff