lucent/cocco-ddraw
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactoring

Browse source
This commit is contained in:
FunkyFr3sh 2021-06-11 20:30:43 +02:00
parent fa19797956
commit 1f11bf8b84
52 changed files with 2596 additions and 2071 deletions
Download patch file Download diff file Expand all files Collapse all files

62
src/IAMMediaStream/IAMMediaStream.c
View file

@ -3,126 +3,126 @@
HRESULT __stdcall IAMMediaStream__QueryInterface(IAMMediaStreamImpl* This, REFIID riid, void** obj)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, obj);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED -> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, obj);
HRESULT ret = E_NOINTERFACE;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
ULONG __stdcall IAMMediaStream__AddRef(IAMMediaStreamImpl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = ++This->ref;
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
ULONG __stdcall IAMMediaStream__Release(IAMMediaStreamImpl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = --This->ref;
if (This->ref == 0)
{
dprintf(" Released (%p)\n", This);
TRACE(" Released (%p)\n", This);
HeapFree(GetProcessHeap(), 0, This);
}
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
HRESULT WINAPI IAMMediaStream__GetMultiMediaStream(IAMMediaStreamImpl* This, int a)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT WINAPI IAMMediaStream__GetInformation(IAMMediaStreamImpl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT WINAPI IAMMediaStream__SetSameFormat(IAMMediaStreamImpl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT WINAPI IAMMediaStream__AllocateSample(IAMMediaStreamImpl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT WINAPI IAMMediaStream__CreateSharedSample(IAMMediaStreamImpl* This, int a, int b, int c)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT WINAPI IAMMediaStream__SendEndOfStream(IAMMediaStreamImpl* This, int a)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
// IAMMediaStream
HRESULT WINAPI IAMMediaStream__Initialize(IAMMediaStreamImpl* This, int a, int b, int c, int d)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT WINAPI IAMMediaStream__SetState(IAMMediaStreamImpl* This, int a)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT WINAPI IAMMediaStream__JoinAMMultiMediaStream(IAMMediaStreamImpl* This, int a)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT WINAPI IAMMediaStream__JoinFilter(IAMMediaStreamImpl* This, int a)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT WINAPI IAMMediaStream__JoinFilterGraph(IAMMediaStreamImpl* This, int a)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
struct IAMMediaStreamImplVtbl g_ms_vtbl =
{
/* IUnknown */

38
src/IDirect3D/IDirect3D.c
View file

@ -4,82 +4,82 @@
HRESULT __stdcall IDirect3D__QueryInterface(IDirect3DImpl* This, REFIID riid, void** obj)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, obj);
TRACE("NOT_IMPLEMENTED -> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, obj);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
ULONG __stdcall IDirect3D__AddRef(IDirect3DImpl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = ++This->ref;
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
ULONG __stdcall IDirect3D__Release(IDirect3DImpl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = --This->ref;
if (This->ref == 0)
{
dprintf(" Released (%p)\n", This);
TRACE(" Released (%p)\n", This);
HeapFree(GetProcessHeap(), 0, This);
}
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
HRESULT __stdcall IDirect3D__Initialize(IDirect3DImpl* This, int a)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D__EnumDevices(IDirect3DImpl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D__CreateLight(IDirect3DImpl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D__CreateMaterial(IDirect3DImpl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D__CreateViewport(IDirect3DImpl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D__FindDevice(IDirect3DImpl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}

38
src/IDirect3D/IDirect3D2.c
View file

@ -4,82 +4,82 @@
HRESULT __stdcall IDirect3D2__QueryInterface(IDirect3D2Impl* This, REFIID riid, void** obj)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, obj);
TRACE("NOT_IMPLEMENTED -> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, obj);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
ULONG __stdcall IDirect3D2__AddRef(IDirect3D2Impl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = ++This->ref;
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
ULONG __stdcall IDirect3D2__Release(IDirect3D2Impl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = --This->ref;
if (This->ref == 0)
{
dprintf(" Released (%p)\n", This);
TRACE(" Released (%p)\n", This);
HeapFree(GetProcessHeap(), 0, This);
}
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
HRESULT __stdcall IDirect3D2__EnumDevices(IDirect3D2Impl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D2__CreateLight(IDirect3D2Impl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D2__CreateMaterial(IDirect3D2Impl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D2__CreateViewport(IDirect3D2Impl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D2__FindDevice(IDirect3D2Impl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D2__CreateDevice(IDirect3D2Impl* This, int a, int b, int c)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}

50
src/IDirect3D/IDirect3D3.c
View file

@ -4,106 +4,106 @@
HRESULT __stdcall IDirect3D3__QueryInterface(IDirect3D3Impl* This, REFIID riid, void** obj)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, obj);
TRACE("NOT_IMPLEMENTED -> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, obj);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
ULONG __stdcall IDirect3D3__AddRef(IDirect3D3Impl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = ++This->ref;
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
ULONG __stdcall IDirect3D3__Release(IDirect3D3Impl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = --This->ref;
if (This->ref == 0)
{
dprintf(" Released (%p)\n", This);
TRACE(" Released (%p)\n", This);
HeapFree(GetProcessHeap(), 0, This);
}
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
HRESULT __stdcall IDirect3D3__EnumDevices(IDirect3D3Impl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D3__CreateLight(IDirect3D3Impl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D3__CreateMaterial(IDirect3D3Impl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D3__CreateViewport(IDirect3D3Impl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D3__FindDevice(IDirect3D3Impl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D3__CreateDevice(IDirect3D3Impl* This, int a, int b, int c, int d)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D3__CreateVertexBuffer(IDirect3D3Impl* This, int a, int b, int c, int d)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D3__EnumZBufferFormats(IDirect3D3Impl* This, int a, int b, int c)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D3__EvictManagedTextures(IDirect3D3Impl* This)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}

34
src/IDirect3D/IDirect3D7.c
View file

@ -4,74 +4,74 @@
HRESULT __stdcall IDirect3D7__QueryInterface(IDirect3D7Impl* This, REFIID riid, void** obj)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, obj);
TRACE("NOT_IMPLEMENTED -> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, obj);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
ULONG __stdcall IDirect3D7__AddRef(IDirect3D7Impl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = ++This->ref;
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
ULONG __stdcall IDirect3D7__Release(IDirect3D7Impl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = --This->ref;
if (This->ref == 0)
{
dprintf(" Released (%p)\n", This);
TRACE(" Released (%p)\n", This);
HeapFree(GetProcessHeap(), 0, This);
}
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
HRESULT __stdcall IDirect3D7__EnumDevices(IDirect3D7Impl* This, int a, int b)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D7__CreateDevice(IDirect3D7Impl* This, int a, int b, int c)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D7__CreateVertexBuffer(IDirect3D7Impl* This, int a, int b, int c)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D7__EnumZBufferFormats(IDirect3D7Impl* This, int a, int b, int c)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirect3D7__EvictManagedTextures(IDirect3D7Impl* This)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = E_FAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}

349
src/IDirectDraw/IDirectDraw.c
View file

@ -9,9 +9,10 @@
#include "debug.h"
HRESULT __stdcall IDirectDraw__QueryInterface(IDirectDrawImpl* This, REFIID riid, void** obj)
HRESULT __stdcall IDirectDraw__QueryInterface(IDirectDrawImpl* This, REFIID riid, LPVOID FAR* ppvObj)
{
dprintf("-> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, obj);
TRACE("-> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, ppvObj);
HRESULT ret = DDERR_UNSUPPORTED;
if (riid)
@ -20,91 +21,97 @@ HRESULT __stdcall IDirectDraw__QueryInterface(IDirectDrawImpl* This, REFIID riid
IsEqualGUID(&IID_IDirectDraw4, riid) ||
IsEqualGUID(&IID_IDirectDraw7, riid))
{
IDirectDrawImpl* dd = (IDirectDrawImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawImpl));
dprintf(" GUID = %08X (IID_IDirectDrawX), ddraw = %p\n", ((GUID*)riid)->Data1, dd);
IDirectDrawImpl* dd =
(IDirectDrawImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawImpl));
TRACE(" GUID = %08X (IID_IDirectDrawX), ddraw = %p\n", ((GUID*)riid)->Data1, dd);
dd->lpVtbl = &g_dd_vtblx;
IDirectDraw_AddRef(dd);
*obj = dd;
*ppvObj = dd;
ret = S_OK;
}
else if (IsEqualGUID(&IID_IDirectDraw, riid))
{
IDirectDrawImpl* dd = (IDirectDrawImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawImpl));
dprintf(" GUID = %08X (IID_IDirectDraw), ddraw = %p\n", ((GUID*)riid)->Data1, dd);
IDirectDrawImpl* dd =
(IDirectDrawImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawImpl));
TRACE(" GUID = %08X (IID_IDirectDraw), ddraw = %p\n", ((GUID*)riid)->Data1, dd);
dd->lpVtbl = &g_dd_vtbl1;
IDirectDraw_AddRef(dd);
*obj = dd;
*ppvObj = dd;
ret = S_OK;
}
else if (IsEqualGUID(&IID_IDirect3D, riid))
{
IDirect3DImpl* d3d = (IDirect3DImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DImpl));
dprintf(" GUID = %08X (IID_IDirect3D), d3d = %p\n", ((GUID*)riid)->Data1, d3d);
IDirect3DImpl* d3d =
(IDirect3DImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DImpl));
TRACE(" GUID = %08X (IID_IDirect3D), d3d = %p\n", ((GUID*)riid)->Data1, d3d);
d3d->lpVtbl = &g_d3d_vtbl;
d3d->lpVtbl->AddRef(d3d);
*obj = d3d;
*ppvObj = d3d;
ret = S_OK;
}
else if (IsEqualGUID(&IID_IDirect3D2, riid))
{
IDirect3D2Impl* d3d = (IDirect3D2Impl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3D2Impl));
IDirect3D2Impl* d3d =
(IDirect3D2Impl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3D2Impl));
dprintf(" GUID = %08X (IID_IDirect3D2), d3d = %p\n", ((GUID*)riid)->Data1, d3d);
TRACE(" GUID = %08X (IID_IDirect3D2), d3d = %p\n", ((GUID*)riid)->Data1, d3d);
d3d->lpVtbl = &g_d3d2_vtbl;
d3d->lpVtbl->AddRef(d3d);
*obj = d3d;
*ppvObj = d3d;
ret = S_OK;
}
else if (IsEqualGUID(&IID_IDirect3D3, riid))
{
IDirect3D3Impl* d3d = (IDirect3D3Impl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3D3Impl));
IDirect3D3Impl* d3d =
(IDirect3D3Impl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3D3Impl));
dprintf(" GUID = %08X (IID_IDirect3D3), d3d = %p\n", ((GUID*)riid)->Data1, d3d);
TRACE(" GUID = %08X (IID_IDirect3D3), d3d = %p\n", ((GUID*)riid)->Data1, d3d);
d3d->lpVtbl = &g_d3d3_vtbl;
d3d->lpVtbl->AddRef(d3d);
*obj = d3d;
*ppvObj = d3d;
ret = S_OK;
}
else if (IsEqualGUID(&IID_IDirect3D7, riid))
{
IDirect3D7Impl* d3d = (IDirect3D7Impl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3D7Impl));
IDirect3D7Impl* d3d =
(IDirect3D7Impl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3D7Impl));
dprintf(" GUID = %08X (IID_IDirect3D7), d3d = %p\n", ((GUID*)riid)->Data1, d3d);
TRACE(" GUID = %08X (IID_IDirect3D7), d3d = %p\n", ((GUID*)riid)->Data1, d3d);
d3d->lpVtbl = &g_d3d7_vtbl;
d3d->lpVtbl->AddRef(d3d);
*obj = d3d;
*ppvObj = d3d;
ret = S_OK;
}
/*
else if (
!g_ddraw->passthrough &&
!g_ddraw->passthrough &&
(IsEqualGUID(&IID_IMediaStream, riid) || IsEqualGUID(&IID_IAMMediaStream, riid)))
{
IAMMediaStreamImpl* ms =
IAMMediaStreamImpl* ms =
(IAMMediaStreamImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IAMMediaStreamImpl));
dprintf(" GUID = %08X (IID_IXXMediaStream), ms = %p\n", ((GUID*)riid)->Data1, ms);
TRACE(" GUID = %08X (IID_IXXMediaStream), ms = %p\n", ((GUID*)riid)->Data1, ms);
ms->lpVtbl = &g_ms_vtbl;
ms->lpVtbl->AddRef(ms);
@ -116,7 +123,7 @@ HRESULT __stdcall IDirectDraw__QueryInterface(IDirectDrawImpl* This, REFIID riid
*/
else
{
dprintf("NOT_IMPLEMENTED GUID = %08X\n", ((GUID*)riid)->Data1);
TRACE("NOT_IMPLEMENTED GUID = %08X\n", ((GUID*)riid)->Data1);
if (!g_ddraw->real_dll)
g_ddraw->real_dll = LoadLibrary("system32\\ddraw.dll");
@ -131,275 +138,363 @@ HRESULT __stdcall IDirectDraw__QueryInterface(IDirectDrawImpl* This, REFIID riid
g_ddraw->DirectDrawCreate(NULL, &g_ddraw->real_dd, NULL);
if (g_ddraw->real_dd)
return IDirectDraw_QueryInterface(g_ddraw->real_dd, riid, obj);
return IDirectDraw_QueryInterface(g_ddraw->real_dd, riid, ppvObj);
ret = E_NOINTERFACE;
}
}
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
ULONG __stdcall IDirectDraw__AddRef(IDirectDrawImpl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = ++This->ref;
ULONG glob_ref = dd_AddRef();
dprintf("<- %s(This ref=%u, global ref=%u)\n", __FUNCTION__, ret, glob_ref);
TRACE("<- %s(This ref=%u, global ref=%u)\n", __FUNCTION__, ret, glob_ref);
return ret;
}
ULONG __stdcall IDirectDraw__Release(IDirectDrawImpl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = --This->ref;
if (This->ref == 0)
{
dprintf(" Released (%p)\n", This);
TRACE(" Released (%p)\n", This);
HeapFree(GetProcessHeap(), 0, This);
}
ULONG glob_ref = dd_Release();
dprintf("<- %s(This ref=%u, global ref=%u)\n", __FUNCTION__, ret, glob_ref);
TRACE("<- %s(This ref=%u, global ref=%u)\n", __FUNCTION__, ret, glob_ref);
return ret;
}
HRESULT __stdcall IDirectDraw__Compact(IDirectDrawImpl* This)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__CreateClipper(IDirectDrawImpl* This, DWORD dwFlags, LPDIRECTDRAWCLIPPER FAR* lplpDDClipper, IUnknown FAR* pUnkOuter)
HRESULT __stdcall IDirectDraw__CreateClipper(
IDirectDrawImpl* This,
DWORD dwFlags,
LPDIRECTDRAWCLIPPER FAR* lplpDDClipper,
IUnknown FAR* pUnkOuter)
{
dprintf("-> %s(This=%p, dwFlags=%08X, DDClipper=%p, unkOuter=%p)\n", __FUNCTION__, This, (int)dwFlags, lplpDDClipper, pUnkOuter);
HRESULT ret = dd_CreateClipper(dwFlags, lplpDDClipper, pUnkOuter);
dprintf("<- %s\n", __FUNCTION__);
TRACE(
"-> %s(This=%p, dwFlags=%08X, DDClipper=%p, unkOuter=%p)\n",
__FUNCTION__,
This,
dwFlags,
lplpDDClipper,
pUnkOuter);
HRESULT ret = dd_CreateClipper(dwFlags, (IDirectDrawClipperImpl**)lplpDDClipper, pUnkOuter);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__CreatePalette(IDirectDrawImpl* This, DWORD dwFlags, LPPALETTEENTRY lpDDColorArray, LPDIRECTDRAWPALETTE FAR* lpDDPalette, IUnknown FAR* unkOuter)
HRESULT __stdcall IDirectDraw__CreatePalette(
IDirectDrawImpl* This,
DWORD dwFlags,
LPPALETTEENTRY lpDDColorArray,
LPDIRECTDRAWPALETTE FAR* lpDDPalette,
IUnknown FAR* unkOuter)
{
dprintf("-> %s(This=%p, dwFlags=%08X, DDColorArray=%p, DDPalette=%p, unkOuter=%p)\n", __FUNCTION__, This, (int)dwFlags, lpDDColorArray, lpDDPalette, unkOuter);
HRESULT ret = dd_CreatePalette(dwFlags, lpDDColorArray, lpDDPalette, unkOuter);
dprintf("<- %s\n", __FUNCTION__);
TRACE(
"-> %s(This=%p, dwFlags=%08X, DDColorArray=%p, DDPalette=%p, unkOuter=%p)\n",
__FUNCTION__,
This,
dwFlags,
lpDDColorArray,
lpDDPalette,
unkOuter);
HRESULT ret = dd_CreatePalette(dwFlags, lpDDColorArray, (IDirectDrawPaletteImpl**)lpDDPalette, unkOuter);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__CreateSurface(IDirectDrawImpl* This, LPDDSURFACEDESC lpDDSurfaceDesc, LPDIRECTDRAWSURFACE FAR* lpDDSurface, IUnknown FAR* unkOuter)
HRESULT __stdcall IDirectDraw__CreateSurface(
IDirectDrawImpl* This,
LPDDSURFACEDESC2 lpDDSurfaceDesc,
LPDIRECTDRAWSURFACE7 FAR* lpDDSurface,
IUnknown FAR* unkOuter)
{
dprintf("-> %s(This=%p, lpDDSurfaceDesc=%p, lpDDSurface=%p, unkOuter=%p)\n", __FUNCTION__, This, lpDDSurfaceDesc, lpDDSurface, unkOuter);
HRESULT ret = dd_CreateSurface(This, lpDDSurfaceDesc, lpDDSurface, unkOuter);
dprintf("<- %s\n", __FUNCTION__);
TRACE(
"-> %s(This=%p, lpDDSurfaceDesc=%p, lpDDSurface=%p, unkOuter=%p)\n",
__FUNCTION__,
This,
lpDDSurfaceDesc,
lpDDSurface,
unkOuter);
HRESULT ret = dd_CreateSurface(This, lpDDSurfaceDesc, (IDirectDrawSurfaceImpl**)lpDDSurface, unkOuter);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__DuplicateSurface(IDirectDrawImpl* This, LPDIRECTDRAWSURFACE src, LPDIRECTDRAWSURFACE* dest)
HRESULT __stdcall IDirectDraw__DuplicateSurface(
IDirectDrawImpl* This,
LPDIRECTDRAWSURFACE7 lpDDSrcSurface,
LPDIRECTDRAWSURFACE7* lpDDDestSurface)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_CANTDUPLICATE;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__EnumDisplayModes(IDirectDrawImpl* This, DWORD dwFlags, LPDDSURFACEDESC lpDDSurfaceDesc, LPVOID lpContext, LPDDENUMMODESCALLBACK lpEnumModesCallback)
HRESULT __stdcall IDirectDraw__EnumDisplayModes(
IDirectDrawImpl* This,
DWORD dwFlags,
LPDDSURFACEDESC2 lpDDSurfaceDesc,
LPVOID lpContext,
LPDDENUMMODESCALLBACK2 lpEnumModesCallback)
{
dprintf("-> %s(This=%p, dwFlags=%08X, lpDDSurfaceDesc=%p, lpContext=%p, lpEnumModesCallback=%p)\n", __FUNCTION__, This, (unsigned int)dwFlags, lpDDSurfaceDesc, lpContext, lpEnumModesCallback);
TRACE(
"-> %s(This=%p, dwFlags=%08X, lpDDSurfaceDesc=%p, lpContext=%p, lpEnumModesCallback=%p)\n",
__FUNCTION__,
This,
dwFlags,
lpDDSurfaceDesc,
lpContext,
lpEnumModesCallback);
HRESULT ret = dd_EnumDisplayModes(dwFlags, lpDDSurfaceDesc, lpContext, lpEnumModesCallback);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__EnumSurfaces(IDirectDrawImpl* This, DWORD a, LPDDSURFACEDESC b, LPVOID c, LPDDENUMSURFACESCALLBACK d)
HRESULT __stdcall IDirectDraw__EnumSurfaces(
IDirectDrawImpl* This,
DWORD dwFlags,
LPDDSURFACEDESC2 lpDDSurfaceDesc,
LPVOID lpContext,
LPDDENUMSURFACESCALLBACK7 lpEnumSurfacesCallback)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__FlipToGDISurface(IDirectDrawImpl* This)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__GetCaps(IDirectDrawImpl* This, LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDEmulCaps)
{
dprintf("-> %s(This=%p, lpDDDriverCaps=%p, lpDDEmulCaps=%p)\n", __FUNCTION__, This, lpDDDriverCaps, lpDDEmulCaps);
TRACE("-> %s(This=%p, lpDDDriverCaps=%p, lpDDEmulCaps=%p)\n", __FUNCTION__, This, lpDDDriverCaps, lpDDEmulCaps);
HRESULT ret = dd_GetCaps(lpDDDriverCaps, lpDDEmulCaps);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__GetDisplayMode(IDirectDrawImpl* This, LPDDSURFACEDESC lpDDSurfaceDesc)
HRESULT __stdcall IDirectDraw__GetDisplayMode(IDirectDrawImpl* This, LPDDSURFACEDESC2 lpDDSurfaceDesc)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = dd_GetDisplayMode(lpDDSurfaceDesc);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__GetFourCCCodes(IDirectDrawImpl* This, LPDWORD a, LPDWORD b)
HRESULT __stdcall IDirectDraw__GetFourCCCodes(IDirectDrawImpl* This, LPDWORD lpNumCodes, LPDWORD lpCodes)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_INVALIDOBJECT;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__GetGDISurface(IDirectDrawImpl* This, LPDIRECTDRAWSURFACE* a)
HRESULT __stdcall IDirectDraw__GetGDISurface(IDirectDrawImpl* This, LPDIRECTDRAWSURFACE7* lplpGDIDDSurface)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_NOTFOUND;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__GetMonitorFrequency(IDirectDrawImpl* This, LPDWORD lpdwFreq)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = dd_GetMonitorFrequency(lpdwFreq);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__GetScanLine(IDirectDrawImpl* This, LPDWORD a)
HRESULT __stdcall IDirectDraw__GetScanLine(IDirectDrawImpl* This, LPDWORD lpdwScanLine)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_UNSUPPORTED;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__GetVerticalBlankStatus(IDirectDrawImpl* This, LPBOOL lpbIsInVB)
{
dprintf("-> %s(This=%p, lpbIsInVB=%p)\n", __FUNCTION__, This, lpbIsInVB);
TRACE("-> %s(This=%p, lpbIsInVB=%p)\n", __FUNCTION__, This, lpbIsInVB);
HRESULT ret = dd_GetVerticalBlankStatus(lpbIsInVB);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__Initialize(IDirectDrawImpl* This, GUID* a)
HRESULT __stdcall IDirectDraw__Initialize(IDirectDrawImpl* This, GUID* lpGUID)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__RestoreDisplayMode(IDirectDrawImpl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = dd_RestoreDisplayMode();
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__SetCooperativeLevel(IDirectDrawImpl* This, HWND hwnd, DWORD dwFlags)
{
dprintf("-> %s(This=%p, hwnd=0x%08X, dwFlags=0x%08X)\n", __FUNCTION__, This, (unsigned int)hwnd, (unsigned int)dwFlags);
TRACE("-> %s(This=%p, hwnd=%p, dwFlags=0x%08X)\n", __FUNCTION__, This, hwnd, dwFlags);
HRESULT ret = dd_SetCooperativeLevel(hwnd, dwFlags);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__SetDisplayMode(IDirectDrawImpl* This, DWORD width, DWORD height, DWORD bpp)
HRESULT __stdcall IDirectDraw__SetDisplayMode(IDirectDrawImpl* This, DWORD dwWidth, DWORD dwHeight, DWORD dwBPP)
{
dprintf("-> %s(This=%p, width=%d, height=%d, bpp=%d)\n", __FUNCTION__, This, (unsigned int)width, (unsigned int)height, (unsigned int)bpp);
HRESULT ret = dd_SetDisplayMode(width, height, bpp, TRUE);
dprintf("<- %s\n", __FUNCTION__);
TRACE("-> %s(This=%p, width=%d, height=%d, bpp=%d)\n", __FUNCTION__, This, dwWidth, dwHeight, dwBPP);
HRESULT ret = dd_SetDisplayMode(dwWidth, dwHeight, dwBPP, TRUE);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__SetDisplayModeX(IDirectDrawImpl* This, DWORD width, DWORD height, DWORD bpp, DWORD refreshRate, DWORD flags)
HRESULT __stdcall IDirectDraw__SetDisplayModeX(
IDirectDrawImpl* This,
DWORD dwWidth,
DWORD dwHeight,
DWORD dwBPP,
DWORD dwRefreshRate,
DWORD dwFlags)
{
dprintf("-> %s(This=%p, width=%d, height=%d, bpp=%d, refreshRate=%d, flags=%d)\n", __FUNCTION__, This, (unsigned int)width, (unsigned int)height, (unsigned int)bpp, (unsigned int)refreshRate, (unsigned int)flags);
HRESULT ret = dd_SetDisplayMode(width, height, bpp, TRUE);
dprintf("<- %s\n", __FUNCTION__);
TRACE(
"-> %s(This=%p, width=%d, height=%d, bpp=%d, refreshRate=%d, flags=%d)\n",
__FUNCTION__,
This,
dwWidth,
dwHeight,
dwBPP,
dwRefreshRate,
dwFlags);
HRESULT ret = dd_SetDisplayMode(dwWidth, dwHeight, dwBPP, TRUE);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__WaitForVerticalBlank(IDirectDrawImpl* This, DWORD dwFlags, HANDLE h)
HRESULT __stdcall IDirectDraw__WaitForVerticalBlank(IDirectDrawImpl* This, DWORD dwFlags, HANDLE hEvent)
{
dprintfex("-> %s(This=%p, flags=%08X, handle=%p)\n", __FUNCTION__, This, dwFlags, h);
HRESULT ret = dd_WaitForVerticalBlank(dwFlags, h);
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT("-> %s(This=%p, flags=%08X, handle=%p)\n", __FUNCTION__, This, dwFlags, hEvent);
HRESULT ret = dd_WaitForVerticalBlank(dwFlags, hEvent);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__GetAvailableVidMem(IDirectDrawImpl* This, void* lpDDCaps, LPDWORD lpdwTotal, LPDWORD lpdwFree)
HRESULT __stdcall IDirectDraw__GetAvailableVidMem(
IDirectDrawImpl* This,
LPDDSCAPS2 lpDDCaps,
LPDWORD lpdwTotal,
LPDWORD lpdwFree)
{
dprintf("-> %s(This=%p, lpDDCaps=%p, lpdwTotal=%p, lpdwFree=%p)\n", __FUNCTION__, This, lpDDCaps, lpdwTotal, lpdwFree);
TRACE(
"-> %s(This=%p, lpDDCaps=%p, lpdwTotal=%p, lpdwFree=%p)\n",
__FUNCTION__,
This,
lpDDCaps,
lpdwTotal,
lpdwFree);
HRESULT ret = dd_GetAvailableVidMem(lpDDCaps, lpdwTotal, lpdwFree);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__GetSurfaceFromDC(IDirectDrawImpl* This, HDC hdc, void* lplpDDSurface)
HRESULT __stdcall IDirectDraw__GetSurfaceFromDC(IDirectDrawImpl* This, HDC hdc, LPDIRECTDRAWSURFACE7* lplpDDSurface)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_GENERIC;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_NOTFOUND;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__RestoreAllSurfaces(IDirectDrawImpl* This)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__TestCooperativeLevel(IDirectDrawImpl* This)
{
dprintfex("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE_EXT("-> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__GetDeviceIdentifier(IDirectDrawImpl* This, void* pDDDI, DWORD dwFlags)
HRESULT __stdcall IDirectDraw__GetDeviceIdentifier(IDirectDrawImpl* This, LPDDDEVICEIDENTIFIER2 pDDDI, DWORD dwFlags)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_INVALIDPARAMS;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__StartModeTest(IDirectDrawImpl* This, LPSIZE pModes, DWORD dwNumModes, DWORD dwFlags)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_CURRENTLYNOTAVAIL;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDraw__EvaluateMode(IDirectDrawImpl* This, DWORD dwFlags, DWORD* pTimeout)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_INVALIDOBJECT;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
struct IDirectDrawImplVtbl g_dd_vtbl1 =
{
/* IUnknown */
/*** IUnknown methods ***/
IDirectDraw__QueryInterface,
IDirectDraw__AddRef,
IDirectDraw__Release,
/* IDirectDrawImpl */
/*** IDirectDraw methods ***/
IDirectDraw__Compact,
IDirectDraw__CreateClipper,
IDirectDraw__CreatePalette,
@ -420,25 +515,25 @@ struct IDirectDrawImplVtbl g_dd_vtbl1 =
IDirectDraw__SetCooperativeLevel,
{IDirectDraw__SetDisplayMode},
IDirectDraw__WaitForVerticalBlank,
// v2
/*** Added in the v2 Interface ***/
IDirectDraw__GetAvailableVidMem,
// v4
/*** Added in the v4 Interface ***/
IDirectDraw__GetSurfaceFromDC,
IDirectDraw__RestoreAllSurfaces,
IDirectDraw__TestCooperativeLevel,
IDirectDraw__GetDeviceIdentifier,
// v7
/*** Added in the v7 Interface ***/
IDirectDraw__StartModeTest,
IDirectDraw__EvaluateMode,
};
struct IDirectDrawImplVtbl g_dd_vtblx =
{
/* IUnknown */
/*** IUnknown methods ***/
IDirectDraw__QueryInterface,
IDirectDraw__AddRef,
IDirectDraw__Release,
/* IDirectDrawImpl */
/*** IDirectDraw methods ***/
IDirectDraw__Compact,
IDirectDraw__CreateClipper,
IDirectDraw__CreatePalette,
@ -459,14 +554,14 @@ struct IDirectDrawImplVtbl g_dd_vtblx =
IDirectDraw__SetCooperativeLevel,
{IDirectDraw__SetDisplayModeX},
IDirectDraw__WaitForVerticalBlank,
// v2
/*** Added in the v2 interface ***/
IDirectDraw__GetAvailableVidMem,
// v4
/*** Added in the v4 Interface ***/
IDirectDraw__GetSurfaceFromDC,
IDirectDraw__RestoreAllSurfaces,
IDirectDraw__TestCooperativeLevel,
IDirectDraw__GetDeviceIdentifier,
// v7
/*** Added in the v7 Interface ***/
IDirectDraw__StartModeTest,
IDirectDraw__EvaluateMode,
};

72
src/IDirectDraw/IDirectDrawClipper.c
View file

@ -2,94 +2,98 @@
#include "ddclipper.h"
#include "debug.h"
HRESULT __stdcall IDirectDrawClipper__QueryInterface(IDirectDrawClipperImpl *This, REFIID riid, void **obj)
HRESULT __stdcall IDirectDrawClipper__QueryInterface(IDirectDrawClipperImpl* This, REFIID riid, LPVOID FAR* ppvObj)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, obj);
HRESULT ret = S_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED -> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, ppvObj);
HRESULT ret = E_NOINTERFACE;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
ULONG __stdcall IDirectDrawClipper__AddRef(IDirectDrawClipperImpl *This)
ULONG __stdcall IDirectDrawClipper__AddRef(IDirectDrawClipperImpl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = ++This->ref;
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
ULONG __stdcall IDirectDrawClipper__Release(IDirectDrawClipperImpl *This)
ULONG __stdcall IDirectDrawClipper__Release(IDirectDrawClipperImpl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = --This->ref;
if (This->ref == 0)
{
dprintf(" Released (%p)\n", This);
TRACE(" Released (%p)\n", This);
HeapFree(GetProcessHeap(), 0, This);
}
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
HRESULT __stdcall IDirectDrawClipper__GetClipList(IDirectDrawClipperImpl *This, LPRECT a, LPRGNDATA b, LPDWORD c)
HRESULT __stdcall IDirectDrawClipper__GetClipList(
IDirectDrawClipperImpl* This,
LPRECT lpRect,
LPRGNDATA lpClipList,
LPDWORD lpdwSiz)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_NOCLIPLIST;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawClipper__GetHWnd(IDirectDrawClipperImpl *This, HWND FAR *a)
HRESULT __stdcall IDirectDrawClipper__GetHWnd(IDirectDrawClipperImpl* This, HWND FAR* lphWnd)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_INVALIDOBJECT;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawClipper__Initialize(IDirectDrawClipperImpl *This, LPDIRECTDRAW a, DWORD b)
HRESULT __stdcall IDirectDrawClipper__Initialize(IDirectDrawClipperImpl* This, LPDIRECTDRAW lpDD, DWORD dwFlags)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawClipper__IsClipListChanged(IDirectDrawClipperImpl *This, BOOL FAR *a)
HRESULT __stdcall IDirectDrawClipper__IsClipListChanged(IDirectDrawClipperImpl* This, BOOL FAR* lpbChanged)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_INVALIDOBJECT;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawClipper__SetClipList(IDirectDrawClipperImpl *This, LPRGNDATA a, DWORD b)
HRESULT __stdcall IDirectDrawClipper__SetClipList(IDirectDrawClipperImpl* This, LPRGNDATA lpClipList, DWORD dwFlags)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawClipper__SetHWnd(IDirectDrawClipperImpl *This, DWORD a, HWND b)
HRESULT __stdcall IDirectDrawClipper__SetHWnd(IDirectDrawClipperImpl* This, DWORD dwFlags, HWND hWnd)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
struct IDirectDrawClipperImplVtbl g_ddc_vtbl =
{
/* IUnknown */
/*** IUnknown methods ***/
IDirectDrawClipper__QueryInterface,
IDirectDrawClipper__AddRef,
IDirectDrawClipper__Release,
/* IDirectDrawClipper */
/*** IDirectDrawClipper methods ***/
IDirectDrawClipper__GetClipList,
IDirectDrawClipper__GetHWnd,
IDirectDrawClipper__Initialize,

38
src/IDirectDraw/IDirectDrawGammaControl.c
View file

@ -1,62 +1,62 @@
#include "IDirectDrawGammaControl.h"
#include "debug.h"
HRESULT __stdcall IDirectDrawGammaControl__QueryInterface(IDirectDrawGammaControlImpl *This, REFIID riid, void **obj)
HRESULT __stdcall IDirectDrawGammaControl__QueryInterface(IDirectDrawGammaControlImpl* This, REFIID riid, LPVOID FAR* ppvObj)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, obj);
HRESULT ret = S_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED -> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, ppvObj);
HRESULT ret = E_NOINTERFACE;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
ULONG __stdcall IDirectDrawGammaControl__AddRef(IDirectDrawGammaControlImpl *This)
ULONG __stdcall IDirectDrawGammaControl__AddRef(IDirectDrawGammaControlImpl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = ++This->ref;
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
ULONG __stdcall IDirectDrawGammaControl__Release(IDirectDrawGammaControlImpl *This)
ULONG __stdcall IDirectDrawGammaControl__Release(IDirectDrawGammaControlImpl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = --This->ref;
if (This->ref == 0)
{
dprintf(" Released (%p)\n", This);
TRACE(" Released (%p)\n", This);
HeapFree(GetProcessHeap(), 0, This);
}
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
HRESULT __stdcall IDirectDrawGammaControl__GetGammaRamp(IDirectDrawGammaControlImpl *This, DWORD dwFlags, void *lpRampData)
HRESULT __stdcall IDirectDrawGammaControl__GetGammaRamp(IDirectDrawGammaControlImpl* This, DWORD dwFlags, LPDDGAMMARAMP lpRampData)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_EXCEPTION;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawGammaControl__SetGammaRamp(IDirectDrawGammaControlImpl *This, DWORD dwFlags, void *lpRampData)
HRESULT __stdcall IDirectDrawGammaControl__SetGammaRamp(IDirectDrawGammaControlImpl* This, DWORD dwFlags, LPDDGAMMARAMP lpRampData)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_EXCEPTION;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
struct IDirectDrawGammaControlImplVtbl g_ddgc_vtbl =
{
/* IUnknown */
/*** IUnknown methods ***/
IDirectDrawGammaControl__QueryInterface,
IDirectDrawGammaControl__AddRef,
IDirectDrawGammaControl__Release,
/* IDirectDrawGammaControl */
/*** IDirectDrawGammaControl methods ***/
IDirectDrawGammaControl__GetGammaRamp,
IDirectDrawGammaControl__SetGammaRamp,
};

80
src/IDirectDraw/IDirectDrawPalette.c
View file

@ -4,31 +4,31 @@
#include "debug.h"
HRESULT __stdcall IDirectDrawPalette__QueryInterface(IDirectDrawPaletteImpl* This, REFIID riid, void** obj)
HRESULT __stdcall IDirectDrawPalette__QueryInterface(IDirectDrawPaletteImpl* This, REFIID riid, LPVOID FAR* ppvObj)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, obj);
HRESULT ret = S_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED -> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, ppvObj);
HRESULT ret = E_NOINTERFACE;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
ULONG __stdcall IDirectDrawPalette__AddRef(IDirectDrawPaletteImpl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = ++This->ref;
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
ULONG __stdcall IDirectDrawPalette__Release(IDirectDrawPaletteImpl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = --This->ref;
if (This->ref == 0)
{
dprintf(" Released (%p)\n", This);
TRACE(" Released (%p)\n", This);
if (g_ddraw)
g_ddraw->last_freed_palette = This;
@ -36,49 +36,81 @@ ULONG __stdcall IDirectDrawPalette__Release(IDirectDrawPaletteImpl* This)
HeapFree(GetProcessHeap(), 0, This);
}
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
HRESULT __stdcall IDirectDrawPalette__GetCaps(IDirectDrawPaletteImpl* This, LPDWORD caps)
HRESULT __stdcall IDirectDrawPalette__GetCaps(IDirectDrawPaletteImpl* This, LPDWORD lpdwCaps)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p, caps=%p)\n", __FUNCTION__, This, caps);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED -> %s(This=%p, caps=%p)\n", __FUNCTION__, This, lpdwCaps);
HRESULT ret = DDERR_INVALIDOBJECT;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawPalette__GetEntries(IDirectDrawPaletteImpl *This, DWORD dwFlags, DWORD dwBase, DWORD dwNumEntries, LPPALETTEENTRY lpEntries)
HRESULT __stdcall IDirectDrawPalette__GetEntries(
IDirectDrawPaletteImpl* This,
DWORD dwFlags,
DWORD dwBase,
DWORD dwNumEntries,
LPPALETTEENTRY lpEntries)
{
dprintf("-> %s(This=%p, dwFlags=%08X, dwBase=%d, dwNumEntries=%d, lpEntries=%p)\n", __FUNCTION__, This, (int)dwFlags, (int)dwBase, (int)dwNumEntries, lpEntries);
TRACE(
"-> %s(This=%p, dwFlags=%08X, dwBase=%u, dwNumEntries=%u, lpEntries=%p)\n",
__FUNCTION__,
This,
dwFlags,
dwBase,
dwNumEntries,
lpEntries);
HRESULT ret = ddp_GetEntries(This, dwFlags, dwBase, dwNumEntries, lpEntries);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawPalette__Initialize(IDirectDrawPaletteImpl* This, LPDIRECTDRAW lpDD, DWORD dw, LPPALETTEENTRY paent)
HRESULT __stdcall IDirectDrawPalette__Initialize(
IDirectDrawPaletteImpl* This,
LPDIRECTDRAW lpDD,
DWORD dwFlags,
LPPALETTEENTRY lpDDColorTable)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawPalette__SetEntries(IDirectDrawPaletteImpl *This, DWORD dwFlags, DWORD dwStartingEntry, DWORD dwCount, LPPALETTEENTRY lpEntries)
HRESULT __stdcall IDirectDrawPalette__SetEntries(
IDirectDrawPaletteImpl* This,
DWORD dwFlags,
DWORD dwStartingEntry,
DWORD dwCount,
LPPALETTEENTRY lpEntries)
{
dprintfex("-> %s(This=%p, dwFlags=%08X, dwStartingEntry=%d, dwCount=%d, lpEntries=%p)\n", __FUNCTION__, This, (int)dwFlags, (int)dwStartingEntry, (int)dwCount, lpEntries);
TRACE_EXT(
"-> %s(This=%p, dwFlags=%08X, dwStartingEntry=%u, dwCount=%u, lpEntries=%p)\n",
__FUNCTION__,
This,
dwFlags,
dwStartingEntry,
dwCount,
lpEntries);
HRESULT ret = ddp_SetEntries(This, dwFlags, dwStartingEntry, dwCount, lpEntries);
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
struct IDirectDrawPaletteImplVtbl g_ddp_vtbl =
{
/* IUnknown */
/*** IUnknown methods ***/
IDirectDrawPalette__QueryInterface,
IDirectDrawPalette__AddRef,
IDirectDrawPalette__Release,
/* IDirectDrawPalette */
/*** IDirectDrawPalette methods ***/
IDirectDrawPalette__GetCaps,
IDirectDrawPalette__GetEntries,
IDirectDrawPalette__Initialize,

456
src/IDirectDraw/IDirectDrawSurface.c
View file

@ -6,9 +6,9 @@
#include "debug.h"
HRESULT __stdcall IDirectDrawSurface__QueryInterface(IDirectDrawSurfaceImpl *This, REFIID riid, void **obj)
HRESULT __stdcall IDirectDrawSurface__QueryInterface(IDirectDrawSurfaceImpl* This, REFIID riid, LPVOID FAR* ppvObj)
{
dprintf("-> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, obj);
TRACE("-> %s(This=%p, riid=%08X, obj=%p)\n", __FUNCTION__, This, (unsigned int)riid, ppvObj);
HRESULT ret = S_OK;
if (riid)
@ -19,56 +19,60 @@ HRESULT __stdcall IDirectDrawSurface__QueryInterface(IDirectDrawSurfaceImpl *Thi
IsEqualGUID(&IID_IDirectDrawSurface4, riid) ||
IsEqualGUID(&IID_IDirectDrawSurface7, riid))
{
dprintf(" GUID = %08X (IID_IDirectDrawSurfaceX)\n", ((GUID*)riid)->Data1);
TRACE(" GUID = %08X (IID_IDirectDrawSurfaceX)\n", ((GUID*)riid)->Data1);
IDirectDrawSurface_AddRef(This);
*obj = This;
*ppvObj = This;
ret = S_OK;
}
else if (IsEqualGUID(&IID_IDirectDrawGammaControl, riid))
{
IDirectDrawGammaControlImpl* gc = (IDirectDrawGammaControlImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawGammaControlImpl));
IDirectDrawGammaControlImpl* gc =
(IDirectDrawGammaControlImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawGammaControlImpl));
dprintf("NOT_IMPLEMENTED GUID = %08X (IID_IDirectDrawGammaControl), gammacontrol = %p\n", ((GUID*)riid)->Data1, gc);
TRACE(
"NOT_IMPLEMENTED GUID = %08X (IID_IDirectDrawGammaControl), gammacontrol = %p\n",
((GUID*)riid)->Data1,
gc);
gc->lpVtbl = &g_ddgc_vtbl;
gc->lpVtbl->AddRef(gc);
*obj = gc;
*ppvObj = gc;
ret = S_OK;
}
else
{
dprintf("NOT_IMPLEMENTED GUID = %08X\n", ((GUID*)riid)->Data1);
TRACE("NOT_IMPLEMENTED GUID = %08X\n", ((GUID*)riid)->Data1);
ret = E_NOINTERFACE;
}
}
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
ULONG __stdcall IDirectDrawSurface__AddRef(IDirectDrawSurfaceImpl *This)
ULONG __stdcall IDirectDrawSurface__AddRef(IDirectDrawSurfaceImpl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = ++This->ref;
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
ULONG __stdcall IDirectDrawSurface__Release(IDirectDrawSurfaceImpl *This)
ULONG __stdcall IDirectDrawSurface__Release(IDirectDrawSurfaceImpl* This)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
ULONG ret = --This->ref;
if(This->ref == 0)
if (This->ref == 0)
{
dprintf(" Released (%p)\n", This);
TRACE(" Released (%p)\n", This);
if (g_ddraw && (This->caps & DDSCAPS_PRIMARYSURFACE))
{
@ -98,7 +102,7 @@ ULONG __stdcall IDirectDrawSurface__Release(IDirectDrawSurfaceImpl *This)
if (This->clipper)
IDirectDrawClipper_Release(This->clipper);
if(This->palette && (!g_ddraw || (void*)This->palette != g_ddraw->last_freed_palette))
if (This->palette && (!g_ddraw || (void*)This->palette != g_ddraw->last_freed_palette))
{
IDirectDrawPalette_Release(This->palette);
}
@ -106,385 +110,479 @@ ULONG __stdcall IDirectDrawSurface__Release(IDirectDrawSurfaceImpl *This)
HeapFree(GetProcessHeap(), 0, This);
}
dprintf("<- %s(This ref=%u)\n", __FUNCTION__, ret);
TRACE("<- %s(This ref=%u)\n", __FUNCTION__, ret);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__AddAttachedSurface(IDirectDrawSurfaceImpl *This, LPDIRECTDRAWSURFACE lpDDSurface)
HRESULT __stdcall IDirectDrawSurface__AddAttachedSurface(IDirectDrawSurfaceImpl* This, LPDIRECTDRAWSURFACE7 lpDDSurface)
{
dprintf("-> %s(This=%p, lpDDSurface=%p)\n", __FUNCTION__, This, lpDDSurface);
HRESULT ret = dds_AddAttachedSurface(This, lpDDSurface);
dprintf("<- %s\n", __FUNCTION__);
TRACE("-> %s(This=%p, lpDDSurface=%p)\n", __FUNCTION__, This, lpDDSurface);
HRESULT ret = dds_AddAttachedSurface(This, (IDirectDrawSurfaceImpl*)lpDDSurface);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__AddOverlayDirtyRect(IDirectDrawSurfaceImpl *This, LPRECT a)
HRESULT __stdcall IDirectDrawSurface__AddOverlayDirtyRect(IDirectDrawSurfaceImpl* This, LPRECT lpRect)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE lpDDSrcSurface, LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx)
HRESULT __stdcall IDirectDrawSurface__Blt(
IDirectDrawSurfaceImpl* This,
LPRECT lpDestRect,
LPDIRECTDRAWSURFACE7 lpDDSrcSurface,
LPRECT lpSrcRect,
DWORD dwFlags,
LPDDBLTFX lpDDBltFx)
{
dprintfex("-> %s(This=%p, lpDestRect=%p, lpDDSrcSurface=%p, lpSrcRect=%p, dwFlags=%08X, lpDDBltFx=%p)\n", __FUNCTION__, This, lpDestRect, lpDDSrcSurface, lpSrcRect, (int)dwFlags, lpDDBltFx);
HRESULT ret = dds_Blt(This, lpDestRect, lpDDSrcSurface, lpSrcRect, dwFlags, lpDDBltFx);
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT(
"-> %s(This=%p, lpDestRect=%p, lpDDSrcSurface=%p, lpSrcRect=%p, dwFlags=%08X, lpDDBltFx=%p)\n",
__FUNCTION__,
This,
lpDestRect,
lpDDSrcSurface,
lpSrcRect,
dwFlags,
lpDDBltFx);
HRESULT ret = dds_Blt(This, lpDestRect, (IDirectDrawSurfaceImpl*)lpDDSrcSurface, lpSrcRect, dwFlags, lpDDBltFx);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__BltBatch(IDirectDrawSurfaceImpl *This, LPDDBLTBATCH a, DWORD b, DWORD c)
HRESULT __stdcall IDirectDrawSurface__BltBatch(
IDirectDrawSurfaceImpl* This,
LPDDBLTBATCH lpDDBltBatch,
DWORD dwCount,
DWORD dwFlags)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__BltFast(IDirectDrawSurfaceImpl *This, DWORD dst_x, DWORD dst_y, LPDIRECTDRAWSURFACE lpDDSrcSurface, LPRECT lpSrcRect, DWORD flags)
HRESULT __stdcall IDirectDrawSurface__BltFast(
IDirectDrawSurfaceImpl* This,
DWORD dwX,
DWORD dwY,
LPDIRECTDRAWSURFACE7 lpDDSrcSurface,
LPRECT lpSrcRect,
DWORD dwFlags)
{
dprintfex("-> %s(This=%p, x=%d, y=%d, lpDDSrcSurface=%p, lpSrcRect=%p, flags=%08X)\n", __FUNCTION__, This, dst_x, dst_y, lpDDSrcSurface, lpSrcRect, flags);
HRESULT ret = dds_BltFast(This, dst_x, dst_y, lpDDSrcSurface, lpSrcRect, flags);
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT(
"-> %s(This=%p, x=%d, y=%d, lpDDSrcSurface=%p, lpSrcRect=%p, flags=%08X)\n",
__FUNCTION__,
This,
dwX,
dwY,
lpDDSrcSurface,
lpSrcRect,
dwFlags);
HRESULT ret = dds_BltFast(This, dwX, dwY, (IDirectDrawSurfaceImpl*)lpDDSrcSurface, lpSrcRect, dwFlags);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__DeleteAttachedSurface(IDirectDrawSurfaceImpl *This, DWORD dwFlags, LPDIRECTDRAWSURFACE lpDDSurface)
HRESULT __stdcall IDirectDrawSurface__DeleteAttachedSurface(
IDirectDrawSurfaceImpl* This,
DWORD dwFlags,
LPDIRECTDRAWSURFACE7 lpDDSurface)
{
dprintf("-> %s(This=%p, dwFlags=%08X, lpDDSurface=%p)\n", __FUNCTION__, This, (int)dwFlags, lpDDSurface);
HRESULT ret = dds_DeleteAttachedSurface(This, dwFlags, lpDDSurface);
dprintf("<- %s\n", __FUNCTION__);
TRACE("-> %s(This=%p, dwFlags=%08X, lpDDSurface=%p)\n", __FUNCTION__, This, dwFlags, lpDDSurface);
HRESULT ret = dds_DeleteAttachedSurface(This, dwFlags, (IDirectDrawSurfaceImpl*)lpDDSurface);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__GetSurfaceDesc(IDirectDrawSurfaceImpl *This, LPDDSURFACEDESC lpDDSurfaceDesc)
HRESULT __stdcall IDirectDrawSurface__EnumAttachedSurfaces(
IDirectDrawSurfaceImpl* This,
LPVOID lpContext,
LPDDENUMSURFACESCALLBACK7 lpEnumSurfacesCallback)
{
dprintfex("-> %s(This=%p, lpDDSurfaceDesc=%p)\n", __FUNCTION__, This, lpDDSurfaceDesc);
HRESULT ret = dds_GetSurfaceDesc(This, lpDDSurfaceDesc);
dprintfex("<- %s\n", __FUNCTION__);
return ret;
}
TRACE(
"-> %s(This=%p, lpContext=%p, lpEnumSurfacesCallback=%p)\n",
__FUNCTION__,
This,
lpContext,
lpEnumSurfacesCallback);
HRESULT __stdcall IDirectDrawSurface__EnumAttachedSurfaces(IDirectDrawSurfaceImpl *This, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpEnumSurfacesCallback)
{
dprintf("-> %s(This=%p, lpContext=%p, lpEnumSurfacesCallback=%p)\n", __FUNCTION__, This, lpContext, lpEnumSurfacesCallback);
HRESULT ret = dds_EnumAttachedSurfaces(This, lpContext, lpEnumSurfacesCallback);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__EnumOverlayZOrders(IDirectDrawSurfaceImpl *This, DWORD a, LPVOID b, LPDDENUMSURFACESCALLBACK c)
HRESULT __stdcall IDirectDrawSurface__EnumOverlayZOrders(
IDirectDrawSurfaceImpl* This,
DWORD dwFlags,
LPVOID lpContext,
LPDDENUMSURFACESCALLBACK7 lpfnCallback)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__Flip(IDirectDrawSurfaceImpl *This, LPDIRECTDRAWSURFACE surface, DWORD flags)
HRESULT __stdcall IDirectDrawSurface__Flip(
IDirectDrawSurfaceImpl* This,
LPDIRECTDRAWSURFACE7 lpDDSurfaceTargetOverride,
DWORD dwFlags)
{
dprintfex("-> %s(This=%p, surface=%p, flags=%08X)\n", __FUNCTION__, This, surface, flags);
HRESULT ret = dds_Flip(This, surface, flags);
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT("-> %s(This=%p, surface=%p, flags=%08X)\n", __FUNCTION__, This, lpDDSurfaceTargetOverride, dwFlags);
HRESULT ret = dds_Flip(This, (IDirectDrawSurfaceImpl*)lpDDSurfaceTargetOverride, dwFlags);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__GetAttachedSurface(IDirectDrawSurfaceImpl *This, LPDDSCAPS lpDdsCaps, LPDIRECTDRAWSURFACE FAR *surface)
HRESULT __stdcall IDirectDrawSurface__GetAttachedSurface(
IDirectDrawSurfaceImpl* This,
LPDDSCAPS2 lpDdsCaps,
LPDIRECTDRAWSURFACE7 FAR* lpDDsurface)
{
dprintf("-> %s(This=%p, dwCaps=%08X, surface=%p)\n", __FUNCTION__, This, lpDdsCaps->dwCaps, surface);
HRESULT ret = dds_GetAttachedSurface(This, lpDdsCaps, surface);
dprintf("<- %s\n", __FUNCTION__);
TRACE("-> %s(This=%p, dwCaps=%08X, surface=%p)\n", __FUNCTION__, This, lpDdsCaps->dwCaps, lpDDsurface);
HRESULT ret = dds_GetAttachedSurface(This, lpDdsCaps, (IDirectDrawSurfaceImpl**)lpDDsurface);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__GetBltStatus(IDirectDrawSurfaceImpl *This, DWORD a)
HRESULT __stdcall IDirectDrawSurface__GetBltStatus(IDirectDrawSurfaceImpl* This, DWORD dwFlags)
{
dprintfex("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE_EXT("-> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__GetCaps(IDirectDrawSurfaceImpl *This, LPDDSCAPS lpDDSCaps)
HRESULT __stdcall IDirectDrawSurface__GetCaps(IDirectDrawSurfaceImpl* This, LPDDSCAPS2 lpDDSCaps)
{
dprintf("-> %s(This=%p, lpDDSCaps=%p)\n", __FUNCTION__, This, lpDDSCaps);
TRACE("-> %s(This=%p, lpDDSCaps=%p)\n", __FUNCTION__, This, lpDDSCaps);
HRESULT ret = dds_GetCaps(This, lpDDSCaps);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__GetClipper(IDirectDrawSurfaceImpl *This, LPDIRECTDRAWCLIPPER FAR *lpClipper)
HRESULT __stdcall IDirectDrawSurface__GetClipper(IDirectDrawSurfaceImpl* This, LPDIRECTDRAWCLIPPER FAR* lpClipper)
{
dprintfex("-> %s(This=%p, lpClipper=%p)\n", __FUNCTION__, This, lpClipper);
HRESULT ret = dds_GetClipper(This, lpClipper);
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT("-> %s(This=%p, lpClipper=%p)\n", __FUNCTION__, This, lpClipper);
HRESULT ret = dds_GetClipper(This, (IDirectDrawClipperImpl**)lpClipper);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__GetColorKey(IDirectDrawSurfaceImpl *This, DWORD flags, LPDDCOLORKEY colorKey)
HRESULT __stdcall IDirectDrawSurface__GetColorKey(IDirectDrawSurfaceImpl* This, DWORD dwFlags, LPDDCOLORKEY lpColorKey)
{
dprintfex("-> %s(This=%p, flags=0x%08X, color_key=%p)\n", __FUNCTION__, This, flags, colorKey);
HRESULT ret = dds_GetColorKey(This, flags, colorKey);
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT("-> %s(This=%p, flags=0x%08X, color_key=%p)\n", __FUNCTION__, This, dwFlags, lpColorKey);
HRESULT ret = dds_GetColorKey(This, dwFlags, lpColorKey);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__GetDC(IDirectDrawSurfaceImpl *This, HDC FAR *lpHDC)
HRESULT __stdcall IDirectDrawSurface__GetDC(IDirectDrawSurfaceImpl* This, HDC FAR* lpHDC)
{
dprintfex("-> %s(This=%p, lpHDC=%p)\n", __FUNCTION__, This);
TRACE_EXT("-> %s(This=%p, lpHDC=%p)\n", __FUNCTION__, This);
HRESULT ret = dds_GetDC(This, lpHDC);
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__GetFlipStatus(IDirectDrawSurfaceImpl *This, DWORD a)
HRESULT __stdcall IDirectDrawSurface__GetFlipStatus(IDirectDrawSurfaceImpl* This, DWORD dwFlags)
{
dprintfex("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE_EXT("-> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__GetOverlayPosition(IDirectDrawSurfaceImpl *This, LPLONG a, LPLONG b)
HRESULT __stdcall IDirectDrawSurface__GetOverlayPosition(IDirectDrawSurfaceImpl* This, LPLONG lplX, LPLONG lplY)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_NOTAOVERLAYSURFACE;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__GetPalette(IDirectDrawSurfaceImpl *This, LPDIRECTDRAWPALETTE FAR *lplpDDPalette)
HRESULT __stdcall IDirectDrawSurface__GetPalette(IDirectDrawSurfaceImpl* This, LPDIRECTDRAWPALETTE FAR* lplpDDPalette)
{
dprintf("-> %s(This=%p, lplpDDPalette=%p)\n", __FUNCTION__, This, lplpDDPalette);
HRESULT ret = dds_GetPalette(This, lplpDDPalette);
dprintf("<- %s\n", __FUNCTION__);
TRACE("-> %s(This=%p, lplpDDPalette=%p)\n", __FUNCTION__, This, lplpDDPalette);
HRESULT ret = dds_GetPalette(This, (IDirectDrawPaletteImpl**)lplpDDPalette);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__GetPixelFormat(IDirectDrawSurfaceImpl *This, LPDDPIXELFORMAT ddpfPixelFormat)
HRESULT __stdcall IDirectDrawSurface__GetPixelFormat(IDirectDrawSurfaceImpl* This, LPDDPIXELFORMAT ddpfPixelFormat)
{
dprintfex("-> %s(This=%p, ...)\n", __FUNCTION__, This);
TRACE_EXT("-> %s(This=%p, ...)\n", __FUNCTION__, This);
HRESULT ret = dds_GetPixelFormat(This, ddpfPixelFormat);
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__Initialize(IDirectDrawSurfaceImpl *This, LPDIRECTDRAW a, LPDDSURFACEDESC b)
HRESULT __stdcall IDirectDrawSurface__GetSurfaceDesc(IDirectDrawSurfaceImpl* This, LPDDSURFACEDESC2 lpDDSurfaceDesc)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE_EXT("-> %s(This=%p, lpDDSurfaceDesc=%p)\n", __FUNCTION__, This, lpDDSurfaceDesc);
HRESULT ret = dds_GetSurfaceDesc(This, lpDDSurfaceDesc);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__Initialize(
IDirectDrawSurfaceImpl* This,
LPDIRECTDRAW lpDD,
LPDDSURFACEDESC2 lpDDSurfaceDesc)
{
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__IsLost(IDirectDrawSurfaceImpl *This)
HRESULT __stdcall IDirectDrawSurface__IsLost(IDirectDrawSurfaceImpl* This)
{
dprintfex("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE_EXT("-> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__Lock(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDDSURFACEDESC lpDDSurfaceDesc, DWORD dwFlags, HANDLE hEvent)
HRESULT __stdcall IDirectDrawSurface__Lock(
IDirectDrawSurfaceImpl* This,
LPRECT lpDestRect,
LPDDSURFACEDESC2 lpDDSurfaceDesc,
DWORD dwFlags,
HANDLE hEvent)
{
dprintfex("-> %s(This=%p, lpDestRect=%p, lpDDSurfaceDesc=%p, dwFlags=%08X, hEvent=%p)\n", __FUNCTION__, This, lpDestRect, lpDDSurfaceDesc, (int)dwFlags, hEvent);
TRACE_EXT(
"-> %s(This=%p, lpDestRect=%p, lpDDSurfaceDesc=%p, dwFlags=%08X, hEvent=%p)\n",
__FUNCTION__,
This,
lpDestRect,
lpDDSurfaceDesc,
dwFlags,
hEvent);
HRESULT ret = dds_Lock(This, lpDestRect, lpDDSurfaceDesc, dwFlags, hEvent);
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__ReleaseDC(IDirectDrawSurfaceImpl *This, HDC hDC)
HRESULT __stdcall IDirectDrawSurface__ReleaseDC(IDirectDrawSurfaceImpl* This, HDC hDC)
{
dprintfex("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE_EXT("-> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = dds_ReleaseDC(This, hDC);
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__Restore(IDirectDrawSurfaceImpl *This)
HRESULT __stdcall IDirectDrawSurface__Restore(IDirectDrawSurfaceImpl* This)
{
dprintfex("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE_EXT("-> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__SetClipper(IDirectDrawSurfaceImpl *This, LPDIRECTDRAWCLIPPER lpClipper)
HRESULT __stdcall IDirectDrawSurface__SetClipper(IDirectDrawSurfaceImpl* This, LPDIRECTDRAWCLIPPER lpClipper)
{
dprintf("-> %s(This=%p, lpClipper=%p)\n", __FUNCTION__, This, lpClipper);
HRESULT ret = dds_SetClipper(This, lpClipper);
dprintf("<- %s\n", __FUNCTION__);
TRACE("-> %s(This=%p, lpClipper=%p)\n", __FUNCTION__, This, lpClipper);
HRESULT ret = dds_SetClipper(This, (IDirectDrawClipperImpl*)lpClipper);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__SetColorKey(IDirectDrawSurfaceImpl *This, DWORD flags, LPDDCOLORKEY colorKey)
HRESULT __stdcall IDirectDrawSurface__SetColorKey(IDirectDrawSurfaceImpl* This, DWORD dwFlags, LPDDCOLORKEY lpColorKey)
{
dprintfex("-> %s(This=%p, flags=0x%08X, color_key=%p)\n", __FUNCTION__, This, flags, colorKey);
HRESULT ret = dds_SetColorKey(This, flags, colorKey);
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT("-> %s(This=%p, flags=0x%08X, color_key=%p)\n", __FUNCTION__, This, dwFlags, lpColorKey);
HRESULT ret = dds_SetColorKey(This, dwFlags, lpColorKey);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__SetOverlayPosition(IDirectDrawSurfaceImpl *This, LONG a, LONG b)
HRESULT __stdcall IDirectDrawSurface__SetOverlayPosition(IDirectDrawSurfaceImpl* This, LONG lX, LONG lY)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__SetPalette(IDirectDrawSurfaceImpl *This, LPDIRECTDRAWPALETTE lpDDPalette)
HRESULT __stdcall IDirectDrawSurface__SetPalette(IDirectDrawSurfaceImpl* This, LPDIRECTDRAWPALETTE lpDDPalette)
{
dprintf("-> %s(This=%p, lpDDPalette=%p)\n", __FUNCTION__, This, lpDDPalette);
HRESULT ret = dds_SetPalette(This, lpDDPalette);
dprintf("<- %s\n", __FUNCTION__);
TRACE("-> %s(This=%p, lpDDPalette=%p)\n", __FUNCTION__, This, lpDDPalette);
HRESULT ret = dds_SetPalette(This, (IDirectDrawPaletteImpl*)lpDDPalette);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__Unlock(IDirectDrawSurfaceImpl *This, LPVOID lpRect)
HRESULT __stdcall IDirectDrawSurface__Unlock(IDirectDrawSurfaceImpl* This, LPRECT lpRect)
{
dprintfex("-> %s(This=%p, lpRect=%p)\n", __FUNCTION__, This, lpRect);
TRACE_EXT("-> %s(This=%p, lpRect=%p)\n", __FUNCTION__, This, lpRect);
HRESULT ret = dds_Unlock(This, lpRect);
dprintfex("<- %s\n", __FUNCTION__);
TRACE_EXT("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__UpdateOverlay(IDirectDrawSurfaceImpl *This, LPRECT a, LPDIRECTDRAWSURFACE b, LPRECT c, DWORD d, LPDDOVERLAYFX e)
HRESULT __stdcall IDirectDrawSurface__UpdateOverlay(
IDirectDrawSurfaceImpl* This,
LPRECT lpSrcRect,
LPDIRECTDRAWSURFACE7 lpDDDestSurface,
LPRECT lpDestRect,
DWORD dwFlags,
LPDDOVERLAYFX lpDDOverlayFx)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__UpdateOverlayDisplay(IDirectDrawSurfaceImpl *This, DWORD a)
HRESULT __stdcall IDirectDrawSurface__UpdateOverlayDisplay(IDirectDrawSurfaceImpl* This, DWORD dwFlags)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__UpdateOverlayZOrder(IDirectDrawSurfaceImpl *This, DWORD a, LPDIRECTDRAWSURFACE b)
HRESULT __stdcall IDirectDrawSurface__UpdateOverlayZOrder(
IDirectDrawSurfaceImpl* This,
DWORD dwFlags,
LPDIRECTDRAWSURFACE7 lpDDSReference)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__GetDDInterface(IDirectDrawSurfaceImpl *This, LPVOID* lplpDD)
HRESULT __stdcall IDirectDrawSurface__GetDDInterface(IDirectDrawSurfaceImpl* This, LPVOID* lplpDD)
{
dprintf("-> %s(This=%p)\n", __FUNCTION__, This);
TRACE("-> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = dds_GetDDInterface(This, lplpDD);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__PageLock(IDirectDrawSurfaceImpl *This, DWORD dwFlags)
HRESULT __stdcall IDirectDrawSurface__PageLock(IDirectDrawSurfaceImpl* This, DWORD dwFlags)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__PageUnlock(IDirectDrawSurfaceImpl *This, DWORD dwFlags)
HRESULT __stdcall IDirectDrawSurface__PageUnlock(IDirectDrawSurfaceImpl* This, DWORD dwFlags)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__SetSurfaceDesc(IDirectDrawSurfaceImpl *This, LPDDSURFACEDESC lpDDSD, DWORD dwFlags)
HRESULT __stdcall IDirectDrawSurface__SetSurfaceDesc(IDirectDrawSurfaceImpl* This, LPDDSURFACEDESC2 lpDDSD, DWORD dwFlags)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_UNSUPPORTED;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__SetPrivateData(IDirectDrawSurfaceImpl *This, REFGUID rtag, LPVOID lpData, DWORD dwSize, DWORD dwFlags)
HRESULT __stdcall IDirectDrawSurface__SetPrivateData(
IDirectDrawSurfaceImpl* This,
REFGUID rtag,
LPVOID lpData,
DWORD dwSize,
DWORD dwFlags)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_OUTOFMEMORY;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__GetPrivateData(IDirectDrawSurfaceImpl *This, REFGUID rtag, LPVOID lpBuffer, LPDWORD lpdwBufferSize)
HRESULT __stdcall IDirectDrawSurface__GetPrivateData(
IDirectDrawSurfaceImpl* This,
REFGUID rtag,
LPVOID lpBuffer,
LPDWORD lpdwBufferSize)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_NOTFOUND;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__FreePrivateData(IDirectDrawSurfaceImpl *This, REFGUID rtag)
HRESULT __stdcall IDirectDrawSurface__FreePrivateData(IDirectDrawSurfaceImpl* This, REFGUID rtag)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DD_OK;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__GetUniquenessValue(IDirectDrawSurfaceImpl *This, LPDWORD lpdwValue)
HRESULT __stdcall IDirectDrawSurface__GetUniquenessValue(IDirectDrawSurfaceImpl* This, LPDWORD lpdwValue)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_INVALIDOBJECT;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__ChangeUniquenessValue(IDirectDrawSurfaceImpl *This)
HRESULT __stdcall IDirectDrawSurface__ChangeUniquenessValue(IDirectDrawSurfaceImpl* This)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_INVALIDOBJECT;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__SetPriority(IDirectDrawSurfaceImpl *This, DWORD dwPrio)
HRESULT __stdcall IDirectDrawSurface__SetPriority(IDirectDrawSurfaceImpl* This, DWORD dwPrio)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_INVALIDOBJECT;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__GetPriority(IDirectDrawSurfaceImpl *This, LPDWORD lpdwPrio)
HRESULT __stdcall IDirectDrawSurface__GetPriority(IDirectDrawSurfaceImpl* This, LPDWORD lpdwPrio)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_INVALIDOBJECT;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__SetLOD(IDirectDrawSurfaceImpl *This, DWORD dwLod)
HRESULT __stdcall IDirectDrawSurface__SetLOD(IDirectDrawSurfaceImpl* This, DWORD dwLod)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_INVALIDOBJECT;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
HRESULT __stdcall IDirectDrawSurface__GetLOD(IDirectDrawSurfaceImpl *This, LPDWORD lpdwLod)
HRESULT __stdcall IDirectDrawSurface__GetLOD(IDirectDrawSurfaceImpl* This, LPDWORD lpdwLod)
{
dprintf("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
TRACE("NOT_IMPLEMENTED -> %s(This=%p)\n", __FUNCTION__, This);
HRESULT ret = DDERR_INVALIDOBJECT;
dprintf("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
struct IDirectDrawSurfaceImplVtbl g_dds_vtbl =
{
/* IUnknown */
/*** IUnknown methods ***/
IDirectDrawSurface__QueryInterface,
IDirectDrawSurface__AddRef,
IDirectDrawSurface__Release,
/* IDirectDrawSurface */
/*** IDirectDrawSurface methods ***/
IDirectDrawSurface__AddAttachedSurface,
IDirectDrawSurface__AddOverlayDirtyRect,
IDirectDrawSurface__Blt,
@ -518,19 +616,19 @@ struct IDirectDrawSurfaceImplVtbl g_dds_vtbl =
IDirectDrawSurface__UpdateOverlay,
IDirectDrawSurface__UpdateOverlayDisplay,
IDirectDrawSurface__UpdateOverlayZOrder,
// v2
/*** Added in the v2 interface ***/
IDirectDrawSurface__GetDDInterface,
IDirectDrawSurface__PageLock,
IDirectDrawSurface__PageUnlock,
// v3
/*** Added in the v3 interface ***/
IDirectDrawSurface__SetSurfaceDesc,
// v4
/*** Added in the v4 interface ***/
IDirectDrawSurface__SetPrivateData,
IDirectDrawSurface__GetPrivateData,
IDirectDrawSurface__FreePrivateData,
IDirectDrawSurface__GetUniquenessValue,
IDirectDrawSurface__ChangeUniquenessValue,
// v7
/*** Added in the v7 interface ***/
IDirectDrawSurface__SetPriority,
IDirectDrawSurface__GetPriority,
IDirectDrawSurface__SetLOD,

35
src/config.c
View file

@ -16,12 +16,12 @@ static int cfg_get_int(LPCSTR key, int default_value);
static DWORD cfg_get_string(LPCSTR key, LPCSTR default_value, LPSTR out_string, DWORD out_size);
static void cfg_create_ini();
cnc_ddraw_config g_config =
{ .window_rect = { .left = -32000, .top = -32000, .right = 0, .bottom = 0 }, .window_state = -1 };
CNCDDRAWCONFIG g_config =
{ .window_rect = {.left = -32000, .top = -32000, .right = 0, .bottom = 0 }, .window_state = -1 };
void cfg_load()
{
//set up settings ini
/* set up settings ini */
char cwd[MAX_PATH];
char tmp[256];
GetCurrentDirectoryA(sizeof(cwd), cwd);
@ -30,12 +30,12 @@ void cfg_load()
if (GetFileAttributes(g_config.ini_path) == INVALID_FILE_ATTRIBUTES)
cfg_create_ini();
//get process filename
/* get process filename */
char process_file_path[MAX_PATH] = { 0 };
GetModuleFileNameA(NULL, process_file_path, MAX_PATH);
_splitpath(process_file_path, NULL, NULL, g_config.process_file_name, NULL);
//load settings from ini
/* load settings from ini */
g_ddraw->windowed = cfg_get_bool("windowed", FALSE);
g_ddraw->border = cfg_get_bool("border", TRUE);
g_ddraw->boxing = cfg_get_bool("boxing", FALSE);
@ -53,7 +53,6 @@ void cfg_load()
g_ddraw->fixwndprochook = cfg_get_bool("fixwndprochook", FALSE);
g_ddraw->d3d9linear = cfg_get_bool("d3d9linear", TRUE);
g_ddraw->gdilinear = cfg_get_bool("gdilinear", FALSE);
g_ddraw->backbuffer = cfg_get_bool("backbuffer", TRUE);
g_ddraw->passthrough = cfg_get_bool("passthrough", TRUE);
g_ddraw->resolutions = cfg_get_int("resolutions", RESLIST_NORMAL);
@ -67,7 +66,7 @@ void cfg_load()
g_config.save_settings = cfg_get_int("savesettings", 1);
g_hook_method = cfg_get_int("hook", 4);
g_ddraw->render.maxfps = cfg_get_int("maxfps", -1);
g_ddraw->render.minfps = cfg_get_int("minfps", 0);
@ -81,9 +80,9 @@ void cfg_load()
g_ddraw->render.minfps_tick_len = (DWORD)(1000.0f / g_ddraw->render.minfps);
}
/* can't fully set it up here due to missing g_ddraw->mode.dmDisplayFrequency */
if (g_ddraw->accurate_timers || g_ddraw->vsync)
g_fpsl.htimer = CreateWaitableTimer(NULL, TRUE, NULL);
//can't fully set it up here due to missing g_ddraw->mode.dmDisplayFrequency
g_ddraw->maxgameticks = cfg_get_int("maxgameticks", 0);
@ -99,7 +98,7 @@ void cfg_load()
if (g_ddraw->maxgameticks >= 0 || g_ddraw->maxgameticks == -2)
{
//always using 60 fps for flip...
/* always using 60 fps for flip... */
if (g_ddraw->accurate_timers)
g_ddraw->flip_limiter.htimer = CreateWaitableTimer(NULL, TRUE, NULL);
@ -139,21 +138,21 @@ void cfg_load()
g_ddraw->render.bpp = 0;
}
// to do: read .glslp config file instead of the shader and apply the correct settings
/* to do: read .glslp config file instead of the shader and apply the correct settings */
cfg_get_string("shader", "", g_ddraw->shader, sizeof(g_ddraw->shader));
cfg_get_string("renderer", "auto", tmp, sizeof(tmp));
dprintf(" Using %s renderer\n", tmp);
TRACE(" Using %s renderer\n", tmp);
if (tolower(tmp[0]) == 's' || tolower(tmp[0]) == 'g') //gdi
if (tolower(tmp[0]) == 's' || tolower(tmp[0]) == 'g') /* gdi */
{
g_ddraw->renderer = gdi_render_main;
}
else if (tolower(tmp[0]) == 'd') //direct3d9
else if (tolower(tmp[0]) == 'd') /* direct3d9 */
{
g_ddraw->renderer = d3d9_render_main;
}
else if (tolower(tmp[0]) == 'o') //opengl
else if (tolower(tmp[0]) == 'o') /* opengl */
{
if (oglu_load_dll())
{
@ -165,7 +164,7 @@ void cfg_load()
g_ddraw->renderer = gdi_render_main;
}
}
else //auto
else /* auto */
{
if (!g_ddraw->wine && d3d9_is_available())
{
@ -189,14 +188,14 @@ void cfg_save()
return;
char buf[16];
char *section = g_config.save_settings == 1 ? "ddraw" : g_config.process_file_name;
char* section = g_config.save_settings == 1 ? "ddraw" : g_config.process_file_name;
if (g_config.window_rect.right)
{
sprintf(buf, "%ld", g_config.window_rect.right);
WritePrivateProfileString(section, "width", buf, g_config.ini_path);
}
if (g_config.window_rect.bottom)
{
sprintf(buf, "%ld", g_config.window_rect.bottom);
@ -223,7 +222,7 @@ void cfg_save()
static void cfg_create_ini()
{
FILE *fh = fopen(g_config.ini_path, "w");
FILE* fh = fopen(g_config.ini_path, "w");
if (fh)
{
fputs(

207
src/dd.c
View file

@ -1,6 +1,6 @@
#include <windows.h>
#include <ddraw.h>
#include "IDirectDraw.h"
#include "ddraw.h"
#include "dd.h"
#include "hook.h"
#include "config.h"
@ -14,14 +14,18 @@
#include "utils.h"
cnc_ddraw *g_ddraw = NULL;
CNCDDRAW* g_ddraw = NULL;
HRESULT dd_EnumDisplayModes(DWORD dwFlags, LPDDSURFACEDESC lpDDSurfaceDesc, LPVOID lpContext, LPDDENUMMODESCALLBACK lpEnumModesCallback)
HRESULT dd_EnumDisplayModes(
DWORD dwFlags,
LPDDSURFACEDESC2 lpDDSurfaceDesc,
LPVOID lpContext,
LPDDENUMMODESCALLBACK2 lpEnumModesCallback)
{
DWORD i = 0;
DDSURFACEDESC s;
DDSURFACEDESC2 s;
/* Some games crash when you feed them with too many resolutions... */
/* Some games crash when you feed them with too many resolutions so we have to keep the list short */
SIZE resolutions[] =
{
@ -40,7 +44,7 @@ HRESULT dd_EnumDisplayModes(DWORD dwFlags, LPDDSURFACEDESC lpDDSurfaceDesc, LPVO
if (g_ddraw->bpp || g_ddraw->resolutions == RESLIST_FULL)
{
dprintf(" g_ddraw->bpp=%u\n", g_ddraw->bpp);
TRACE(" g_ddraw->bpp=%u\n", g_ddraw->bpp);
/* set up some filters to keep the list short */
DWORD refresh_rate = 0;
@ -82,9 +86,15 @@ HRESULT dd_EnumDisplayModes(DWORD dwFlags, LPDDSURFACEDESC lpDDSurfaceDesc, LPVO
flags == m.dmDisplayFlags &&
fixed_output == m.dmDisplayFixedOutput)
{
dprintfex(" %d: %dx%d@%d %d bpp\n", (int)i, (int)m.dmPelsWidth, (int)m.dmPelsHeight, (int)m.dmDisplayFrequency, (int)m.dmBitsPerPel);
TRACE_EXT(
" %u: %ux%u@%u %u bpp\n",
i,
m.dmPelsWidth,
m.dmPelsHeight,
m.dmDisplayFrequency,
m.dmBitsPerPel);
memset(&s, 0, sizeof(DDSURFACEDESC));
memset(&s, 0, sizeof(s));
s.dwSize = sizeof(DDSURFACEDESC);
s.dwFlags = DDSD_HEIGHT | DDSD_REFRESHRATE | DDSD_WIDTH | DDSD_PITCH | DDSD_PIXELFORMAT;
@ -101,7 +111,7 @@ HRESULT dd_EnumDisplayModes(DWORD dwFlags, LPDDSURFACEDESC lpDDSurfaceDesc, LPVO
{
if (lpEnumModesCallback(&s, lpContext) == DDENUMRET_CANCEL)
{
dprintf(" DDENUMRET_CANCEL returned, stopping\n");
TRACE(" DDENUMRET_CANCEL returned, stopping\n");
return DD_OK;
}
}
@ -117,7 +127,7 @@ HRESULT dd_EnumDisplayModes(DWORD dwFlags, LPDDSURFACEDESC lpDDSurfaceDesc, LPVO
{
if (lpEnumModesCallback(&s, lpContext) == DDENUMRET_CANCEL)
{
dprintf(" DDENUMRET_CANCEL returned, stopping\n");
TRACE(" DDENUMRET_CANCEL returned, stopping\n");
return DD_OK;
}
}
@ -133,7 +143,7 @@ HRESULT dd_EnumDisplayModes(DWORD dwFlags, LPDDSURFACEDESC lpDDSurfaceDesc, LPVO
{
if (lpEnumModesCallback(&s, lpContext) == DDENUMRET_CANCEL)
{
dprintf(" DDENUMRET_CANCEL returned, stopping\n");
TRACE(" DDENUMRET_CANCEL returned, stopping\n");
return DD_OK;
}
}
@ -187,7 +197,7 @@ HRESULT dd_EnumDisplayModes(DWORD dwFlags, LPDDSURFACEDESC lpDDSurfaceDesc, LPVO
continue;
}
memset(&s, 0, sizeof(DDSURFACEDESC));
memset(&s, 0, sizeof(s));
s.dwSize = sizeof(DDSURFACEDESC);
s.dwFlags = DDSD_HEIGHT | DDSD_REFRESHRATE | DDSD_WIDTH | DDSD_PITCH | DDSD_PIXELFORMAT;
@ -201,7 +211,7 @@ HRESULT dd_EnumDisplayModes(DWORD dwFlags, LPDDSURFACEDESC lpDDSurfaceDesc, LPVO
if (lpEnumModesCallback(&s, lpContext) == DDENUMRET_CANCEL)
{
dprintf(" DDENUMRET_CANCEL returned, stopping\n");
TRACE(" DDENUMRET_CANCEL returned, stopping\n");
return DD_OK;
}
@ -214,7 +224,7 @@ HRESULT dd_EnumDisplayModes(DWORD dwFlags, LPDDSURFACEDESC lpDDSurfaceDesc, LPVO
if (lpEnumModesCallback(&s, lpContext) == DDENUMRET_CANCEL)
{
dprintf(" DDENUMRET_CANCEL returned, stopping\n");
TRACE(" DDENUMRET_CANCEL returned, stopping\n");
return DD_OK;
}
@ -230,7 +240,7 @@ HRESULT dd_EnumDisplayModes(DWORD dwFlags, LPDDSURFACEDESC lpDDSurfaceDesc, LPVO
if (lpEnumModesCallback(&s, lpContext) == DDENUMRET_CANCEL)
{
dprintf(" DDENUMRET_CANCEL returned, stopping\n");
TRACE(" DDENUMRET_CANCEL returned, stopping\n");
return DD_OK;
}
}
@ -243,8 +253,15 @@ HRESULT dd_GetCaps(LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDEmulCaps)
{
if (lpDDDriverCaps)
{
lpDDDriverCaps->dwSize = sizeof(DDCAPS);
lpDDDriverCaps->dwCaps = DDCAPS_BLT | DDCAPS_PALETTE | DDCAPS_BLTCOLORFILL | DDCAPS_BLTSTRETCH | DDCAPS_CANCLIP | DDCAPS_CANBLTSYSMEM;
lpDDDriverCaps->dwSize = sizeof(DDCAPS_DX5);
lpDDDriverCaps->dwCaps =
DDCAPS_BLT |
DDCAPS_PALETTE |
DDCAPS_BLTCOLORFILL |
DDCAPS_BLTSTRETCH |
DDCAPS_CANCLIP |
DDCAPS_CANBLTSYSMEM;
lpDDDriverCaps->dwCKeyCaps = 0;
lpDDDriverCaps->dwPalCaps = DDPCAPS_8BIT | DDPCAPS_PRIMARYSURFACE;
lpDDDriverCaps->dwVidMemTotal = 16777216;
@ -267,13 +284,15 @@ HRESULT dd_GetCaps(LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDEmulCaps)
return DD_OK;
}
HRESULT dd_GetDisplayMode(LPDDSURFACEDESC lpDDSurfaceDesc)
HRESULT dd_GetDisplayMode(LPDDSURFACEDESC2 lpDDSurfaceDesc)
{
if (lpDDSurfaceDesc)
{
memset(lpDDSurfaceDesc, 0, sizeof(DDSURFACEDESC));
int size = lpDDSurfaceDesc->dwSize == sizeof(DDSURFACEDESC2) ? sizeof(DDSURFACEDESC2) : sizeof(DDSURFACEDESC);
lpDDSurfaceDesc->dwSize = sizeof(DDSURFACEDESC);
memset(lpDDSurfaceDesc, 0, size);
lpDDSurfaceDesc->dwSize = size;
lpDDSurfaceDesc->dwFlags = DDSD_HEIGHT | DDSD_REFRESHRATE | DDSD_WIDTH | DDSD_PITCH | DDSD_PIXELFORMAT;
lpDDSurfaceDesc->dwHeight = g_ddraw->height ? g_ddraw->height : 768;
lpDDSurfaceDesc->dwWidth = g_ddraw->width ? g_ddraw->width : 1024;
@ -339,7 +358,7 @@ HRESULT dd_RestoreDisplayMode()
d3d9_release();
}
}
if (!g_ddraw->windowed)
{
if (g_ddraw->renderer != d3d9_render_main)
@ -351,9 +370,9 @@ HRESULT dd_RestoreDisplayMode()
return DD_OK;
}
HRESULT dd_SetDisplayMode(DWORD width, DWORD height, DWORD bpp, BOOL set_by_game)
HRESULT dd_SetDisplayMode(DWORD dwWidth, DWORD dwHeight, DWORD dwBPP, BOOL setByGame)
{
if (bpp != 8 && bpp != 16 && bpp != 32)
if (dwBPP != 8 && dwBPP != 16 && dwBPP != 32)
return DDERR_INVALIDMODE;
if (g_ddraw->render.thread)
@ -419,21 +438,21 @@ HRESULT dd_SetDisplayMode(DWORD width, DWORD height, DWORD bpp, BOOL set_by_game
g_ddraw->render.height = g_config.window_rect.bottom;
}
//temporary fix: center window for games that keep changing their resolution
if (g_ddraw->width &&
(g_ddraw->width != width || g_ddraw->height != height) &&
(width > g_config.window_rect.right || height > g_config.window_rect.bottom))
/* temporary fix: center window for games that keep changing their resolution */
if (g_ddraw->width &&
(g_ddraw->width != dwWidth || g_ddraw->height != dwHeight) &&
(dwWidth > g_config.window_rect.right || dwHeight > g_config.window_rect.bottom))
{
g_config.window_rect.left = -32000;
g_config.window_rect.top = -32000;
}
g_ddraw->width = width;
g_ddraw->height = height;
g_ddraw->bpp = bpp;
g_ddraw->width = dwWidth;
g_ddraw->height = dwHeight;
g_ddraw->bpp = dwBPP;
g_ddraw->cursor.x = width / 2;
g_ddraw->cursor.y = height / 2;
g_ddraw->cursor.x = dwWidth / 2;
g_ddraw->cursor.y = dwHeight / 2;
BOOL border = g_ddraw->border;
@ -442,14 +461,14 @@ HRESULT dd_SetDisplayMode(DWORD width, DWORD height, DWORD bpp, BOOL set_by_game
g_ddraw->render.width = g_ddraw->mode.dmPelsWidth;
g_ddraw->render.height = g_ddraw->mode.dmPelsHeight;
if (g_ddraw->windowed) //windowed-fullscreen aka borderless
if (g_ddraw->windowed) /* windowed-fullscreen aka borderless */
{
border = FALSE;
g_config.window_rect.left = -32000;
g_config.window_rect.top = -32000;
// prevent OpenGL from going automatically into fullscreen exclusive mode
/* prevent OpenGL from going automatically into fullscreen exclusive mode */
if (g_ddraw->renderer == ogl_render_main)
g_ddraw->render.height++;
@ -467,14 +486,14 @@ HRESULT dd_SetDisplayMode(DWORD width, DWORD height, DWORD bpp, BOOL set_by_game
}
g_ddraw->render.run = TRUE;
BOOL lock_mouse = g_ddraw->locked || g_ddraw->fullscreen;
mouse_unlock();
memset(&g_ddraw->render.mode, 0, sizeof(DEVMODE));
g_ddraw->render.mode.dmSize = sizeof(DEVMODE);
g_ddraw->render.mode.dmFields = DM_PELSWIDTH|DM_PELSHEIGHT;
g_ddraw->render.mode.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
g_ddraw->render.mode.dmPelsWidth = g_ddraw->render.width;
g_ddraw->render.mode.dmPelsHeight = g_ddraw->render.height;
@ -483,49 +502,51 @@ HRESULT dd_SetDisplayMode(DWORD width, DWORD height, DWORD bpp, BOOL set_by_game
g_ddraw->render.mode.dmFields |= DM_BITSPERPEL;
g_ddraw->render.mode.dmBitsPerPel = g_ddraw->render.bpp;
}
BOOL maintas = g_ddraw->maintas;
if (!g_ddraw->windowed)
{
// Making sure the chosen resolution is valid
/* Making sure the chosen resolution is valid */
int old_width = g_ddraw->render.width;
int old_height = g_ddraw->render.height;
if (ChangeDisplaySettings(&g_ddraw->render.mode, CDS_TEST) != DISP_CHANGE_SUCCESSFUL)
{
// fail... compare resolutions
if (g_ddraw->render.width > g_ddraw->mode.dmPelsWidth || g_ddraw->render.height > g_ddraw->mode.dmPelsHeight)
/* fail... compare resolutions */
if (g_ddraw->render.width > g_ddraw->mode.dmPelsWidth ||
g_ddraw->render.height > g_ddraw->mode.dmPelsHeight)
{
// chosen game resolution higher than current resolution, use windowed mode for this case
/* chosen game resolution higher than current resolution, use windowed mode for this case */
g_ddraw->windowed = TRUE;
}
else
{
// Try 2x scaling
/* Try 2x scaling */
g_ddraw->render.width *= 2;
g_ddraw->render.height *= 2;
g_ddraw->render.mode.dmPelsWidth = g_ddraw->render.width;
g_ddraw->render.mode.dmPelsHeight = g_ddraw->render.height;
if ((g_ddraw->render.width > g_ddraw->mode.dmPelsWidth || g_ddraw->render.height > g_ddraw->mode.dmPelsHeight) ||
if ((g_ddraw->render.width > g_ddraw->mode.dmPelsWidth ||
g_ddraw->render.height > g_ddraw->mode.dmPelsHeight) ||
ChangeDisplaySettings(&g_ddraw->render.mode, CDS_TEST) != DISP_CHANGE_SUCCESSFUL)
{
SIZE res = {0};
SIZE res = { 0 };
//try to get a resolution with the same aspect ratio as the requested resolution
/* try to get a resolution with the same aspect ratio as the requested resolution */
BOOL found_res = util_get_lowest_resolution(
(float)old_width / old_height,
&res,
old_width + 1, //don't return the original resolution since we tested that one already
old_width + 1, /* don't return the original resolution since we tested that one already */
old_height + 1,
g_ddraw->mode.dmPelsWidth,
g_ddraw->mode.dmPelsHeight);
if (!found_res)
{
//try to get a resolution with the same aspect ratio as the current display mode
/* try to get a resolution with the same aspect ratio as the current display mode */
found_res = util_get_lowest_resolution(
(float)g_ddraw->mode.dmPelsWidth / g_ddraw->mode.dmPelsHeight,
&res,
@ -543,10 +564,10 @@ HRESULT dd_SetDisplayMode(DWORD width, DWORD height, DWORD bpp, BOOL set_by_game
g_ddraw->render.mode.dmPelsWidth = g_ddraw->render.width;
g_ddraw->render.mode.dmPelsHeight = g_ddraw->render.height;
if (!found_res || ChangeDisplaySettings(&g_ddraw->render.mode, CDS_TEST) != DISP_CHANGE_SUCCESSFUL)
{
// try current display settings
/* try current display settings */
g_ddraw->render.width = g_ddraw->mode.dmPelsWidth;
g_ddraw->render.height = g_ddraw->mode.dmPelsHeight;
@ -555,7 +576,7 @@ HRESULT dd_SetDisplayMode(DWORD width, DWORD height, DWORD bpp, BOOL set_by_game
if (ChangeDisplaySettings(&g_ddraw->render.mode, CDS_TEST) != DISP_CHANGE_SUCCESSFUL)
{
// everything failed, use windowed mode instead
/* everything failed, use windowed mode instead */
g_ddraw->render.width = old_width;
g_ddraw->render.height = old_height;
@ -586,14 +607,13 @@ HRESULT dd_SetDisplayMode(DWORD width, DWORD height, DWORD bpp, BOOL set_by_game
g_ddraw->render.viewport.height = g_ddraw->render.height;
g_ddraw->render.viewport.x = 0;
g_ddraw->render.viewport.y = 0;
if (g_ddraw->boxing)
{
g_ddraw->render.viewport.width = g_ddraw->width;
g_ddraw->render.viewport.height = g_ddraw->height;
int i;
for (i = 20; i-- > 1;)
for (int i = 20; i-- > 1;)
{
if (g_ddraw->width * i <= g_ddraw->render.width && g_ddraw->height * i <= g_ddraw->render.height)
{
@ -609,20 +629,21 @@ HRESULT dd_SetDisplayMode(DWORD width, DWORD height, DWORD bpp, BOOL set_by_game
else if (maintas)
{
g_ddraw->render.viewport.width = g_ddraw->render.width;
g_ddraw->render.viewport.height = (int)(((float)g_ddraw->height / g_ddraw->width) * g_ddraw->render.viewport.width);
g_ddraw->render.viewport.height =
(int)(((float)g_ddraw->height / g_ddraw->width) * g_ddraw->render.viewport.width);
if (g_ddraw->render.viewport.height > g_ddraw->render.height)
{
g_ddraw->render.viewport.width =
g_ddraw->render.viewport.width =
(int)(((float)g_ddraw->render.viewport.width / g_ddraw->render.viewport.height) * g_ddraw->render.height);
g_ddraw->render.viewport.height = g_ddraw->render.height;
}
g_ddraw->render.viewport.y = g_ddraw->render.height / 2 - g_ddraw->render.viewport.height / 2;
g_ddraw->render.viewport.x = g_ddraw->render.width / 2 - g_ddraw->render.viewport.width / 2;
}
g_ddraw->render.scale_w = ((float)g_ddraw->render.viewport.width / g_ddraw->width);
g_ddraw->render.scale_h = ((float)g_ddraw->render.viewport.height / g_ddraw->height);
g_ddraw->render.unscale_w = ((float)g_ddraw->width / g_ddraw->render.viewport.width);
@ -630,29 +651,41 @@ HRESULT dd_SetDisplayMode(DWORD width, DWORD height, DWORD bpp, BOOL set_by_game
if (g_ddraw->windowed)
{
MSG msg; // workaround for "Not Responding" window problem in cnc games
MSG msg; /* workaround for "Not Responding" window problem in cnc games */
PeekMessage(&msg, g_ddraw->hwnd, 0, 0, PM_NOREMOVE);
if (!border)
{
real_SetWindowLongA(g_ddraw->hwnd, GWL_STYLE, GetWindowLong(g_ddraw->hwnd, GWL_STYLE) & ~(WS_CAPTION | WS_THICKFRAME | WS_MINIMIZE | WS_MAXIMIZE | WS_SYSMENU));
real_SetWindowLongA(
g_ddraw->hwnd,
GWL_STYLE,
GetWindowLong(
g_ddraw->hwnd, GWL_STYLE) & ~(WS_CAPTION | WS_THICKFRAME | WS_MINIMIZE | WS_MAXIMIZE | WS_SYSMENU));
}
else
{
real_SetWindowLongA(g_ddraw->hwnd, GWL_STYLE, (GetWindowLong(g_ddraw->hwnd, GWL_STYLE) | WS_OVERLAPPEDWINDOW));// &~WS_MAXIMIZEBOX);
real_SetWindowLongA(
g_ddraw->hwnd,
GWL_STYLE,
(GetWindowLong(g_ddraw->hwnd, GWL_STYLE) | WS_OVERLAPPEDWINDOW));// &~WS_MAXIMIZEBOX);
}
if (g_ddraw->wine)
real_SetWindowLongA(g_ddraw->hwnd, GWL_STYLE, (GetWindowLong(g_ddraw->hwnd, GWL_STYLE) | WS_MINIMIZEBOX) & ~(WS_MAXIMIZEBOX | WS_THICKFRAME));
{
real_SetWindowLongA(
g_ddraw->hwnd,
GWL_STYLE,
(GetWindowLong(g_ddraw->hwnd, GWL_STYLE) | WS_MINIMIZEBOX) & ~(WS_MAXIMIZEBOX | WS_THICKFRAME));
}
/* center the window with correct dimensions */
int cy = g_ddraw->mode.dmPelsWidth ? g_ddraw->mode.dmPelsWidth : g_ddraw->render.width;
int cx = g_ddraw->mode.dmPelsHeight ? g_ddraw->mode.dmPelsHeight : g_ddraw->render.height;
int x = (g_config.window_rect.left != -32000) ? g_config.window_rect.left : (cy / 2) - (g_ddraw->render.width / 2);
int y = (g_config.window_rect.top != -32000) ? g_config.window_rect.top : (cx / 2) - (g_ddraw->render.height / 2);
RECT dst = { x, y, g_ddraw->render.width + x, g_ddraw->render.height + y };
AdjustWindowRect(&dst, GetWindowLong(g_ddraw->hwnd, GWL_STYLE), FALSE);
real_SetWindowPos(g_ddraw->hwnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
real_MoveWindow(g_ddraw->hwnd, dst.left, dst.top, (dst.right - dst.left), (dst.bottom - dst.top), TRUE);
@ -680,7 +713,10 @@ HRESULT dd_SetDisplayMode(DWORD width, DWORD height, DWORD bpp, BOOL set_by_game
if ((style & WS_CAPTION))
{
real_SetWindowLongA(g_ddraw->hwnd, GWL_STYLE, style & ~(WS_CAPTION | WS_THICKFRAME | WS_MINIMIZE | WS_MAXIMIZE | WS_SYSMENU));
real_SetWindowLongA(
g_ddraw->hwnd,
GWL_STYLE,
style & ~(WS_CAPTION | WS_THICKFRAME | WS_MINIMIZE | WS_MAXIMIZE | WS_SYSMENU));
}
BOOL d3d9_active = FALSE;
@ -701,7 +737,7 @@ HRESULT dd_SetDisplayMode(DWORD width, DWORD height, DWORD bpp, BOOL set_by_game
{
g_ddraw->render.run = FALSE;
g_ddraw->windowed = TRUE;
return dd_SetDisplayMode(width, height, bpp, set_by_game);
return dd_SetDisplayMode(dwWidth, dwHeight, dwBPP, setByGame);
}
if (g_ddraw->wine)
@ -709,12 +745,20 @@ HRESULT dd_SetDisplayMode(DWORD width, DWORD height, DWORD bpp, BOOL set_by_game
real_SetWindowLongA(g_ddraw->hwnd, GWL_STYLE, GetWindowLong(g_ddraw->hwnd, GWL_STYLE) | WS_MINIMIZEBOX);
}
real_SetWindowPos(g_ddraw->hwnd, HWND_TOPMOST, 0, 0, g_ddraw->render.width, g_ddraw->render.height, SWP_SHOWWINDOW);
real_SetWindowPos(
g_ddraw->hwnd,
HWND_TOPMOST,
0,
0,
g_ddraw->render.width,
g_ddraw->render.height,
SWP_SHOWWINDOW);
g_ddraw->last_set_window_pos_tick = timeGetTime();
mouse_lock();
}
if (g_ddraw->render.viewport.x != 0 || g_ddraw->render.viewport.y != 0)
{
RedrawWindow(g_ddraw->hwnd, NULL, NULL, RDW_ERASE | RDW_INVALIDATE);
@ -729,7 +773,7 @@ HRESULT dd_SetDisplayMode(DWORD width, DWORD height, DWORD bpp, BOOL set_by_game
g_ddraw->render.thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)g_ddraw->renderer, NULL, 0, NULL);
}
if (set_by_game)
if (setByGame)
{
real_SendMessageA(g_ddraw->hwnd, WM_SIZE_DDRAW, 0, MAKELPARAM(g_ddraw->width, g_ddraw->height));
real_SendMessageA(g_ddraw->hwnd, WM_MOVE_DDRAW, 0, MAKELPARAM(0, 0));
@ -743,7 +787,6 @@ HRESULT dd_SetCooperativeLevel(HWND hwnd, DWORD dwFlags)
{
PIXELFORMATDESCRIPTOR pfd;
/* Red Alert for some weird reason does this on Windows XP */
if (hwnd == NULL)
{
return DD_OK;
@ -768,7 +811,9 @@ HRESULT dd_SetCooperativeLevel(HWND hwnd, DWORD dwFlags)
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER | (g_ddraw->renderer == ogl_render_main ? PFD_SUPPORT_OPENGL : 0);
pfd.dwFlags =
PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER | (g_ddraw->renderer == ogl_render_main ? PFD_SUPPORT_OPENGL : 0);
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = g_ddraw->render.bpp ? g_ddraw->render.bpp : g_ddraw->mode.dmBitsPerPel;
pfd.iLayerType = PFD_MAIN_PLANE;
@ -778,7 +823,7 @@ HRESULT dd_SetCooperativeLevel(HWND hwnd, DWORD dwFlags)
if (g_ddraw->handlemouse && g_ddraw->windowed)
{
while (real_ShowCursor(FALSE) > 0); //workaround for direct input games
while (real_ShowCursor(FALSE) > 0); /* workaround for direct input games */
while (real_ShowCursor(TRUE) < 0);
}
@ -810,7 +855,7 @@ HRESULT dd_SetCooperativeLevel(HWND hwnd, DWORD dwFlags)
return DD_OK;
}
HRESULT dd_WaitForVerticalBlank(DWORD dwFlags, HANDLE h)
HRESULT dd_WaitForVerticalBlank(DWORD dwFlags, HANDLE hEvent)
{
if (g_ddraw->maxgameticks == -2)
{
@ -952,7 +997,7 @@ ULONG dd_Release()
return g_ddraw->ref;
}
HRESULT dd_GetAvailableVidMem(void* lpDDCaps, LPDWORD lpdwTotal, LPDWORD lpdwFree)
HRESULT dd_GetAvailableVidMem(LPDDSCAPS2 lpDDCaps, LPDWORD lpdwTotal, LPDWORD lpdwFree)
{
*lpdwTotal = 16777216;
*lpdwFree = 16777216;
@ -977,7 +1022,7 @@ HRESULT dd_CreateEx(GUID* lpGuid, LPVOID* lplpDD, REFIID iid, IUnknown* pUnkOute
g_ddraw->real_dll = LoadLibrary("system32\\ddraw.dll");
if (g_ddraw->real_dll && !g_ddraw->DirectDrawCreate)
g_ddraw->DirectDrawCreate = (DIRECTDRAWCREATEPROC)GetProcAddress(g_ddraw->real_dll, "DirectDrawCreate");
g_ddraw->DirectDrawCreate = (void*)GetProcAddress(g_ddraw->real_dll, "DirectDrawCreate");
if (g_ddraw->DirectDrawCreate == DirectDrawCreate)
g_ddraw->DirectDrawCreate = NULL;
@ -991,7 +1036,7 @@ HRESULT dd_CreateEx(GUID* lpGuid, LPVOID* lplpDD, REFIID iid, IUnknown* pUnkOute
}
else
{
g_ddraw = (cnc_ddraw*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(cnc_ddraw));
g_ddraw = (CNCDDRAW*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CNCDDRAW));
g_ddraw->ref++;
InitializeCriticalSection(&g_ddraw->cs);
@ -1004,16 +1049,16 @@ HRESULT dd_CreateEx(GUID* lpGuid, LPVOID* lplpDD, REFIID iid, IUnknown* pUnkOute
}
IDirectDrawImpl* dd = (IDirectDrawImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawImpl));
if (iid && IsEqualGUID(&IID_IDirectDraw, iid))
{
dprintf(" GUID = %08X (IID_IDirectDraw), ddraw = %p\n", ((GUID*)iid)->Data1, dd);
TRACE(" GUID = %08X (IID_IDirectDraw), ddraw = %p\n", ((GUID*)iid)->Data1, dd);
dd->lpVtbl = &g_dd_vtbl1;
}
else
{
dprintf(" GUID = %08X (IID_IDirectDrawX), ddraw = %p\n", iid ? ((GUID*)iid)->Data1 : 0, dd);
TRACE(" GUID = %08X (IID_IDirectDrawX), ddraw = %p\n", iid ? ((GUID*)iid)->Data1 : 0, dd);
dd->lpVtbl = &g_dd_vtblx;
}

11
src/ddclipper.c
View file

@ -5,19 +5,20 @@
#include "debug.h"
HRESULT dd_CreateClipper(DWORD dwFlags, LPDIRECTDRAWCLIPPER FAR *lplpDDClipper, IUnknown FAR *pUnkOuter )
HRESULT dd_CreateClipper(DWORD dwFlags, IDirectDrawClipperImpl** lplpDDClipper, IUnknown FAR* pUnkOuter)
{
if (!lplpDDClipper)
return DDERR_INVALIDPARAMS;
IDirectDrawClipperImpl *c = (IDirectDrawClipperImpl *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawClipperImpl));
dprintf(" Clipper = %p\n", c);
IDirectDrawClipperImpl* c =
(IDirectDrawClipperImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawClipperImpl));
TRACE(" clipper = %p\n", c);
c->lpVtbl = &g_ddc_vtbl;
IDirectDrawClipper_AddRef(c);
*lplpDDClipper = (LPDIRECTDRAWCLIPPER)c;
*lplpDDClipper = c;
return DD_OK;
}

32
src/ddpalette.c
View file

@ -7,7 +7,12 @@
#include "debug.h"
HRESULT ddp_GetEntries(IDirectDrawPaletteImpl *This, DWORD dwFlags, DWORD dwBase, DWORD dwNumEntries, LPPALETTEENTRY lpEntries)
HRESULT ddp_GetEntries(
IDirectDrawPaletteImpl* This,
DWORD dwFlags,
DWORD dwBase,
DWORD dwNumEntries,
LPPALETTEENTRY lpEntries)
{
for (int i = dwBase, x = 0; i < dwBase + dwNumEntries; i++, x++)
{
@ -19,7 +24,12 @@ HRESULT ddp_GetEntries(IDirectDrawPaletteImpl *This, DWORD dwFlags, DWORD dwBase
return DD_OK;
}
HRESULT ddp_SetEntries(IDirectDrawPaletteImpl *This, DWORD dwFlags, DWORD dwStartingEntry, DWORD dwCount, LPPALETTEENTRY lpEntries)
HRESULT ddp_SetEntries(
IDirectDrawPaletteImpl* This,
DWORD dwFlags,
DWORD dwStartingEntry,
DWORD dwCount,
LPPALETTEENTRY lpEntries)
{
for (int i = dwStartingEntry, x = 0; i < dwStartingEntry + dwCount; i++, x++)
{
@ -56,18 +66,26 @@ HRESULT ddp_SetEntries(IDirectDrawPaletteImpl *This, DWORD dwFlags, DWORD dwStar
return DD_OK;
}
HRESULT dd_CreatePalette(DWORD dwFlags, LPPALETTEENTRY lpDDColorArray, LPDIRECTDRAWPALETTE FAR * lpDDPalette, IUnknown FAR * unkOuter)
HRESULT dd_CreatePalette(
DWORD dwFlags,
LPPALETTEENTRY lpDDColorArray,
IDirectDrawPaletteImpl** lpDDPalette,
IUnknown FAR* unkOuter)
{
IDirectDrawPaletteImpl *p = (IDirectDrawPaletteImpl *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawPaletteImpl));
dprintf(" Palette = %p\n", p);
if (!lpDDPalette || !lpDDColorArray)
return DDERR_INVALIDPARAMS;
IDirectDrawPaletteImpl* p =
(IDirectDrawPaletteImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawPaletteImpl));
TRACE(" palette = %p\n", p);
p->lpVtbl = &g_ddp_vtbl;
p->flags = dwFlags;
ddp_SetEntries(p, dwFlags, 0, 256, lpDDColorArray);
IDirectDrawPalette_AddRef(p);
*lpDDPalette = (LPDIRECTDRAWPALETTE)p;
*lpDDPalette = p;
return DD_OK;
}

379
src/ddsurface.c
View file

@ -12,34 +12,37 @@
#include "utils.h"
HRESULT dds_AddAttachedSurface(IDirectDrawSurfaceImpl *This, LPDIRECTDRAWSURFACE lpDDSurface)
HRESULT dds_AddAttachedSurface(IDirectDrawSurfaceImpl* This, IDirectDrawSurfaceImpl* lpDDSurface)
{
if (lpDDSurface)
{
IDirectDrawSurface_AddRef(lpDDSurface);
if (g_ddraw->backbuffer && !This->backbuffer)
if (!This->backbuffer)
{
IDirectDrawSurfaceImpl* surface = (IDirectDrawSurfaceImpl*)lpDDSurface;
surface->caps |= DDSCAPS_BACKBUFFER;
This->backbuffer = surface;
lpDDSurface->caps |= DDSCAPS_BACKBUFFER;
This->backbuffer = lpDDSurface;
}
}
return DD_OK;
}
HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE lpDDSrcSurface, LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx)
HRESULT dds_Blt(
IDirectDrawSurfaceImpl* This,
LPRECT lpDestRect,
IDirectDrawSurfaceImpl* lpDDSrcSurface,
LPRECT lpSrcRect,
DWORD dwFlags,
LPDDBLTFX lpDDBltFx)
{
IDirectDrawSurfaceImpl *src_surface = (IDirectDrawSurfaceImpl *)lpDDSrcSurface;
dbg_dump_dds_blt_flags(dwFlags);
dbg_dump_dds_blt_fx_flags((dwFlags & DDBLT_DDFX) && lpDDBltFx ? lpDDBltFx->dwDDFX : 0);
if (g_ddraw->iskkndx &&
(dwFlags & DDBLT_COLORFILL) &&
lpDestRect &&
lpDestRect->right == 640 &&
if (g_ddraw->iskkndx &&
(dwFlags & DDBLT_COLORFILL) &&
lpDestRect &&
lpDestRect->right == 640 &&
lpDestRect->bottom == 480)
{
if (This->backbuffer)
@ -50,6 +53,8 @@ HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSUR
lpDestRect = NULL;
}
IDirectDrawSurfaceImpl* src_surface = lpDDSrcSurface;
RECT src_rect = { 0, 0, src_surface ? src_surface->width : 0, src_surface ? src_surface->height : 0 };
RECT dst_rect = { 0, 0, This->width, This->height };
@ -59,8 +64,8 @@ HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSUR
if (lpDestRect)
memcpy(&dst_rect, lpDestRect, sizeof(dst_rect));
// stretch or clip?
BOOL is_stretch_blt =
/* stretch or clip? */
BOOL is_stretch_blt =
((src_rect.right - src_rect.left) != (dst_rect.right - dst_rect.left)) ||
((src_rect.bottom - src_rect.top) != (dst_rect.bottom - dst_rect.top));
@ -118,8 +123,8 @@ HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSUR
if (dst_buf && (dwFlags & DDBLT_COLORFILL) && dst_w > 0 && dst_h > 0)
{
unsigned char *dst = (unsigned char *)dst_buf + (dst_x * This->lx_pitch) + (This->l_pitch * dst_y);
unsigned char *first_row = dst;
unsigned char* dst = (unsigned char*)dst_buf + (dst_x * This->lx_pitch) + (This->l_pitch * dst_y);
unsigned char* first_row = dst;
unsigned int dst_pitch = dst_w * This->lx_pitch;
int x, i;
@ -135,7 +140,7 @@ HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSUR
}
else if (This->bpp == 16)
{
unsigned short *row1 = (unsigned short *)dst;
unsigned short* row1 = (unsigned short*)dst;
unsigned short color = (unsigned short)lpDDBltFx->dwFillColor;
if ((color & 0xFF) == (color >> 8))
@ -195,7 +200,7 @@ HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSUR
{
if (This->bpp != src_surface->bpp)
{
dprintfex(" NOT_IMPLEMENTED This->bpp=%u, src_surface->bpp=%u\n", This->bpp, src_surface->bpp);
TRACE_EXT(" NOT_IMPLEMENTED This->bpp=%u, src_surface->bpp=%u\n", This->bpp, src_surface->bpp);
HDC dst_dc;
dds_GetDC(This, &dst_dc);
@ -211,11 +216,11 @@ HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSUR
color_key.dwColorSpaceLowValue =
(dwFlags & DDBLT_KEYSRCOVERRIDE) ?
lpDDBltFx->ddckSrcColorkey.dwColorSpaceLowValue : src_surface->color_key.dwColorSpaceLowValue;
lpDDBltFx->ddckSrcColorkey.dwColorSpaceLowValue : src_surface->color_key.dwColorSpaceLowValue;
color_key.dwColorSpaceHighValue =
(dwFlags & DDBLT_KEYSRCOVERRIDE) ?
lpDDBltFx->ddckSrcColorkey.dwColorSpaceHighValue : src_surface->color_key.dwColorSpaceHighValue;
lpDDBltFx->ddckSrcColorkey.dwColorSpaceHighValue : src_surface->color_key.dwColorSpaceHighValue;
BOOL got_fx = (dwFlags & DDBLT_DDFX) && lpDDBltFx;
BOOL mirror_left_right = got_fx && (lpDDBltFx->dwDDFX & DDBLTFX_MIRRORLEFTRIGHT);
@ -316,11 +321,11 @@ HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSUR
int width = dst_w > src_w ? src_w : dst_w;
int height = dst_h > src_h ? src_h : dst_h;
unsigned char *src =
(unsigned char *)src_buf + (src_x * src_surface->lx_pitch) + (src_surface->l_pitch * src_y);
unsigned char* src =
(unsigned char*)src_buf + (src_x * src_surface->lx_pitch) + (src_surface->l_pitch * src_y);
unsigned char *dst =
(unsigned char *)dst_buf + (dst_x * This->lx_pitch) + (This->l_pitch * dst_y);
unsigned char* dst =
(unsigned char*)dst_buf + (dst_x * This->lx_pitch) + (This->l_pitch * dst_y);
unsigned int dst_pitch = width * This->lx_pitch;
@ -374,13 +379,13 @@ HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSUR
unsigned int s_src_x, s_src_y;
unsigned int dest_base, source_base;
scale_pattern *pattern = malloc((dst_w + 1) * (sizeof(scale_pattern)));
scale_pattern* pattern = malloc((dst_w + 1) * (sizeof(scale_pattern)));
int pattern_idx = 0;
unsigned int last_src_x = 0;
if (pattern != NULL)
{
pattern[pattern_idx] = (scale_pattern) { ONCE, 0, 0, 1 };
pattern[pattern_idx] = (scale_pattern){ ONCE, 0, 0, 1 };
/* Build the pattern! */
int x;
@ -396,7 +401,7 @@ HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSUR
else if (pattern[pattern_idx].type == SEQUENCE)
{
pattern_idx++;
pattern[pattern_idx] = (scale_pattern) { REPEAT, x, s_src_x, 1 };
pattern[pattern_idx] = (scale_pattern){ REPEAT, x, s_src_x, 1 };
}
}
else if (s_src_x == last_src_x + 1)
@ -409,17 +414,17 @@ HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSUR
else if (pattern[pattern_idx].type == REPEAT)
{
pattern_idx++;
pattern[pattern_idx] = (scale_pattern) { ONCE, x, s_src_x, 1 };
pattern[pattern_idx] = (scale_pattern){ ONCE, x, s_src_x, 1 };
}
}
else
{
pattern_idx++;
pattern[pattern_idx] = (scale_pattern) { ONCE, x, s_src_x, 1 };
pattern[pattern_idx] = (scale_pattern){ ONCE, x, s_src_x, 1 };
}
last_src_x = s_src_x;
}
pattern[pattern_idx + 1] = (scale_pattern) { END, 0, 0, 0 };
pattern[pattern_idx + 1] = (scale_pattern){ END, 0, 0, 0 };
/* Do the actual blitting */
@ -435,13 +440,13 @@ HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSUR
source_base = src_x + src_surface->width * (s_src_y + src_y);
pattern_idx = 0;
scale_pattern *current = &pattern[pattern_idx];
scale_pattern* current = &pattern[pattern_idx];
if (This->bpp == 8)
{
unsigned char *d, *s, v;
unsigned char *src = (unsigned char *)src_buf;
unsigned char *dst = (unsigned char *)dst_buf;
unsigned char* d, * s, v;
unsigned char* src = (unsigned char*)src_buf;
unsigned char* dst = (unsigned char*)dst_buf;
do {
switch (current->type)
@ -465,7 +470,7 @@ HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSUR
d = dst + dest_base + current->dst_index;
s = src + source_base + current->src_index;
memcpy((void *)d, (void *)s, current->count * This->lx_pitch);
memcpy((void*)d, (void*)s, current->count * This->lx_pitch);
break;
case END:
@ -478,9 +483,9 @@ HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSUR
}
else if (This->bpp == 16)
{
unsigned short *d, *s, v;
unsigned short *src = (unsigned short *)src_buf;
unsigned short *dst = (unsigned short *)dst_buf;
unsigned short* d, * s, v;
unsigned short* src = (unsigned short*)src_buf;
unsigned short* dst = (unsigned short*)dst_buf;
do {
switch (current->type)
@ -504,7 +509,7 @@ HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSUR
d = dst + dest_base + current->dst_index;
s = src + source_base + current->src_index;
memcpy((void *)d, (void *)s, current->count * This->lx_pitch);
memcpy((void*)d, (void*)s, current->count * This->lx_pitch);
break;
case END:
@ -562,7 +567,7 @@ HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSUR
}
}
if((This->caps & DDSCAPS_PRIMARYSURFACE) && g_ddraw->render.run)
if ((This->caps & DDSCAPS_PRIMARYSURFACE) && g_ddraw->render.run)
{
InterlockedExchange(&g_ddraw->render.surface_updated, TRUE);
@ -584,11 +589,17 @@ HRESULT dds_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDIRECTDRAWSUR
return DD_OK;
}
HRESULT dds_BltFast(IDirectDrawSurfaceImpl *This, DWORD dst_x, DWORD dst_y, LPDIRECTDRAWSURFACE lpDDSrcSurface, LPRECT lpSrcRect, DWORD flags)
HRESULT dds_BltFast(
IDirectDrawSurfaceImpl* This,
DWORD dwX,
DWORD dwY,
IDirectDrawSurfaceImpl* lpDDSrcSurface,
LPRECT lpSrcRect,
DWORD dwFlags)
{
IDirectDrawSurfaceImpl *src_surface = (IDirectDrawSurfaceImpl *)lpDDSrcSurface;
dbg_dump_dds_blt_fast_flags(dwFlags);
dbg_dump_dds_blt_fast_flags(flags);
IDirectDrawSurfaceImpl* src_surface = lpDDSrcSurface;
RECT src_rect = { 0, 0, src_surface ? src_surface->width : 0, src_surface ? src_surface->height : 0 };
@ -617,6 +628,8 @@ HRESULT dds_BltFast(IDirectDrawSurfaceImpl *This, DWORD dst_x, DWORD dst_y, LPDI
int src_x = src_rect.left;
int src_y = src_rect.top;
int dst_x = dwX;
int dst_y = dwY;
RECT dst_rect = { dst_x, dst_y, (src_rect.right - src_rect.left) + dst_x, (src_rect.bottom - src_rect.top) + dst_y };
@ -650,7 +663,7 @@ HRESULT dds_BltFast(IDirectDrawSurfaceImpl *This, DWORD dst_x, DWORD dst_y, LPDI
{
if (This->bpp != src_surface->bpp)
{
dprintfex(" NOT_IMPLEMENTED This->bpp=%u, src_surface->bpp=%u\n", This->bpp, src_surface->bpp);
TRACE_EXT(" NOT_IMPLEMENTED This->bpp=%u, src_surface->bpp=%u\n", This->bpp, src_surface->bpp);
HDC dst_dc;
dds_GetDC(This, &dst_dc);
@ -660,7 +673,7 @@ HRESULT dds_BltFast(IDirectDrawSurfaceImpl *This, DWORD dst_x, DWORD dst_y, LPDI
BitBlt(dst_dc, dst_x, dst_y, dst_w, dst_h, src_dc, src_x, src_y, SRCCOPY);
}
else if (flags & DDBLTFAST_SRCCOLORKEY)
else if (dwFlags & DDBLTFAST_SRCCOLORKEY)
{
if (This->bpp == 8)
{
@ -671,11 +684,12 @@ HRESULT dds_BltFast(IDirectDrawSurfaceImpl *This, DWORD dst_x, DWORD dst_y, LPDI
for (int x = 0; x < dst_w; x++)
{
unsigned char c = ((unsigned char *)src_buf)[x + src_x + src_row];
unsigned char c = ((unsigned char*)src_buf)[x + src_x + src_row];
if (c < src_surface->color_key.dwColorSpaceLowValue || c > src_surface->color_key.dwColorSpaceHighValue)
if (c < src_surface->color_key.dwColorSpaceLowValue ||
c > src_surface->color_key.dwColorSpaceHighValue)
{
((unsigned char *)dst_buf)[x + dst_x + dst_row] = c;
((unsigned char*)dst_buf)[x + dst_x + dst_row] = c;
}
}
}
@ -689,11 +703,12 @@ HRESULT dds_BltFast(IDirectDrawSurfaceImpl *This, DWORD dst_x, DWORD dst_y, LPDI
for (int x = 0; x < dst_w; x++)
{
unsigned short c = ((unsigned short *)src_buf)[x + src_x + src_row];
if (c < src_surface->color_key.dwColorSpaceLowValue || c > src_surface->color_key.dwColorSpaceHighValue)
unsigned short c = ((unsigned short*)src_buf)[x + src_x + src_row];
if (c < src_surface->color_key.dwColorSpaceLowValue ||
c > src_surface->color_key.dwColorSpaceHighValue)
{
((unsigned short *)dst_buf)[x + dst_x + dst_row] = c;
((unsigned short*)dst_buf)[x + dst_x + dst_row] = c;
}
}
}
@ -709,7 +724,8 @@ HRESULT dds_BltFast(IDirectDrawSurfaceImpl *This, DWORD dst_x, DWORD dst_y, LPDI
{
unsigned int c = ((unsigned int*)src_buf)[x + src_x + src_row];
if (c < src_surface->color_key.dwColorSpaceLowValue || c > src_surface->color_key.dwColorSpaceHighValue)
if (c < src_surface->color_key.dwColorSpaceLowValue ||
c > src_surface->color_key.dwColorSpaceHighValue)
{
((unsigned int*)dst_buf)[x + dst_x + dst_row] = c;
}
@ -719,11 +735,11 @@ HRESULT dds_BltFast(IDirectDrawSurfaceImpl *This, DWORD dst_x, DWORD dst_y, LPDI
}
else
{
unsigned char *src =
(unsigned char *)src_buf + (src_x * src_surface->lx_pitch) + (src_surface->l_pitch * src_y);
unsigned char* src =
(unsigned char*)src_buf + (src_x * src_surface->lx_pitch) + (src_surface->l_pitch * src_y);
unsigned char *dst =
(unsigned char *)dst_buf + (dst_x * This->lx_pitch) + (This->l_pitch * dst_y);
unsigned char* dst =
(unsigned char*)dst_buf + (dst_x * This->lx_pitch) + (This->l_pitch * dst_y);
unsigned int dst_pitch = dst_w * This->lx_pitch;
@ -772,7 +788,7 @@ HRESULT dds_BltFast(IDirectDrawSurfaceImpl *This, DWORD dst_x, DWORD dst_y, LPDI
DWORD time = timeGetTime();
if (!(This->flags & DDSD_BACKBUFFERCOUNT) ||
if (!(This->flags & DDSD_BACKBUFFERCOUNT) ||
(This->last_flip_tick + FLIP_REDRAW_TIMEOUT < time && This->last_blt_tick + FLIP_REDRAW_TIMEOUT < time))
{
ReleaseSemaphore(g_ddraw->render.sem, 1, NULL);
@ -782,24 +798,28 @@ HRESULT dds_BltFast(IDirectDrawSurfaceImpl *This, DWORD dst_x, DWORD dst_y, LPDI
return DD_OK;
}
HRESULT dds_DeleteAttachedSurface(IDirectDrawSurfaceImpl *This, DWORD dwFlags, LPDIRECTDRAWSURFACE lpDDSurface)
HRESULT dds_DeleteAttachedSurface(IDirectDrawSurfaceImpl* This, DWORD dwFlags, IDirectDrawSurfaceImpl* lpDDSurface)
{
if (lpDDSurface)
{
IDirectDrawSurface_Release(lpDDSurface);
This->backbuffer = NULL;
if (lpDDSurface == This->backbuffer)
This->backbuffer = NULL;
}
return DD_OK;
}
HRESULT dds_GetSurfaceDesc(IDirectDrawSurfaceImpl *This, LPDDSURFACEDESC lpDDSurfaceDesc)
HRESULT dds_GetSurfaceDesc(IDirectDrawSurfaceImpl* This, LPDDSURFACEDESC2 lpDDSurfaceDesc)
{
if (lpDDSurfaceDesc)
{
memset(lpDDSurfaceDesc, 0, sizeof(DDSURFACEDESC));
int size = lpDDSurfaceDesc->dwSize == sizeof(DDSURFACEDESC2) ? sizeof(DDSURFACEDESC2) : sizeof(DDSURFACEDESC);
lpDDSurfaceDesc->dwSize = sizeof(DDSURFACEDESC);
memset(lpDDSurfaceDesc, 0, size);
lpDDSurfaceDesc->dwSize = size;
lpDDSurfaceDesc->dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PITCH | DDSD_PIXELFORMAT | DDSD_LPSURFACE;
lpDDSurfaceDesc->dwWidth = This->width;
lpDDSurfaceDesc->dwHeight = This->height;
@ -810,7 +830,7 @@ HRESULT dds_GetSurfaceDesc(IDirectDrawSurfaceImpl *This, LPDDSURFACEDESC lpDDSur
lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = This->bpp;
lpDDSurfaceDesc->ddsCaps.dwCaps = This->caps;
if ((This->caps & DDSCAPS_PRIMARYSURFACE) || (This->caps & DDSCAPS_BACKBUFFER))
if (This->caps & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_BACKBUFFER))
{
lpDDSurfaceDesc->ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
}
@ -836,38 +856,31 @@ HRESULT dds_GetSurfaceDesc(IDirectDrawSurfaceImpl *This, LPDDSURFACEDESC lpDDSur
return DD_OK;
}
HRESULT dds_EnumAttachedSurfaces(IDirectDrawSurfaceImpl *This, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpEnumSurfacesCallback)
HRESULT dds_EnumAttachedSurfaces(
IDirectDrawSurfaceImpl* This,
LPVOID lpContext,
LPDDENUMSURFACESCALLBACK7 lpEnumSurfacesCallback)
{
static DDSURFACEDESC dd_surface_desc;
memset(&dd_surface_desc, 0, sizeof(DDSURFACEDESC));
static DDSURFACEDESC2 desc;
memset(&desc, 0, sizeof(desc));
if (This->backbuffer)
{
dds_GetSurfaceDesc(This->backbuffer, &dd_surface_desc);
dds_GetSurfaceDesc(This->backbuffer, &desc);
IDirectDrawSurface_AddRef(This->backbuffer);
lpEnumSurfacesCallback((LPDIRECTDRAWSURFACE)This->backbuffer, &dd_surface_desc, lpContext);
}
else if (!g_ddraw->backbuffer)
{
dds_GetSurfaceDesc(This, &dd_surface_desc);
This->caps |= DDSCAPS_BACKBUFFER; // Nox hack
lpEnumSurfacesCallback((LPDIRECTDRAWSURFACE)This, &dd_surface_desc, lpContext);
if ((This->caps & DDSCAPS_PRIMARYSURFACE) && (This->caps & DDSCAPS_FLIP) && !(This->caps & DDSCAPS_BACKBUFFER))
IDirectDrawSurface_AddRef(This);
This->caps &= ~DDSCAPS_BACKBUFFER;
lpEnumSurfacesCallback((LPDIRECTDRAWSURFACE7)This->backbuffer, &desc, lpContext);
}
return DD_OK;
}
HRESULT dds_Flip(IDirectDrawSurfaceImpl *This, LPDIRECTDRAWSURFACE surface, DWORD flags)
HRESULT dds_Flip(IDirectDrawSurfaceImpl* This, IDirectDrawSurfaceImpl* lpDDSurfaceTargetOverride, DWORD dwFlags)
{
if (This->backbuffer)
{
EnterCriticalSection(&g_ddraw->cs);
IDirectDrawSurfaceImpl* backbuffer = surface ? (IDirectDrawSurfaceImpl*)surface : This->backbuffer;
IDirectDrawSurfaceImpl* backbuffer = lpDDSurfaceTargetOverride ? lpDDSurfaceTargetOverride : This->backbuffer;
void* buf = InterlockedExchangePointer(&This->surface, backbuffer->surface);
HBITMAP bitmap = (HBITMAP)InterlockedExchangePointer(&This->bitmap, backbuffer->bitmap);
@ -878,7 +891,7 @@ HRESULT dds_Flip(IDirectDrawSurfaceImpl *This, LPDIRECTDRAWSURFACE surface, DWOR
InterlockedExchangePointer(&backbuffer->hdc, dc);
LeaveCriticalSection(&g_ddraw->cs);
if (!surface && This->backbuffer->backbuffer)
if (!lpDDSurfaceTargetOverride && This->backbuffer->backbuffer)
{
dds_Flip(This->backbuffer, NULL, 0);
}
@ -892,7 +905,7 @@ HRESULT dds_Flip(IDirectDrawSurfaceImpl *This, LPDIRECTDRAWSURFACE surface, DWOR
ReleaseSemaphore(g_ddraw->render.sem, 1, NULL);
SwitchToThread();
if ((flags & DDFLIP_WAIT) || g_ddraw->maxgameticks == -2)
if ((dwFlags & DDFLIP_WAIT) || g_ddraw->maxgameticks == -2)
{
dd_WaitForVerticalBlank(DDWAITVB_BLOCKEND, NULL);
}
@ -907,37 +920,37 @@ HRESULT dds_Flip(IDirectDrawSurfaceImpl *This, LPDIRECTDRAWSURFACE surface, DWOR
return DD_OK;
}
HRESULT dds_GetAttachedSurface(IDirectDrawSurfaceImpl *This, LPDDSCAPS lpDdsCaps, LPDIRECTDRAWSURFACE FAR *surface)
HRESULT dds_GetAttachedSurface(IDirectDrawSurfaceImpl* This, LPDDSCAPS2 lpDdsCaps, IDirectDrawSurfaceImpl** lpDDsurface)
{
if ((This->caps & DDSCAPS_PRIMARYSURFACE) && (This->caps & DDSCAPS_FLIP) && (lpDdsCaps->dwCaps & DDSCAPS_BACKBUFFER))
{
if (This->backbuffer)
{
IDirectDrawSurface_AddRef(This->backbuffer);
*surface = (LPDIRECTDRAWSURFACE)This->backbuffer;
*lpDDsurface = This->backbuffer;
}
else
{
IDirectDrawSurface_AddRef(This);
*surface = (LPDIRECTDRAWSURFACE)This;
*lpDDsurface = This;
}
}
return DD_OK;
}
HRESULT dds_GetCaps(IDirectDrawSurfaceImpl *This, LPDDSCAPS lpDDSCaps)
HRESULT dds_GetCaps(IDirectDrawSurfaceImpl* This, LPDDSCAPS2 lpDDSCaps)
{
lpDDSCaps->dwCaps = This->caps;
return DD_OK;
}
HRESULT dds_GetClipper(IDirectDrawSurfaceImpl* This, LPDIRECTDRAWCLIPPER FAR* lpClipper)
HRESULT dds_GetClipper(IDirectDrawSurfaceImpl* This, IDirectDrawClipperImpl** lpClipper)
{
if (!lpClipper)
return DDERR_INVALIDPARAMS;
*lpClipper = (LPDIRECTDRAWCLIPPER)This->clipper;
*lpClipper = This->clipper;
if (This->clipper)
{
@ -950,18 +963,18 @@ HRESULT dds_GetClipper(IDirectDrawSurfaceImpl* This, LPDIRECTDRAWCLIPPER FAR* lp
}
}
HRESULT dds_GetColorKey(IDirectDrawSurfaceImpl *This, DWORD flags, LPDDCOLORKEY colorKey)
HRESULT dds_GetColorKey(IDirectDrawSurfaceImpl* This, DWORD dwFlags, LPDDCOLORKEY lpColorKey)
{
if (colorKey)
if (lpColorKey)
{
colorKey->dwColorSpaceHighValue = This->color_key.dwColorSpaceHighValue;
colorKey->dwColorSpaceLowValue = This->color_key.dwColorSpaceLowValue;
lpColorKey->dwColorSpaceHighValue = This->color_key.dwColorSpaceHighValue;
lpColorKey->dwColorSpaceLowValue = This->color_key.dwColorSpaceLowValue;
}
return DD_OK;
}
HRESULT dds_GetDC(IDirectDrawSurfaceImpl *This, HDC FAR *lpHDC)
HRESULT dds_GetDC(IDirectDrawSurfaceImpl* This, HDC FAR* lpHDC)
{
if (!This)
{
@ -973,10 +986,10 @@ HRESULT dds_GetDC(IDirectDrawSurfaceImpl *This, HDC FAR *lpHDC)
if ((This->l_pitch % 4))
{
dprintf("NOT_IMPLEMENTED GetDC: width=%d height=%d\n", This->width, This->height);
TRACE("NOT_IMPLEMENTED GetDC: width=%d height=%d\n", This->width, This->height);
}
RGBQUAD *data =
RGBQUAD* data =
This->palette ? This->palette->data_rgb :
g_ddraw->primary && g_ddraw->primary->palette ? g_ddraw->primary->palette->data_rgb :
NULL;
@ -995,31 +1008,13 @@ HRESULT dds_GetDC(IDirectDrawSurfaceImpl *This, HDC FAR *lpHDC)
return DD_OK;
}
HRESULT dds_ReleaseDC(IDirectDrawSurfaceImpl* This, HDC hDC)
{
if ((This->caps & DDSCAPS_PRIMARYSURFACE) && g_ddraw->render.run)
{
InterlockedExchange(&g_ddraw->render.surface_updated, TRUE);
DWORD time = timeGetTime();
if (!(This->flags & DDSD_BACKBUFFERCOUNT) ||
(This->last_flip_tick + FLIP_REDRAW_TIMEOUT < time && This->last_blt_tick + FLIP_REDRAW_TIMEOUT < time))
{
ReleaseSemaphore(g_ddraw->render.sem, 1, NULL);
}
}
return DD_OK;
}
HRESULT dds_GetPalette(IDirectDrawSurfaceImpl *This, LPDIRECTDRAWPALETTE FAR *lplpDDPalette)
HRESULT dds_GetPalette(IDirectDrawSurfaceImpl* This, IDirectDrawPaletteImpl** lplpDDPalette)
{
if (!lplpDDPalette)
return DDERR_INVALIDPARAMS;
*lplpDDPalette = (LPDIRECTDRAWPALETTE)This->palette;
*lplpDDPalette = This->palette;
if (This->palette)
{
IDirectDrawPalette_AddRef(This->palette);
@ -1031,7 +1026,7 @@ HRESULT dds_GetPalette(IDirectDrawSurfaceImpl *This, LPDIRECTDRAWPALETTE FAR *lp
}
}
HRESULT dds_GetPixelFormat(IDirectDrawSurfaceImpl *This, LPDDPIXELFORMAT ddpfPixelFormat)
HRESULT dds_GetPixelFormat(IDirectDrawSurfaceImpl* This, LPDDPIXELFORMAT ddpfPixelFormat)
{
if (ddpfPixelFormat)
{
@ -1064,7 +1059,12 @@ HRESULT dds_GetPixelFormat(IDirectDrawSurfaceImpl *This, LPDDPIXELFORMAT ddpfPix
return DDERR_INVALIDPARAMS;
}
HRESULT dds_Lock(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDDSURFACEDESC lpDDSurfaceDesc, DWORD dwFlags, HANDLE hEvent)
HRESULT dds_Lock(
IDirectDrawSurfaceImpl* This,
LPRECT lpDestRect,
LPDDSURFACEDESC2 lpDDSurfaceDesc,
DWORD dwFlags,
HANDLE hEvent)
{
dbg_dump_dds_lock_flags(dwFlags);
@ -1072,9 +1072,9 @@ HRESULT dds_Lock(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDDSURFACEDES
if (lpDestRect && lpDDSurfaceDesc)
{
if (lpDestRect->left < 0 ||
lpDestRect->top < 0 ||
lpDestRect->left > lpDestRect->right ||
if (lpDestRect->left < 0 ||
lpDestRect->top < 0 ||
lpDestRect->left > lpDestRect->right ||
lpDestRect->top > lpDestRect->bottom ||
lpDestRect->right > This->width ||
lpDestRect->bottom > This->height)
@ -1082,28 +1082,32 @@ HRESULT dds_Lock(IDirectDrawSurfaceImpl *This, LPRECT lpDestRect, LPDDSURFACEDES
return DDERR_INVALIDPARAMS;
}
lpDDSurfaceDesc->lpSurface =
lpDDSurfaceDesc->lpSurface =
(char*)dds_GetBuffer(This) + (lpDestRect->left * This->lx_pitch) + (lpDestRect->top * This->l_pitch);
}
return ret;
}
HRESULT dds_SetColorKey(IDirectDrawSurfaceImpl *This, DWORD flags, LPDDCOLORKEY colorKey)
HRESULT dds_ReleaseDC(IDirectDrawSurfaceImpl* This, HDC hDC)
{
if (colorKey)
if ((This->caps & DDSCAPS_PRIMARYSURFACE) && g_ddraw->render.run)
{
dprintfex(" dwColorSpaceHighValue=%d\n", colorKey->dwColorSpaceHighValue);
dprintfex(" dwColorSpaceLowValue=%d\n", colorKey->dwColorSpaceLowValue);
InterlockedExchange(&g_ddraw->render.surface_updated, TRUE);
This->color_key.dwColorSpaceHighValue = colorKey->dwColorSpaceHighValue;
This->color_key.dwColorSpaceLowValue = colorKey->dwColorSpaceLowValue;
DWORD time = timeGetTime();
if (!(This->flags & DDSD_BACKBUFFERCOUNT) ||
(This->last_flip_tick + FLIP_REDRAW_TIMEOUT < time && This->last_blt_tick + FLIP_REDRAW_TIMEOUT < time))
{
ReleaseSemaphore(g_ddraw->render.sem, 1, NULL);
}
}
return DD_OK;
}
HRESULT dds_SetClipper(IDirectDrawSurfaceImpl* This, LPDIRECTDRAWCLIPPER lpClipper)
HRESULT dds_SetClipper(IDirectDrawSurfaceImpl* This, IDirectDrawClipperImpl* lpClipper)
{
if (lpClipper)
IDirectDrawClipper_AddRef(lpClipper);
@ -1111,12 +1115,26 @@ HRESULT dds_SetClipper(IDirectDrawSurfaceImpl* This, LPDIRECTDRAWCLIPPER lpClipp
if (This->clipper)
IDirectDrawClipper_Release(This->clipper);
This->clipper = (IDirectDrawClipperImpl*)lpClipper;
This->clipper = lpClipper;
return DD_OK;
}
HRESULT dds_SetPalette(IDirectDrawSurfaceImpl *This, LPDIRECTDRAWPALETTE lpDDPalette)
HRESULT dds_SetColorKey(IDirectDrawSurfaceImpl* This, DWORD dwFlags, LPDDCOLORKEY lpColorKey)
{
if (lpColorKey)
{
TRACE_EXT(" dwColorSpaceHighValue=%d\n", lpColorKey->dwColorSpaceHighValue);
TRACE_EXT(" dwColorSpaceLowValue=%d\n", lpColorKey->dwColorSpaceLowValue);
This->color_key.dwColorSpaceHighValue = lpColorKey->dwColorSpaceHighValue;
This->color_key.dwColorSpaceLowValue = lpColorKey->dwColorSpaceLowValue;
}
return DD_OK;
}
HRESULT dds_SetPalette(IDirectDrawSurfaceImpl* This, IDirectDrawPaletteImpl* lpDDPalette)
{
if (lpDDPalette)
IDirectDrawPalette_AddRef(lpDDPalette);
@ -1127,7 +1145,7 @@ HRESULT dds_SetPalette(IDirectDrawSurfaceImpl *This, LPDIRECTDRAWPALETTE lpDDPal
if (This->caps & DDSCAPS_PRIMARYSURFACE)
{
EnterCriticalSection(&g_ddraw->cs);
This->palette = (IDirectDrawPaletteImpl*)lpDDPalette;
This->palette = lpDDPalette;
LeaveCriticalSection(&g_ddraw->cs);
if (g_ddraw->render.run)
@ -1138,14 +1156,15 @@ HRESULT dds_SetPalette(IDirectDrawSurfaceImpl *This, LPDIRECTDRAWPALETTE lpDDPal
}
else
{
This->palette = (IDirectDrawPaletteImpl*)lpDDPalette;
This->palette = lpDDPalette;
}
return DD_OK;
}
HRESULT dds_Unlock(IDirectDrawSurfaceImpl *This, LPVOID lpRect)
HRESULT dds_Unlock(IDirectDrawSurfaceImpl* This, LPVOID lpRect)
{
/* Hack for Warcraft II BNE and Diablo */
HWND hwnd = g_ddraw->bnet_active ? FindWindowEx(HWND_DESKTOP, NULL, "SDlgDialog", NULL) : NULL;
if (hwnd && (This->caps & DDSCAPS_PRIMARYSURFACE))
@ -1153,7 +1172,7 @@ HRESULT dds_Unlock(IDirectDrawSurfaceImpl *This, LPVOID lpRect)
HDC primary_dc;
dds_GetDC(g_ddraw->primary, &primary_dc);
//GdiTransparentBlt idea taken from Aqrit's war2 ddraw
/* GdiTransparentBlt idea taken from Aqrit's war2 ddraw */
RGBQUAD quad;
GetDIBColorTable(primary_dc, 0xFE, 1, &quad);
@ -1200,7 +1219,7 @@ HRESULT dds_Unlock(IDirectDrawSurfaceImpl *This, LPVOID lpRect)
}
}
/* Hack for Star Trek Armada */
hwnd = g_ddraw->armadahack ? FindWindowEx(HWND_DESKTOP, NULL, "#32770", NULL) : NULL;
if (hwnd && (This->caps & DDSCAPS_PRIMARYSURFACE))
@ -1280,25 +1299,30 @@ void* dds_GetBuffer(IDirectDrawSurfaceImpl* This)
return This->surface;
}
HRESULT dd_CreateSurface(IDirectDrawImpl* This, LPDDSURFACEDESC lpDDSurfaceDesc, LPDIRECTDRAWSURFACE FAR *lpDDSurface, IUnknown FAR * unkOuter)
HRESULT dd_CreateSurface(
IDirectDrawImpl* This,
LPDDSURFACEDESC2 lpDDSurfaceDesc,
IDirectDrawSurfaceImpl** lpDDSurface,
IUnknown FAR* unkOuter)
{
dbg_dump_dds_flags(lpDDSurfaceDesc->dwFlags);
dbg_dump_dds_caps(lpDDSurfaceDesc->ddsCaps.dwCaps);
if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) &&
if ((lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) &&
!g_ddraw->passthrough &&
g_ddraw->primary &&
g_ddraw->primary &&
g_ddraw->primary->width == g_ddraw->width &&
g_ddraw->primary->height == g_ddraw->height &&
g_ddraw->primary->bpp == g_ddraw->bpp)
{
*lpDDSurface = (LPDIRECTDRAWSURFACE)g_ddraw->primary;
*lpDDSurface = g_ddraw->primary;
IDirectDrawSurface_AddRef(g_ddraw->primary);
return DD_OK;
}
IDirectDrawSurfaceImpl *dst_surface = (IDirectDrawSurfaceImpl *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawSurfaceImpl));
IDirectDrawSurfaceImpl* dst_surface =
(IDirectDrawSurfaceImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawSurfaceImpl));
dst_surface->lpVtbl = &g_dds_vtbl;
@ -1317,17 +1341,17 @@ HRESULT dd_CreateSurface(IDirectDrawImpl* This, LPDDSURFACEDESC lpDDSurfaceDesc,
dst_surface->bpp = 8;
break;
case 15:
dprintf(" NOT_IMPLEMENTED bpp=%u\n", lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount);
TRACE(" NOT_IMPLEMENTED bpp=%u\n", lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount);
case 16:
dst_surface->bpp = 16;
break;
case 24:
dprintf(" NOT_IMPLEMENTED bpp=%u\n", lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount);
TRACE(" NOT_IMPLEMENTED bpp=%u\n", lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount);
case 32:
dst_surface->bpp = 32;
break;
default:
dprintf(" NOT_IMPLEMENTED bpp=%u\n", lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount);
TRACE(" NOT_IMPLEMENTED bpp=%u\n", lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount);
break;
}
}
@ -1356,9 +1380,11 @@ HRESULT dd_CreateSurface(IDirectDrawImpl* This, LPDDSURFACEDESC lpDDSurfaceDesc,
{
dst_surface->l_pitch = ++dst_surface->width * dst_surface->lx_pitch;
}
}
}
dst_surface->bmi =
HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256);
dst_surface->bmi = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256);
dst_surface->bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
dst_surface->bmi->bmiHeader.biWidth = dst_surface->width;
dst_surface->bmi->bmiHeader.biHeight = -((int)dst_surface->height + 200);
@ -1373,7 +1399,8 @@ HRESULT dd_CreateSurface(IDirectDrawImpl* This, LPDDSURFACEDESC lpDDSurfaceDesc,
dst_surface->bmi->bmiHeader.biClrUsed = (1 << clr_bits);
}
dst_surface->bmi->bmiHeader.biSizeImage = ((dst_surface->width * clr_bits + 31) & ~31) / 8 * dst_surface->height;
dst_surface->bmi->bmiHeader.biSizeImage =
((dst_surface->width * clr_bits + 31) & ~31) / 8 * dst_surface->height;
if (dst_surface->bpp == 8)
{
@ -1399,15 +1426,17 @@ HRESULT dd_CreateSurface(IDirectDrawImpl* This, LPDDSURFACEDESC lpDDSurfaceDesc,
}
dst_surface->hdc = CreateCompatibleDC(g_ddraw->render.hdc);
dst_surface->bitmap = CreateDIBSection(dst_surface->hdc, dst_surface->bmi, DIB_RGB_COLORS, (void **)&dst_surface->surface, NULL, 0);
dst_surface->bitmap =
CreateDIBSection(dst_surface->hdc, dst_surface->bmi, DIB_RGB_COLORS, (void**)&dst_surface->surface, NULL, 0);
dst_surface->bmi->bmiHeader.biHeight = -((int)dst_surface->height);
if (!dst_surface->bitmap)
{
dst_surface->surface =
dst_surface->surface =
HeapAlloc(
GetProcessHeap(),
HEAP_ZERO_MEMORY,
GetProcessHeap(),
HEAP_ZERO_MEMORY,
dst_surface->l_pitch * (dst_surface->height + 200) * dst_surface->lx_pitch);
}
@ -1422,34 +1451,36 @@ HRESULT dd_CreateSurface(IDirectDrawImpl* This, LPDDSURFACEDESC lpDDSurfaceDesc,
if (dst_surface->flags & DDSD_BACKBUFFERCOUNT)
{
dprintf(" dwBackBufferCount=%d\n", lpDDSurfaceDesc->dwBackBufferCount);
TRACE(" dwBackBufferCount=%d\n", lpDDSurfaceDesc->dwBackBufferCount);
if (g_ddraw->backbuffer)
DDSURFACEDESC2 desc;
memset(&desc, 0, sizeof(desc));
if (lpDDSurfaceDesc->dwBackBufferCount > 1)
{
DDSURFACEDESC desc;
memset(&desc, 0, sizeof(DDSURFACEDESC));
if (lpDDSurfaceDesc->dwBackBufferCount > 1)
{
desc.dwBackBufferCount = lpDDSurfaceDesc->dwBackBufferCount - 1;
desc.dwFlags |= DDSD_BACKBUFFERCOUNT;
}
desc.ddsCaps.dwCaps |= DDSCAPS_BACKBUFFER;
desc.dwWidth = dst_surface->width;
desc.dwHeight = dst_surface->height;
dd_CreateSurface(This, &desc, (LPDIRECTDRAWSURFACE*)&dst_surface->backbuffer, unkOuter);
desc.dwBackBufferCount = lpDDSurfaceDesc->dwBackBufferCount - 1;
desc.dwFlags |= DDSD_BACKBUFFERCOUNT;
}
desc.ddsCaps.dwCaps |= DDSCAPS_BACKBUFFER;
desc.dwWidth = dst_surface->width;
desc.dwHeight = dst_surface->height;
dd_CreateSurface(This, &desc, &dst_surface->backbuffer, unkOuter);
}
dprintf(" surface = %p (%dx%d@%d)\n", dst_surface, (int)dst_surface->width, (int)dst_surface->height, (int)dst_surface->bpp);
TRACE(
" surface = %p (%ux%u@%u)\n",
dst_surface,
dst_surface->width,
dst_surface->height,
dst_surface->bpp);
*lpDDSurface = (LPDIRECTDRAWSURFACE)dst_surface;
*lpDDSurface = dst_surface;
dst_surface->ref = 0;
IDirectDrawSurface_AddRef(dst_surface);
return DD_OK;
}

401
src/debug.c
View file

@ -1,8 +1,8 @@
#include <windows.h>
#include <dbghelp.h>
#include <stdio.h>
#include <ddraw.h>
#include "dd.h"
#include "ddraw.h"
#include "ddsurface.h"
#include "debug.h"
@ -76,7 +76,7 @@ void dbg_init()
dbg_printf("%s (%s)\n", name, build);
const char* (CDECL * wine_get_version)() =
const char* (CDECL * wine_get_version)() =
(void*)GetProcAddress(GetModuleHandleA("ntdll.dll"), "wine_get_version");
if (wine_get_version)
@ -101,7 +101,7 @@ double dbg_counter_stop()
return (double)(li.QuadPart - g_dbg_counter_start_time) / g_dbg_counter_freq;
}
void dbg_debug_string(const char *format, ...)
void dbg_debug_string(const char* format, ...)
{
va_list args;
va_start(args, format);
@ -110,7 +110,7 @@ void dbg_debug_string(const char *format, ...)
OutputDebugStringA(buffer);
}
int dbg_printf(const char *fmt, ...)
int dbg_printf(const char* fmt, ...)
{
static CRITICAL_SECTION cs;
static BOOL initialized;
@ -122,14 +122,21 @@ int dbg_printf(const char *fmt, ...)
}
EnterCriticalSection(&cs);
va_list args;
int ret;
SYSTEMTIME st;
GetLocalTime(&st);
fprintf(stdout, "[%lu] %02d:%02d:%02d.%03d ", GetCurrentThreadId(), st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
fprintf(
stdout,
"[%lu] %02d:%02d:%02d.%03d ",
GetCurrentThreadId(),
st.wHour,
st.wMinute,
st.wSecond,
st.wMilliseconds);
va_start(args, fmt);
ret = vfprintf(stdout, fmt, args);
@ -156,13 +163,13 @@ void dbg_draw_frame_info_start()
DrawText(primary_dc, debug_text, -1, &debugrc, DT_NOCLIP);
}
DWORD tick_start = timeGetTime();
if (tick_start >= tick_fps)
{
_snprintf(
debug_text,
sizeof(debug_text)-1,
sizeof(debug_text) - 1,
"FPS: %lu | Time: %2.2f ms ",
g_dbg_frame_count,
g_dbg_frame_time);
@ -178,7 +185,7 @@ void dbg_draw_frame_info_start()
void dbg_draw_frame_info_end()
{
if (g_dbg_frame_count == 1)
if (g_dbg_frame_count == 1)
g_dbg_frame_time = dbg_counter_stop();
}
@ -186,82 +193,130 @@ void dbg_dump_dds_blt_flags(DWORD flags)
{
#ifdef _DEBUG_X
if (flags & DDBLT_ALPHADEST) {
dprintf(" DDBLT_ALPHADEST\n");
TRACE(" DDBLT_ALPHADEST\n");
}
if (flags & DDBLT_ALPHADESTCONSTOVERRIDE) {
dprintf(" DDBLT_ALPHADESTCONSTOVERRIDE\n");
TRACE(" DDBLT_ALPHADESTCONSTOVERRIDE\n");
}
if (flags & DDBLT_ALPHADESTNEG) {
dprintf(" DDBLT_ALPHADESTNEG\n");
TRACE(" DDBLT_ALPHADESTNEG\n");
}
if (flags & DDBLT_ALPHADESTSURFACEOVERRIDE) {
dprintf(" DDBLT_ALPHADESTSURFACEOVERRIDE\n");
TRACE(" DDBLT_ALPHADESTSURFACEOVERRIDE\n");
}
if (flags & DDBLT_ALPHAEDGEBLEND) {
dprintf(" DDBLT_ALPHAEDGEBLEND\n");
TRACE(" DDBLT_ALPHAEDGEBLEND\n");
}
if (flags & DDBLT_ALPHASRC) {
dprintf(" DDBLT_ALPHASRC\n");
TRACE(" DDBLT_ALPHASRC\n");
}
if (flags & DDBLT_ALPHASRCCONSTOVERRIDE) {
dprintf(" DDBLT_ALPHASRCCONSTOVERRIDE\n");
TRACE(" DDBLT_ALPHASRCCONSTOVERRIDE\n");
}
if (flags & DDBLT_ALPHASRCNEG) {
dprintf(" DDBLT_ALPHASRCNEG\n");
TRACE(" DDBLT_ALPHASRCNEG\n");
}
if (flags & DDBLT_ALPHASRCSURFACEOVERRIDE) {
dprintf(" DDBLT_ALPHASRCSURFACEOVERRIDE\n");
TRACE(" DDBLT_ALPHASRCSURFACEOVERRIDE\n");
}
if (flags & DDBLT_ASYNC) {
dprintf(" DDBLT_ASYNC\n");
TRACE(" DDBLT_ASYNC\n");
}
if (flags & DDBLT_COLORFILL) {
dprintf(" DDBLT_COLORFILL\n");
TRACE(" DDBLT_COLORFILL\n");
}
if (flags & DDBLT_DDFX) {
dprintf(" DDBLT_DDFX\n");
TRACE(" DDBLT_DDFX\n");
}
if (flags & DDBLT_DDROPS) {
dprintf(" DDBLT_DDROPS\n");
TRACE(" DDBLT_DDROPS\n");
}
if (flags & DDBLT_KEYDEST) {
dprintf(" DDBLT_KEYDEST\n");
TRACE(" DDBLT_KEYDEST\n");
}
if (flags & DDBLT_KEYDESTOVERRIDE) {
dprintf(" DDBLT_KEYDESTOVERRIDE\n");
TRACE(" DDBLT_KEYDESTOVERRIDE\n");
}
if (flags & DDBLT_KEYSRC) {
dprintf(" DDBLT_KEYSRC\n");
TRACE(" DDBLT_KEYSRC\n");
}
if (flags & DDBLT_KEYSRCOVERRIDE) {
dprintf(" DDBLT_KEYSRCOVERRIDE\n");
TRACE(" DDBLT_KEYSRCOVERRIDE\n");
}
if (flags & DDBLT_ROP) {
dprintf(" DDBLT_ROP\n");
TRACE(" DDBLT_ROP\n");
}
if (flags & DDBLT_ROTATIONANGLE) {
dprintf(" DDBLT_ROTATIONANGLE\n");
TRACE(" DDBLT_ROTATIONANGLE\n");
}
if (flags & DDBLT_ZBUFFER) {
dprintf(" DDBLT_ZBUFFER\n");
TRACE(" DDBLT_ZBUFFER\n");
}
if (flags & DDBLT_ZBUFFERDESTCONSTOVERRIDE) {
dprintf(" DDBLT_ZBUFFERDESTCONSTOVERRIDE\n");
TRACE(" DDBLT_ZBUFFERDESTCONSTOVERRIDE\n");
}
if (flags & DDBLT_ZBUFFERDESTOVERRIDE) {
dprintf(" DDBLT_ZBUFFERDESTOVERRIDE\n");
TRACE(" DDBLT_ZBUFFERDESTOVERRIDE\n");
}
if (flags & DDBLT_ZBUFFERSRCCONSTOVERRIDE) {
dprintf(" DDBLT_ZBUFFERSRCCONSTOVERRIDE\n");
TRACE(" DDBLT_ZBUFFERSRCCONSTOVERRIDE\n");
}
if (flags & DDBLT_ZBUFFERSRCOVERRIDE) {
dprintf(" DDBLT_ZBUFFERSRCOVERRIDE\n");
TRACE(" DDBLT_ZBUFFERSRCOVERRIDE\n");
}
if (flags & DDBLT_WAIT) {
dprintf(" DDBLT_WAIT\n");
TRACE(" DDBLT_WAIT\n");
}
if (flags & DDBLT_DEPTHFILL) {
dprintf(" DDBLT_DEPTHFILL\n");
TRACE(" DDBLT_DEPTHFILL\n");
}
if (flags & DDBLT_DONOTWAIT) {
TRACE(" DDBLT_DONOTWAIT\n");
}
if (flags & DDBLT_PRESENTATION) {
TRACE(" DDBLT_PRESENTATION\n");
}
if (flags & DDBLT_LAST_PRESENTATION) {
TRACE(" DDBLT_LAST_PRESENTATION\n");
}
if (flags & DDBLT_EXTENDED_FLAGS) {
TRACE(" DDBLT_EXTENDED_FLAGS\n");
}
if (flags & DDBLT_EXTENDED_LINEAR_CONTENT) {
TRACE(" DDBLT_EXTENDED_LINEAR_CONTENT\n");
}
#endif
}
void dbg_dump_dds_blt_fx_flags(DWORD flags)
{
#ifdef _DEBUG_X
if (flags & DDBLTFX_ARITHSTRETCHY) {
TRACE(" DDBLTFX_ARITHSTRETCHY\n");
}
if (flags & DDBLTFX_MIRRORLEFTRIGHT) {
TRACE(" DDBLTFX_MIRRORLEFTRIGHT\n");
}
if (flags & DDBLTFX_MIRRORUPDOWN) {
TRACE(" DDBLTFX_MIRRORUPDOWN\n");
}
if (flags & DDBLTFX_NOTEARING) {
TRACE(" DDBLTFX_NOTEARING\n");
}
if (flags & DDBLTFX_ROTATE180) {
TRACE(" DDBLTFX_ROTATE180\n");
}
if (flags & DDBLTFX_ROTATE270) {
TRACE(" DDBLTFX_ROTATE270\n");
}
if (flags & DDBLTFX_ROTATE90) {
TRACE(" DDBLTFX_ROTATE90\n");
}
if (flags & DDBLTFX_ZBUFFERRANGE) {
TRACE(" DDBLTFX_ZBUFFERRANGE\n");
}
if (flags & DDBLTFX_ZBUFFERBASEDEST) {
TRACE(" DDBLTFX_ZBUFFERBASEDEST\n");
}
#endif
}
@ -269,45 +324,95 @@ void dbg_dump_dds_blt_flags(DWORD flags)
void dbg_dump_dds_caps(DWORD caps)
{
#ifdef _DEBUG_X
if (caps & DDSCAPS_ALPHA)
{
dprintf(" DDSCAPS_ALPHA\n");
if (caps & DDSCAPS_RESERVED1) {
TRACE(" DDSCAPS_RESERVED1\n");
}
if (caps & DDSCAPS_BACKBUFFER)
{
dprintf(" DDSCAPS_BACKBUFFER\n");
if (caps & DDSCAPS_ALPHA) {
TRACE(" DDSCAPS_ALPHA\n");
}
if (caps & DDSCAPS_FLIP)
{
dprintf(" DDSCAPS_FLIP\n");
if (caps & DDSCAPS_BACKBUFFER) {
TRACE(" DDSCAPS_BACKBUFFER\n");
}
if (caps & DDSCAPS_FRONTBUFFER)
{
dprintf(" DDSCAPS_FRONTBUFFER\n");
if (caps & DDSCAPS_COMPLEX) {
TRACE(" DDSCAPS_COMPLEX\n");
}
if (caps & DDSCAPS_PALETTE)
{
dprintf(" DDSCAPS_PALETTE\n");
if (caps & DDSCAPS_FLIP) {
TRACE(" DDSCAPS_FLIP\n");
}
if (caps & DDSCAPS_TEXTURE)
{
dprintf(" DDSCAPS_TEXTURE\n");
if (caps & DDSCAPS_FRONTBUFFER) {
TRACE(" DDSCAPS_FRONTBUFFER\n");
}
if (caps & DDSCAPS_PRIMARYSURFACE)
{
dprintf(" DDSCAPS_PRIMARYSURFACE\n");
if (caps & DDSCAPS_OFFSCREENPLAIN) {
TRACE(" DDSCAPS_OFFSCREENPLAIN\n");
}
if (caps & DDSCAPS_OFFSCREENPLAIN)
{
dprintf(" DDSCAPS_OFFSCREENPLAIN\n");
if (caps & DDSCAPS_OVERLAY) {
TRACE(" DDSCAPS_OVERLAY\n");
}
if (caps & DDSCAPS_VIDEOMEMORY)
{
dprintf(" DDSCAPS_VIDEOMEMORY\n");
if (caps & DDSCAPS_PALETTE) {
TRACE(" DDSCAPS_PALETTE\n");
}
if (caps & DDSCAPS_LOCALVIDMEM)
{
dprintf(" DDSCAPS_LOCALVIDMEM\n");
if (caps & DDSCAPS_PRIMARYSURFACE) {
TRACE(" DDSCAPS_PRIMARYSURFACE\n");
}
if (caps & DDSCAPS_RESERVED3) {
TRACE(" DDSCAPS_RESERVED3\n");
}
if (caps & DDSCAPS_PRIMARYSURFACELEFT) {
TRACE(" DDSCAPS_PRIMARYSURFACELEFT\n");
}
if (caps & DDSCAPS_SYSTEMMEMORY) {
TRACE(" DDSCAPS_SYSTEMMEMORY\n");
}
if (caps & DDSCAPS_TEXTURE) {
TRACE(" DDSCAPS_TEXTURE\n");
}
if (caps & DDSCAPS_3DDEVICE) {
TRACE(" DDSCAPS_3DDEVICE\n");
}
if (caps & DDSCAPS_VIDEOMEMORY) {
TRACE(" DDSCAPS_VIDEOMEMORY\n");
}
if (caps & DDSCAPS_VISIBLE) {
TRACE(" DDSCAPS_VISIBLE\n");
}
if (caps & DDSCAPS_ZBUFFER) {
TRACE(" DDSCAPS_ZBUFFER\n");
}
if (caps & DDSCAPS_OWNDC) {
TRACE(" DDSCAPS_OWNDC\n");
}
if (caps & DDSCAPS_LIVEVIDEO) {
TRACE(" DDSCAPS_LIVEVIDEO\n");
}
if (caps & DDSCAPS_HWCODEC) {
TRACE(" DDSCAPS_HWCODEC\n");
}
if (caps & DDSCAPS_MODEX) {
TRACE(" DDSCAPS_MODEX\n");
}
if (caps & DDSCAPS_MIPMAP) {
TRACE(" DDSCAPS_MIPMAP\n");
}
if (caps & DDSCAPS_RESERVED2) {
TRACE(" DDSCAPS_RESERVED2\n");
}
if (caps & DDSCAPS_ALLOCONLOAD) {
TRACE(" DDSCAPS_ALLOCONLOAD\n");
}
if (caps & DDSCAPS_VIDEOPORT) {
TRACE(" DDSCAPS_VIDEOPORT\n");
}
if (caps & DDSCAPS_LOCALVIDMEM) {
TRACE(" DDSCAPS_LOCALVIDMEM\n");
}
if (caps & DDSCAPS_NONLOCALVIDMEM) {
TRACE(" DDSCAPS_NONLOCALVIDMEM\n");
}
if (caps & DDSCAPS_STANDARDVGAMODE) {
TRACE(" DDSCAPS_STANDARDVGAMODE\n");
}
if (caps & DDSCAPS_OPTIMIZED) {
TRACE(" DDSCAPS_OPTIMIZED\n");
}
#endif
}
@ -315,73 +420,68 @@ void dbg_dump_dds_caps(DWORD caps)
void dbg_dump_dds_flags(DWORD flags)
{
#ifdef _DEBUG_X
if (flags & DDSD_CAPS)
{
dprintf(" DDSD_CAPS\n");
if (flags & DDSD_CAPS) {
TRACE(" DDSD_CAPS\n");
}
if (flags & DDSD_HEIGHT)
{
dprintf(" DDSD_HEIGHT\n");
if (flags & DDSD_HEIGHT) {
TRACE(" DDSD_HEIGHT\n");
}
if (flags & DDSD_WIDTH)
{
dprintf(" DDSD_WIDTH\n");
if (flags & DDSD_WIDTH) {
TRACE(" DDSD_WIDTH\n");
}
if (flags & DDSD_PITCH)
{
dprintf(" DDSD_PITCH\n");
if (flags & DDSD_PITCH) {
TRACE(" DDSD_PITCH\n");
}
if (flags & DDSD_BACKBUFFERCOUNT)
{
dprintf(" DDSD_BACKBUFFERCOUNT\n");
if (flags & DDSD_BACKBUFFERCOUNT) {
TRACE(" DDSD_BACKBUFFERCOUNT\n");
}
if (flags & DDSD_ZBUFFERBITDEPTH)
{
dprintf(" DDSD_ZBUFFERBITDEPTH\n");
if (flags & DDSD_ZBUFFERBITDEPTH) {
TRACE(" DDSD_ZBUFFERBITDEPTH\n");
}
if (flags & DDSD_ALPHABITDEPTH)
{
dprintf(" DDSD_ALPHABITDEPTH\n");
if (flags & DDSD_ALPHABITDEPTH) {
TRACE(" DDSD_ALPHABITDEPTH\n");
}
if (flags & DDSD_LPSURFACE)
{
dprintf(" DDSD_LPSURFACE\n");
if (flags & DDSD_LPSURFACE) {
TRACE(" DDSD_LPSURFACE\n");
}
if (flags & DDSD_PIXELFORMAT)
{
dprintf(" DDSD_PIXELFORMAT\n");
if (flags & DDSD_PIXELFORMAT) {
TRACE(" DDSD_PIXELFORMAT\n");
}
if (flags & DDSD_CKDESTOVERLAY)
{
dprintf(" DDSD_CKDESTOVERLAY\n");
if (flags & DDSD_CKDESTOVERLAY) {
TRACE(" DDSD_CKDESTOVERLAY\n");
}
if (flags & DDSD_CKDESTBLT)
{
dprintf(" DDSD_CKDESTBLT\n");
if (flags & DDSD_CKDESTBLT) {
TRACE(" DDSD_CKDESTBLT\n");
}
if (flags & DDSD_CKSRCOVERLAY)
{
dprintf(" DDSD_CKSRCOVERLAY\n");
if (flags & DDSD_CKSRCOVERLAY) {
TRACE(" DDSD_CKSRCOVERLAY\n");
}
if (flags & DDSD_CKSRCBLT)
{
dprintf(" DDSD_CKSRCBLT\n");
if (flags & DDSD_CKSRCBLT) {
TRACE(" DDSD_CKSRCBLT\n");
}
if (flags & DDSD_MIPMAPCOUNT)
{
dprintf(" DDSD_MIPMAPCOUNT\n");
if (flags & DDSD_MIPMAPCOUNT) {
TRACE(" DDSD_MIPMAPCOUNT\n");
}
if (flags & DDSD_REFRESHRATE)
{
dprintf(" DDSD_REFRESHRATE\n");
if (flags & DDSD_REFRESHRATE) {
TRACE(" DDSD_REFRESHRATE\n");
}
if (flags & DDSD_LINEARSIZE)
{
dprintf(" DDSD_LINEARSIZE\n");
if (flags & DDSD_LINEARSIZE) {
TRACE(" DDSD_LINEARSIZE\n");
}
if (flags & DDSD_ALL)
{
dprintf(" DDSD_ALL\n");
if (flags & DDSD_TEXTURESTAGE) {
TRACE(" DDSD_TEXTURESTAGE\n");
}
if (flags & DDSD_FVF) {
TRACE(" DDSD_FVF\n");
}
if (flags & DDSD_SRCVBHANDLE) {
TRACE(" DDSD_SRCVBHANDLE\n");
}
if (flags & DDSD_DEPTH) {
TRACE(" DDSD_DEPTH\n");
}
if (flags & DDSD_ALL) {
TRACE(" DDSD_ALL\n");
}
#endif
}
@ -389,19 +489,20 @@ void dbg_dump_dds_flags(DWORD flags)
void dbg_dump_dds_blt_fast_flags(DWORD flags)
{
#ifdef _DEBUG_X
if (flags & DDBLTFAST_NOCOLORKEY)
{
dprintf(" DDBLTFAST_NOCOLORKEY\n");
if (flags & DDBLTFAST_NOCOLORKEY) {
TRACE(" DDBLTFAST_NOCOLORKEY\n");
}
if (flags & DDBLTFAST_SRCCOLORKEY)
{
dprintf(" DDBLTFAST_SRCCOLORKEY\n");
if (flags & DDBLTFAST_SRCCOLORKEY) {
TRACE(" DDBLTFAST_SRCCOLORKEY\n");
}
if (flags & DDBLTFAST_DESTCOLORKEY)
{
dprintf(" DDBLTFAST_DESTCOLORKEY\n");
if (flags & DDBLTFAST_DESTCOLORKEY) {
TRACE(" DDBLTFAST_DESTCOLORKEY\n");
}
if (flags & DDBLTFAST_WAIT) {
TRACE(" DDBLTFAST_WAIT\n");
}
if (flags & DDBLTFAST_DONOTWAIT) {
TRACE(" DDBLTFAST_DONOTWAIT\n");
}
#endif
}
@ -409,25 +510,41 @@ void dbg_dump_dds_blt_fast_flags(DWORD flags)
void dbg_dump_dds_lock_flags(DWORD flags)
{
#ifdef _DEBUG_X
if (flags & DDLOCK_SURFACEMEMORYPTR)
{
dprintf(" dwFlags: DDLOCK_SURFACEMEMORYPTR\n");
if (flags & DDLOCK_SURFACEMEMORYPTR) {
TRACE(" DDLOCK_SURFACEMEMORYPTR\n");
}
if (flags & DDLOCK_WAIT)
{
dprintf(" dwFlags: DDLOCK_WAIT\n");
if (flags & DDLOCK_WAIT) {
TRACE(" DDLOCK_WAIT\n");
}
if (flags & DDLOCK_EVENT)
{
dprintf(" dwFlags: DDLOCK_EVENT\n");
if (flags & DDLOCK_EVENT) {
TRACE(" DDLOCK_EVENT\n");
}
if (flags & DDLOCK_READONLY)
{
dprintf(" dwFlags: DDLOCK_READONLY\n");
if (flags & DDLOCK_READONLY) {
TRACE(" DDLOCK_READONLY\n");
}
if (flags & DDLOCK_WRITEONLY)
{
dprintf(" dwFlags: DDLOCK_WRITEONLY\n");
if (flags & DDLOCK_WRITEONLY) {
TRACE(" DDLOCK_WRITEONLY\n");
}
if (flags & DDLOCK_NOSYSLOCK) {
TRACE(" DDLOCK_NOSYSLOCK\n");
}
if (flags & DDLOCK_NOOVERWRITE) {
TRACE(" DDLOCK_NOOVERWRITE\n");
}
if (flags & DDLOCK_DISCARDCONTENTS) {
TRACE(" DDLOCK_DISCARDCONTENTS\n");
}
if (flags & DDLOCK_OKTOSWAP) {
TRACE(" DDLOCK_OKTOSWAP\n");
}
if (flags & DDLOCK_DONOTWAIT) {
TRACE(" DDLOCK_DONOTWAIT\n");
}
if (flags & DDLOCK_HASVOLUMETEXTUREBOXRECT) {
TRACE(" DDLOCK_HASVOLUMETEXTUREBOXRECT\n");
}
if (flags & DDLOCK_NODIRTYUPDATE) {
TRACE(" DDLOCK_NODIRTYUPDATE\n");
}
#endif
}

76
src/directinput.c
View file

@ -17,7 +17,7 @@ static DICREATEDEVICEEXPROC real_di_CreateDeviceEx;
static DIDSETCOOPERATIVELEVELPROC real_did_SetCooperativeLevel;
static DIDGETDEVICEDATAPROC real_did_GetDeviceData;
static PROC hook_func(PROC *org_func, PROC new_func)
static PROC hook_func(PROC* org_func, PROC new_func)
{
PROC org = *org_func;
DWORD old_protect;
@ -33,16 +33,21 @@ static PROC hook_func(PROC *org_func, PROC new_func)
return 0;
}
static HRESULT WINAPI fake_did_SetCooperativeLevel(IDirectInputDeviceA *This, HWND hwnd, DWORD dwFlags)
static HRESULT WINAPI fake_did_SetCooperativeLevel(IDirectInputDeviceA* This, HWND hwnd, DWORD dwFlags)
{
dprintf("DirectInput SetCooperativeLevel\n");
TRACE("DirectInput SetCooperativeLevel\n");
return real_did_SetCooperativeLevel(This, hwnd, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE);
}
static HRESULT WINAPI fake_did_GetDeviceData(IDirectInputDeviceA *This, DWORD cbObjectData, LPDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD dwFlags)
static HRESULT WINAPI fake_did_GetDeviceData(
IDirectInputDeviceA* This,
DWORD cbObjectData,
LPDIDEVICEOBJECTDATA rgdod,
LPDWORD pdwInOut,
DWORD dwFlags)
{
//dprintf("DirectInput GetDeviceData\n");
//TRACE("DirectInput GetDeviceData\n");
HRESULT result = real_did_GetDeviceData(This, cbObjectData, rgdod, pdwInOut, dwFlags);
@ -54,9 +59,13 @@ static HRESULT WINAPI fake_did_GetDeviceData(IDirectInputDeviceA *This, DWORD cb
return result;
}
static HRESULT WINAPI fake_di_CreateDevice(IDirectInputA *This, REFGUID rguid, LPDIRECTINPUTDEVICEA * lplpDIDevice, LPUNKNOWN pUnkOuter)
static HRESULT WINAPI fake_di_CreateDevice(
IDirectInputA* This,
REFGUID rguid,
LPDIRECTINPUTDEVICEA* lplpDIDevice,
LPUNKNOWN pUnkOuter)
{
dprintf("DirectInput CreateDevice\n");
TRACE("DirectInput CreateDevice\n");
HRESULT result = real_di_CreateDevice(This, rguid, lplpDIDevice, pUnkOuter);
@ -64,7 +73,7 @@ static HRESULT WINAPI fake_di_CreateDevice(IDirectInputA *This, REFGUID rguid, L
{
real_did_SetCooperativeLevel =
(DIDSETCOOPERATIVELEVELPROC)hook_func(
(PROC *)&(*lplpDIDevice)->lpVtbl->SetCooperativeLevel, (PROC)fake_did_SetCooperativeLevel);
(PROC*)&(*lplpDIDevice)->lpVtbl->SetCooperativeLevel, (PROC)fake_did_SetCooperativeLevel);
real_did_GetDeviceData =
(DIDGETDEVICEDATAPROC)hook_func(
@ -74,9 +83,14 @@ static HRESULT WINAPI fake_di_CreateDevice(IDirectInputA *This, REFGUID rguid, L
return result;
}
static HRESULT WINAPI fake_di_CreateDeviceEx(IDirectInputA* This, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEA* lplpDIDevice, LPUNKNOWN pUnkOuter)
static HRESULT WINAPI fake_di_CreateDeviceEx(
IDirectInputA* This,
REFGUID rguid,
REFIID riid,
LPDIRECTINPUTDEVICEA* lplpDIDevice,
LPUNKNOWN pUnkOuter)
{
dprintf("DirectInput CreateDeviceEx\n");
TRACE("DirectInput CreateDeviceEx\n");
HRESULT result = real_di_CreateDeviceEx(This, rguid, riid, lplpDIDevice, pUnkOuter);
@ -94,9 +108,13 @@ static HRESULT WINAPI fake_di_CreateDeviceEx(IDirectInputA* This, REFGUID rguid,
return result;
}
HRESULT WINAPI fake_DirectInputCreateA(HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUTA* lplpDirectInput, LPUNKNOWN punkOuter)
HRESULT WINAPI fake_DirectInputCreateA(
HINSTANCE hinst,
DWORD dwVersion,
LPDIRECTINPUTA* lplpDirectInput,
LPUNKNOWN punkOuter)
{
dprintf("DirectInputCreateA\n");
TRACE("DirectInputCreateA\n");
if (!real_DirectInputCreateA)
{
@ -112,15 +130,19 @@ HRESULT WINAPI fake_DirectInputCreateA(HINSTANCE hinst, DWORD dwVersion, LPDIREC
if (SUCCEEDED(result) && !real_di_CreateDevice)
{
real_di_CreateDevice =
(DICREATEDEVICEPROC)hook_func((PROC *)&(*lplpDirectInput)->lpVtbl->CreateDevice, (PROC)fake_di_CreateDevice);
(DICREATEDEVICEPROC)hook_func((PROC*)&(*lplpDirectInput)->lpVtbl->CreateDevice, (PROC)fake_di_CreateDevice);
}
return result;
}
HRESULT WINAPI fake_DirectInputCreateW(HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUTW* lplpDirectInput, LPUNKNOWN punkOuter)
HRESULT WINAPI fake_DirectInputCreateW(
HINSTANCE hinst,
DWORD dwVersion,
LPDIRECTINPUTW* lplpDirectInput,
LPUNKNOWN punkOuter)
{
dprintf("DirectInputCreateW\n");
TRACE("DirectInputCreateW\n");
if (!real_DirectInputCreateW)
{
@ -142,9 +164,14 @@ HRESULT WINAPI fake_DirectInputCreateW(HINSTANCE hinst, DWORD dwVersion, LPDIREC
return result;
}
HRESULT WINAPI fake_DirectInputCreateEx(HINSTANCE hinst, DWORD dwVersion, REFIID riidltf, LPDIRECTINPUT7A* ppvOut, LPUNKNOWN punkOuter)
HRESULT WINAPI fake_DirectInputCreateEx(
HINSTANCE hinst,
DWORD dwVersion,
REFIID riidltf,
LPDIRECTINPUT7A* ppvOut,
LPUNKNOWN punkOuter)
{
dprintf("DirectInputCreateEx\n");
TRACE("DirectInputCreateEx\n");
if (!real_DirectInputCreateEx)
{
@ -163,9 +190,9 @@ HRESULT WINAPI fake_DirectInputCreateEx(HINSTANCE hinst, DWORD dwVersion, REFIID
(DICREATEDEVICEPROC)hook_func((PROC*)&(*ppvOut)->lpVtbl->CreateDevice, (PROC)fake_di_CreateDevice);
}
if (SUCCEEDED(result) &&
!real_di_CreateDeviceEx &&
riidltf &&
if (SUCCEEDED(result) &&
!real_di_CreateDeviceEx &&
riidltf &&
(IsEqualGUID(&IID_IDirectInput7A, riidltf) || IsEqualGUID(&IID_IDirectInput7W, riidltf)))
{
real_di_CreateDeviceEx =
@ -175,9 +202,14 @@ HRESULT WINAPI fake_DirectInputCreateEx(HINSTANCE hinst, DWORD dwVersion, REFIID
return result;
}
HRESULT WINAPI fake_DirectInput8Create(HINSTANCE hinst, DWORD dwVersion, REFIID riidltf, LPDIRECTINPUT8* ppvOut, LPUNKNOWN punkOuter)
HRESULT WINAPI fake_DirectInput8Create(
HINSTANCE hinst,
DWORD dwVersion,
REFIID riidltf,
LPDIRECTINPUT8* ppvOut,
LPUNKNOWN punkOuter)
{
dprintf("DirectInput8Create\n");
TRACE("DirectInput8Create\n");
if (!real_DirectInput8Create)
{

72
src/dllmain.c
View file

@ -10,10 +10,10 @@
#include "hook.h"
// export for cncnet cnc games
/* export for cncnet cnc games */
BOOL GameHandlesClose;
// export for some warcraft II tools
/* export for some warcraft II tools */
PVOID FakePrimarySurface;
@ -27,7 +27,7 @@ BOOL WINAPI DllMain(HANDLE hDll, DWORD dwReason, LPVOID lpReserved)
{
#if _DEBUG
dbg_init();
dprintf("cnc-ddraw = %p\n", hDll);
TRACE("cnc-ddraw = %p\n", hDll);
SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)dbg_exception_handler);
#endif
g_ddraw_module = hDll;
@ -64,7 +64,7 @@ BOOL WINAPI DllMain(HANDLE hDll, DWORD dwReason, LPVOID lpReserved)
HMODULE shcore_dll = GetModuleHandle("shcore.dll");
HMODULE user32_dll = GetModuleHandle("user32.dll");
if (user32_dll)
{
SETPROCESSDPIAWARENESSCONTEXTPROC set_awareness_context =
@ -91,7 +91,7 @@ BOOL WINAPI DllMain(HANDLE hDll, DWORD dwReason, LPVOID lpReserved)
if (!set_dpi_aware && user32_dll)
{
SETPROCESSDPIAWAREPROC set_aware =
SETPROCESSDPIAWAREPROC set_aware =
(SETPROCESSDPIAWAREPROC)GetProcAddress(user32_dll, "SetProcessDPIAware");
if (set_aware)
@ -104,7 +104,7 @@ BOOL WINAPI DllMain(HANDLE hDll, DWORD dwReason, LPVOID lpReserved)
}
case DLL_PROCESS_DETACH:
{
dprintf("cnc-ddraw DLL_PROCESS_DETACH\n");
TRACE("cnc-ddraw DLL_PROCESS_DETACH\n");
cfg_save();
@ -119,98 +119,108 @@ BOOL WINAPI DllMain(HANDLE hDll, DWORD dwReason, LPVOID lpReserved)
HRESULT WINAPI DirectDrawCreate(GUID FAR* lpGUID, LPDIRECTDRAW FAR* lplpDD, IUnknown FAR* pUnkOuter)
{
dprintf("-> %s(lpGUID=%p, lplpDD=%p, pUnkOuter=%p)\n", __FUNCTION__, lpGUID, lplpDD, pUnkOuter);
TRACE("-> %s(lpGUID=%p, lplpDD=%p, pUnkOuter=%p)\n", __FUNCTION__, lpGUID, lplpDD, pUnkOuter);
HRESULT ret = dd_CreateEx(lpGUID, (LPVOID*)lplpDD, &IID_IDirectDraw, pUnkOuter);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT WINAPI DirectDrawCreateClipper(DWORD dwFlags, LPDIRECTDRAWCLIPPER FAR* lplpDDClipper, IUnknown FAR* pUnkOuter)
{
dprintf("-> %s(dwFlags=%08X, DDClipper=%p, unkOuter=%p)\n", __FUNCTION__, (int)dwFlags, lplpDDClipper, pUnkOuter);
HRESULT ret = dd_CreateClipper(dwFlags, lplpDDClipper, pUnkOuter);
dprintf("<- %s\n", __FUNCTION__);
TRACE("-> %s(dwFlags=%08X, DDClipper=%p, unkOuter=%p)\n", __FUNCTION__, (int)dwFlags, lplpDDClipper, pUnkOuter);
HRESULT ret = dd_CreateClipper(dwFlags, (IDirectDrawClipperImpl**)lplpDDClipper, pUnkOuter);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT WINAPI DirectDrawCreateEx(GUID* lpGuid, LPVOID* lplpDD, REFIID iid, IUnknown* pUnkOuter)
{
dprintf("-> %s(lpGUID=%p, lplpDD=%p, riid=%08X, pUnkOuter=%p)\n", __FUNCTION__, lpGuid, lplpDD, iid, pUnkOuter);
TRACE("-> %s(lpGUID=%p, lplpDD=%p, riid=%08X, pUnkOuter=%p)\n", __FUNCTION__, lpGuid, lplpDD, iid, pUnkOuter);
HRESULT ret = dd_CreateEx(lpGuid, lplpDD, iid, pUnkOuter);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return ret;
}
HRESULT WINAPI DirectDrawEnumerateA(LPDDENUMCALLBACK lpCallback, LPVOID lpContext)
{
dprintf("-> %s(lpCallback=%p, lpContext=%p)\n", __FUNCTION__, lpCallback, lpContext);
TRACE("-> %s(lpCallback=%p, lpContext=%p)\n", __FUNCTION__, lpCallback, lpContext);
if (lpCallback)
lpCallback(NULL, "Primary Display Driver", "display", lpContext);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return DD_OK;
}
HRESULT WINAPI DirectDrawEnumerateExA(LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags)
{
dprintf("-> %s(lpCallback=%p, lpContext=%p, dwFlags=%d)\n", __FUNCTION__, lpCallback, lpContext, dwFlags);
TRACE("-> %s(lpCallback=%p, lpContext=%p, dwFlags=%d)\n", __FUNCTION__, lpCallback, lpContext, dwFlags);
if (lpCallback)
lpCallback(NULL, "Primary Display Driver", "display", lpContext, NULL);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return DD_OK;
}
HRESULT WINAPI DirectDrawEnumerateExW(LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags)
{
dprintf("-> %s(lpCallback=%p, lpContext=%p, dwFlags=%d)\n", __FUNCTION__, lpCallback, lpContext, dwFlags);
TRACE("-> %s(lpCallback=%p, lpContext=%p, dwFlags=%d)\n", __FUNCTION__, lpCallback, lpContext, dwFlags);
if (lpCallback)
lpCallback(NULL, L"Primary Display Driver", L"display", lpContext, NULL);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return DD_OK;
}
HRESULT WINAPI DirectDrawEnumerateW(LPDDENUMCALLBACKW lpCallback, LPVOID lpContext)
{
dprintf("-> %s(lpCallback=%p, lpContext=%p)\n", __FUNCTION__, lpCallback, lpContext);
TRACE("-> %s(lpCallback=%p, lpContext=%p)\n", __FUNCTION__, lpCallback, lpContext);
if (lpCallback)
lpCallback(NULL, L"Primary Display Driver", L"display", lpContext);
dprintf("<- %s\n", __FUNCTION__);
TRACE("<- %s\n", __FUNCTION__);
return DD_OK;
}
HRESULT WINAPI D3DParseUnknownCommand(LPVOID lpCmd, LPVOID* lpRetCmd)
{
dprintf("-> %s()\n", __FUNCTION__);
return E_FAIL;
TRACE("NOT_IMPLEMENTED -> %s(lpCmd=%p, lpRetCmd=%p)\n", __FUNCTION__, lpCmd, lpRetCmd);
HRESULT ret = E_FAIL;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
DWORD WINAPI AcquireDDThreadLock()
{
dprintf("-> %s()\n", __FUNCTION__);
return 0;
TRACE("NOT_IMPLEMENTED -> %s()\n", __FUNCTION__);
DWORD ret = 0;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
DWORD WINAPI ReleaseDDThreadLock()
{
dprintf("-> %s()\n", __FUNCTION__);
return 0;
TRACE("NOT_IMPLEMENTED -> %s()\n", __FUNCTION__);
DWORD ret = 0;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
DWORD WINAPI DDInternalLock(DWORD a, DWORD b)
{
dprintf("-> %s()\n", __FUNCTION__);
return 0;
TRACE("NOT_IMPLEMENTED -> %s()\n", __FUNCTION__);
DWORD ret = 0;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}
DWORD WINAPI DDInternalUnlock(DWORD a)
{
dprintf("-> %s()\n", __FUNCTION__);
return 0;
TRACE("NOT_IMPLEMENTED -> %s()\n", __FUNCTION__);
DWORD ret = 0;
TRACE("NOT_IMPLEMENTED <- %s\n", __FUNCTION__);
return ret;
}

2
src/fps_limiter.c
View file

@ -3,7 +3,7 @@
#include "dd.h"
#include "debug.h"
fps_limiter g_fpsl;
FPSLIMITER g_fpsl;
void fpsl_init()
{

42
src/hook.c
View file

@ -45,7 +45,7 @@ LOADLIBRARYWPROC real_LoadLibraryW = LoadLibraryW;
LOADLIBRARYEXAPROC real_LoadLibraryExA = LoadLibraryExA;
LOADLIBRARYEXWPROC real_LoadLibraryExW = LoadLibraryExW;
static hook_list g_hooks[] =
static HOOKLIST g_hooks[] =
{
{
"user32.dll",
@ -106,19 +106,19 @@ static hook_list g_hooks[] =
void hook_patch_iat(HMODULE hmod, BOOL unhook, char* module_name, char* function_name, PROC new_function)
{
hook_list hooks[2];
HOOKLIST hooks[2];
memset(&hooks, 0, sizeof(hooks));
hooks[0].enabled = TRUE;
hooks[0].data[0].new_function = new_function;
strncpy(hooks[0].module_name, module_name, sizeof(hooks[0].module_name)-1);
strncpy(hooks[0].module_name, module_name, sizeof(hooks[0].module_name) - 1);
strncpy(hooks[0].data[0].function_name, function_name, sizeof(hooks[0].data[0].function_name) - 1);
hook_patch_iat_list(hmod, unhook, (hook_list*)&hooks);
hook_patch_iat_list(hmod, unhook, (HOOKLIST*)&hooks);
}
void hook_patch_iat_list(HMODULE hmod, BOOL unhook, hook_list* hooks)
void hook_patch_iat_list(HMODULE hmod, BOOL unhook, HOOKLIST* hooks)
{
if (!hmod || hmod == INVALID_HANDLE_VALUE || !hooks)
return;
@ -179,9 +179,9 @@ void hook_patch_iat_list(HMODULE hmod, BOOL unhook, hook_list* hooks)
{
if (unhook)
{
DWORD org =
DWORD org =
(DWORD)GetProcAddress(
GetModuleHandle(hooks[i].module_name),
GetModuleHandle(hooks[i].module_name),
hooks[i].data[x].function_name);
if (org)
@ -213,13 +213,13 @@ void hook_patch_iat_list(HMODULE hmod, BOOL unhook, hook_list* hooks)
}
#ifdef _MSC_VER
}
__except (EXCEPTION_EXECUTE_HANDLER)
__except (EXCEPTION_EXECUTE_HANDLER)
{
}
#endif
}
void hook_create(hook_list* hooks)
void hook_create(HOOKLIST* hooks)
{
#ifdef _MSC_VER
if (g_hook_method == 2)
@ -270,13 +270,13 @@ void hook_create(hook_list* hooks)
if (GetModuleFileNameA(hmod, mod_path, MAX_PATH))
{
dprintfex("Module %s = %p\n", mod_path, hmod);
TRACE_EXT("Module %s = %p\n", mod_path, hmod);
_splitpath(mod_path, NULL, mod_dir, mod_filename, NULL);
/* Don't hook reshade/swiftshader/mesa3d */
if (_strcmpi(mod_filename, "opengl32") == 0 ||
_strcmpi(mod_filename, "d3d9") == 0 ||
if (_strcmpi(mod_filename, "opengl32") == 0 ||
_strcmpi(mod_filename, "d3d9") == 0 ||
_strcmpi(mod_filename, "Shw32") == 0)
continue;
@ -298,7 +298,7 @@ void hook_create(hook_list* hooks)
}
}
void hook_revert(hook_list* hooks)
void hook_revert(HOOKLIST* hooks)
{
#ifdef _MSC_VER
if (g_hook_method == 2)
@ -375,7 +375,8 @@ void hook_init()
#ifdef _MSC_VER
if (!g_hook_active && g_hook_method == 3)
{
real_DirectInputCreateA = (DIRECTINPUTCREATEAPROC)GetProcAddress(LoadLibraryA("dinput.dll"), "DirectInputCreateA");
real_DirectInputCreateA =
(DIRECTINPUTCREATEAPROC)GetProcAddress(LoadLibraryA("dinput.dll"), "DirectInputCreateA");
if (real_DirectInputCreateA)
{
@ -385,7 +386,8 @@ void hook_init()
DetourTransactionCommit();
}
real_DirectInputCreateW = (DIRECTINPUTCREATEWPROC)GetProcAddress(LoadLibraryA("dinput.dll"), "DirectInputCreateW");
real_DirectInputCreateW =
(DIRECTINPUTCREATEWPROC)GetProcAddress(LoadLibraryA("dinput.dll"), "DirectInputCreateW");
if (real_DirectInputCreateW)
{
@ -395,7 +397,8 @@ void hook_init()
DetourTransactionCommit();
}
real_DirectInputCreateEx = (DIRECTINPUTCREATEEXPROC)GetProcAddress(LoadLibraryA("dinput.dll"), "DirectInputCreateEx");
real_DirectInputCreateEx =
(DIRECTINPUTCREATEEXPROC)GetProcAddress(LoadLibraryA("dinput.dll"), "DirectInputCreateEx");
if (real_DirectInputCreateEx)
{
@ -405,7 +408,8 @@ void hook_init()
DetourTransactionCommit();
}
real_DirectInput8Create = (DIRECTINPUT8CREATEPROC)GetProcAddress(LoadLibraryA("dinput8.dll"), "DirectInput8Create");
real_DirectInput8Create =
(DIRECTINPUT8CREATEPROC)GetProcAddress(LoadLibraryA("dinput8.dll"), "DirectInput8Create");
if (real_DirectInput8Create)
{
@ -430,7 +434,7 @@ void hook_init()
}
}
hook_create((hook_list*)&g_hooks);
hook_create((HOOKLIST*)&g_hooks);
}
}
@ -486,7 +490,7 @@ void hook_exit()
}
#endif
hook_revert((hook_list*)&g_hooks);
hook_revert((HOOKLIST*)&g_hooks);
}
hook_patch_iat(GetModuleHandle(NULL), TRUE, "dinput.dll", "DirectInputCreateA", (PROC)fake_DirectInputCreateA);

32
src/mouse.c
View file

@ -14,17 +14,17 @@ void mouse_lock()
if (g_ddraw->devmode)
{
if (g_ddraw->handlemouse)
while(real_ShowCursor(FALSE) >= 0);
while (real_ShowCursor(FALSE) >= 0);
return;
}
if (g_hook_active && !g_ddraw->locked)
{
// Get the window client area.
/* Get the window client area */
real_GetClientRect(g_ddraw->hwnd, &rc);
if(g_ddraw->adjmouse)
if (g_ddraw->adjmouse)
{
rc.right = g_ddraw->render.viewport.width;
rc.bottom = g_ddraw->render.viewport.height;
@ -35,21 +35,21 @@ void mouse_lock()
rc.bottom = g_ddraw->height;
}
// Convert the client area to screen coordinates.
/* Convert the client area to screen coordinates */
POINT pt = { rc.left, rc.top };
POINT pt2 = { rc.right, rc.bottom };
real_ClientToScreen(g_ddraw->hwnd, &pt);
real_ClientToScreen(g_ddraw->hwnd, &pt2);
SetRect(&rc, pt.x, pt.y, pt2.x, pt2.y);
rc.bottom -= (LONG)((g_ddraw->mouse_y_adjust * 2) * g_ddraw->render.scale_h);
if(g_ddraw->adjmouse)
if (g_ddraw->adjmouse)
{
real_SetCursorPos(
(int)(rc.left + (g_ddraw->cursor.x * g_ddraw->render.scale_w)),
(int)(rc.left + (g_ddraw->cursor.x * g_ddraw->render.scale_w)),
(int)(rc.top + ((g_ddraw->cursor.y - g_ddraw->mouse_y_adjust) * g_ddraw->render.scale_h)));
}
else
@ -84,7 +84,7 @@ void mouse_unlock()
if (g_ddraw->devmode)
{
if (g_ddraw->handlemouse)
while(real_ShowCursor(TRUE) < 0);
while (real_ShowCursor(TRUE) < 0);
return;
}
@ -98,10 +98,10 @@ void mouse_unlock()
{
g_ddraw->locked = FALSE;
// Get the window client area.
/* Get the window client area */
real_GetClientRect(g_ddraw->hwnd, &rc);
// Convert the client area to screen coordinates.
/* Convert the client area to screen coordinates */
POINT pt = { rc.left, rc.top };
POINT pt2 = { rc.right, rc.bottom };
@ -109,7 +109,7 @@ void mouse_unlock()
real_ClientToScreen(g_ddraw->hwnd, &pt2);
SetRect(&rc, pt.x, pt.y, pt2.x, pt2.y);
if (g_ddraw->handlemouse)
{
while (real_ShowCursor(TRUE) < 0);
@ -126,9 +126,9 @@ void mouse_unlock()
}
real_ClipCursor(NULL);
real_SetCursorPos(
(int)(rc.left + g_ddraw->render.viewport.x + (g_ddraw->cursor.x * g_ddraw->render.scale_w)),
(int)(rc.left + g_ddraw->render.viewport.x + (g_ddraw->cursor.x * g_ddraw->render.scale_w)),
(int)(rc.top + g_ddraw->render.viewport.y + ((g_ddraw->cursor.y + g_ddraw->mouse_y_adjust) * g_ddraw->render.scale_h)));
}
}

29
src/opengl_utils.c
View file

@ -131,7 +131,6 @@ BOOL oglu_load_dll()
void oglu_init()
{
// Program
glCreateProgram = (PFNGLCREATEPROGRAMPROC)xwglGetProcAddress("glCreateProgram");
glDeleteProgram = (PFNGLDELETEPROGRAMPROC)xwglGetProcAddress("glDeleteProgram");
glUseProgram = (PFNGLUSEPROGRAMPROC)xwglGetProcAddress("glUseProgram");
@ -190,10 +189,10 @@ void oglu_init()
glTexBuffer = (PFNGLTEXBUFFERPROC)xwglGetProcAddress("glTexBuffer");
char *glversion = (char *)glGetString(GL_VERSION);
char* glversion = (char*)glGetString(GL_VERSION);
if (glversion)
{
strncpy(g_oglu_version, glversion, sizeof(g_oglu_version)-1);
strncpy(g_oglu_version, glversion, sizeof(g_oglu_version) - 1);
const char deli[2] = " ";
strtok(g_oglu_version, deli);
}
@ -217,9 +216,9 @@ void oglu_init()
}
}
BOOL oglu_ext_exists(char *ext, HDC hdc)
BOOL oglu_ext_exists(char* ext, HDC hdc)
{
char *glext = (char *)glGetString(GL_EXTENSIONS);
char* glext = (char*)glGetString(GL_EXTENSIONS);
if (glext)
{
@ -229,7 +228,7 @@ BOOL oglu_ext_exists(char *ext, HDC hdc)
if (wglGetExtensionsStringARB)
{
char *wglext = (char *)wglGetExtensionsStringARB(hdc);
char* wglext = (char*)wglGetExtensionsStringARB(hdc);
if (wglext)
{
@ -241,7 +240,7 @@ BOOL oglu_ext_exists(char *ext, HDC hdc)
return FALSE;
}
GLuint oglu_build_program(const GLchar *vert_source, const GLchar *frag_source)
GLuint oglu_build_program(const GLchar* vert_source, const GLchar* frag_source)
{
if (!glCreateShader || !glShaderSource || !glCompileShader || !glCreateProgram ||
!glAttachShader || !glLinkProgram || !glUseProgram || !glDetachShader)
@ -317,36 +316,36 @@ GLuint oglu_build_program(const GLchar *vert_source, const GLchar *frag_source)
return program;
}
GLuint oglu_build_program_from_file(const char *file_path, BOOL core_profile)
GLuint oglu_build_program_from_file(const char* file_path, BOOL core_profile)
{
GLuint program = 0;
FILE *file = fopen(file_path, "rb");
FILE* file = fopen(file_path, "rb");
if (file)
{
fseek(file, 0, SEEK_END);
long file_size = ftell(file);
fseek(file, 0, SEEK_SET);
char *source = file_size > 0 ? calloc(file_size + 1, 1) : NULL;
char* source = file_size > 0 ? calloc(file_size + 1, 1) : NULL;
if (source)
{
fread(source, file_size, 1, file);
fclose(file);
char *vert_source = calloc(file_size + 50, 1);
char *frag_source = calloc(file_size + 50, 1);
char* vert_source = calloc(file_size + 50, 1);
char* frag_source = calloc(file_size + 50, 1);
if (frag_source && vert_source)
{
char *version_start = strstr(source, "#version");
char* version_start = strstr(source, "#version");
if (version_start)
{
if (core_profile)
{
if (_strnicmp(version_start, "#version 130", 12) == 0 ||
if (_strnicmp(version_start, "#version 130", 12) == 0 ||
_strnicmp(version_start, "#version 140", 12) == 0)
{
memcpy(version_start, "#version 150", 12);
@ -354,7 +353,7 @@ GLuint oglu_build_program_from_file(const char *file_path, BOOL core_profile)
}
const char deli[2] = "\n";
char *version = strtok(version_start, deli);
char* version = strtok(version_start, deli);
strcpy(vert_source, source);
strcpy(frag_source, source);

43
src/render_d3d9.c
View file

@ -15,7 +15,7 @@ static BOOL d3d9_create_resouces();
static BOOL d3d9_set_states();
static BOOL d3d9_update_vertices(BOOL upscale_hack, BOOL stretch);
static d3d9_renderer g_d3d9;
static D3D9RENDERER g_d3d9;
BOOL d3d9_is_available()
{
@ -45,15 +45,15 @@ BOOL d3d9_create()
{
if (g_ddraw->nonexclusive)
{
int (WINAPI* d3d9_enable_shim)(BOOL) =
int (WINAPI * d3d9_enable_shim)(BOOL) =
(int (WINAPI*)(BOOL))GetProcAddress(g_d3d9.hmodule, "Direct3D9EnableMaximizedWindowedModeShim");
if (d3d9_enable_shim)
d3d9_enable_shim(TRUE);
}
IDirect3D9 *(WINAPI *d3d_create9)(UINT) =
(IDirect3D9 *(WINAPI *)(UINT))GetProcAddress(g_d3d9.hmodule, "Direct3DCreate9");
IDirect3D9* (WINAPI * d3d_create9)(UINT) =
(IDirect3D9 * (WINAPI*)(UINT))GetProcAddress(g_d3d9.hmodule, "Direct3DCreate9");
if (d3d_create9 && (g_d3d9.instance = d3d_create9(D3D_SDK_VERSION)))
{
@ -78,8 +78,7 @@ BOOL d3d9_create()
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
};
int i;
for (i = 0; i < sizeof(behavior_flags) / sizeof(behavior_flags[0]); i++)
for (int i = 0; i < sizeof(behavior_flags) / sizeof(behavior_flags[0]); i++)
{
if (SUCCEEDED(
IDirect3D9_CreateDevice(
@ -188,11 +187,11 @@ static BOOL d3d9_create_resouces()
err = err || FAILED(
IDirect3DDevice9_CreateVertexBuffer(
g_d3d9.device,
sizeof(CUSTOMVERTEX) * 4, 0,
D3DFVF_XYZRHW | D3DFVF_TEX1,
D3DPOOL_MANAGED,
&g_d3d9.vertex_buf,
g_d3d9.device,
sizeof(CUSTOMVERTEX) * 4, 0,
D3DFVF_XYZRHW | D3DFVF_TEX1,
D3DPOOL_MANAGED,
&g_d3d9.vertex_buf,
NULL));
err = err || !d3d9_update_vertices(InterlockedExchangeAdd(&g_ddraw->upscale_hack_active, 0), TRUE);
@ -234,7 +233,7 @@ static BOOL d3d9_create_resouces()
if (g_ddraw->bpp == 8)
{
err = err || FAILED(
IDirect3DDevice9_CreatePixelShader(g_d3d9.device, (DWORD *)D3D9_PALETTE_SHADER, &g_d3d9.pixel_shader));
IDirect3DDevice9_CreatePixelShader(g_d3d9.device, (DWORD*)D3D9_PALETTE_SHADER, &g_d3d9.pixel_shader));
}
return g_d3d9.vertex_buf && (g_d3d9.pixel_shader || g_ddraw->bpp == 16 || g_ddraw->bpp == 32) && !err;
@ -246,11 +245,11 @@ static BOOL d3d9_set_states()
err = err || FAILED(IDirect3DDevice9_SetFVF(g_d3d9.device, D3DFVF_XYZRHW | D3DFVF_TEX1));
err = err || FAILED(IDirect3DDevice9_SetStreamSource(g_d3d9.device, 0, g_d3d9.vertex_buf, 0, sizeof(CUSTOMVERTEX)));
err = err || FAILED(IDirect3DDevice9_SetTexture(g_d3d9.device, 0, (IDirect3DBaseTexture9 *)g_d3d9.surface_tex[0]));
err = err || FAILED(IDirect3DDevice9_SetTexture(g_d3d9.device, 0, (IDirect3DBaseTexture9*)g_d3d9.surface_tex[0]));
if (g_ddraw->bpp == 8)
{
err = err || FAILED(IDirect3DDevice9_SetTexture(g_d3d9.device, 1, (IDirect3DBaseTexture9 *)g_d3d9.palette_tex[0]));
err = err || FAILED(IDirect3DDevice9_SetTexture(g_d3d9.device, 1, (IDirect3DBaseTexture9*)g_d3d9.palette_tex[0]));
err = err || FAILED(IDirect3DDevice9_SetPixelShader(g_d3d9.device, g_d3d9.pixel_shader));
}
else
@ -294,7 +293,7 @@ static BOOL d3d9_update_vertices(BOOL upscale_hack, BOOL stretch)
{ vp_w - 0.5f, vp_y - 0.5f, 0.0f, 1.0f, s_w, 0.0f }
};
void *data;
void* data;
if (g_d3d9.vertex_buf && SUCCEEDED(IDirect3DVertexBuffer9_Lock(g_d3d9.vertex_buf, 0, 0, (void**)&data, 0)))
{
memcpy(data, vertices, sizeof(vertices));
@ -316,7 +315,7 @@ DWORD WINAPI d3d9_render_main(void)
DWORD timeout = g_ddraw->render.minfps > 0 ? g_ddraw->render.minfps_tick_len : 200;
while (g_ddraw->render.run &&
while (g_ddraw->render.run &&
(g_ddraw->render.minfps < 0 || WaitForSingleObject(g_ddraw->render.sem, timeout) != WAIT_FAILED))
{
#if _DEBUG
@ -354,11 +353,11 @@ DWORD WINAPI d3d9_render_main(void)
RECT rc = { 0, 0, g_ddraw->width, g_ddraw->height };
if (SUCCEEDED(IDirect3DDevice9_SetTexture(g_d3d9.device, 0, (IDirect3DBaseTexture9 *)g_d3d9.surface_tex[tex_index])) &&
if (SUCCEEDED(IDirect3DDevice9_SetTexture(g_d3d9.device, 0, (IDirect3DBaseTexture9*)g_d3d9.surface_tex[tex_index])) &&
SUCCEEDED(IDirect3DTexture9_LockRect(g_d3d9.surface_tex[tex_index], 0, &lock_rc, &rc, 0)))
{
unsigned char *src = (unsigned char *)g_ddraw->primary->surface;
unsigned char *dst = (unsigned char *)lock_rc.pBits;
unsigned char* src = (unsigned char*)g_ddraw->primary->surface;
unsigned char* dst = (unsigned char*)lock_rc.pBits;
int i;
for (i = 0; i < g_ddraw->height; i++)
@ -373,7 +372,7 @@ DWORD WINAPI d3d9_render_main(void)
}
}
if (g_ddraw->bpp == 8 &&
if (g_ddraw->bpp == 8 &&
(InterlockedExchange(&g_ddraw->render.palette_updated, FALSE) || g_ddraw->render.minfps == -2))
{
if (++pal_index >= D3D9_TEXTURE_COUNT)
@ -381,7 +380,7 @@ DWORD WINAPI d3d9_render_main(void)
RECT rc = { 0,0,256,1 };
if (SUCCEEDED(IDirect3DDevice9_SetTexture(g_d3d9.device, 1, (IDirect3DBaseTexture9 *)g_d3d9.palette_tex[pal_index])) &&
if (SUCCEEDED(IDirect3DDevice9_SetTexture(g_d3d9.device, 1, (IDirect3DBaseTexture9*)g_d3d9.palette_tex[pal_index])) &&
SUCCEEDED(IDirect3DTexture9_LockRect(g_d3d9.palette_tex[pal_index], 0, &lock_rc, &rc, 0)))
{
memcpy(lock_rc.pBits, g_ddraw->primary->palette->data_rgb, 256 * sizeof(int));
@ -433,7 +432,7 @@ DWORD WINAPI d3d9_render_main(void)
#if _DEBUG
dbg_draw_frame_info_end();
#endif
fpsl_frame_end();
}

69
src/render_gdi.c
View file

@ -24,8 +24,9 @@ DWORD WINAPI gdi_render_main(void)
PostMessage(g_ddraw->hwnd, WM_AUTORENDERER, 0, 0);
_snprintf(
warning_text, sizeof(warning_text),
"-WARNING- Using slow software rendering, please update your graphics card driver (%s)",
warning_text,
sizeof(warning_text),
"-WARNING- Using slow software rendering, please update your graphics card driver (%s)",
strlen(g_oglu_version) > 10 ? "" : g_oglu_version);
}
@ -94,54 +95,54 @@ DWORD WINAPI gdi_render_main(void)
else if (upscale_hack)
{
StretchDIBits(
g_ddraw->render.hdc,
g_ddraw->render.viewport.x,
g_ddraw->render.hdc,
g_ddraw->render.viewport.x,
g_ddraw->render.viewport.y,
g_ddraw->render.viewport.width,
g_ddraw->render.viewport.width,
g_ddraw->render.viewport.height,
0,
0,
g_ddraw->height - g_ddraw->upscale_hack_height,
g_ddraw->upscale_hack_width,
g_ddraw->upscale_hack_height,
g_ddraw->primary->surface,
g_ddraw->primary->bmi,
DIB_RGB_COLORS,
g_ddraw->primary->bmi,
DIB_RGB_COLORS,
SRCCOPY);
}
else if (!g_ddraw->child_window_exists &&
(g_ddraw->render.width != g_ddraw->width || g_ddraw->render.height != g_ddraw->height))
else if (!g_ddraw->child_window_exists &&
(g_ddraw->render.width != g_ddraw->width || g_ddraw->render.height != g_ddraw->height))
{
StretchDIBits(
g_ddraw->render.hdc,
g_ddraw->render.viewport.x,
g_ddraw->render.viewport.y,
g_ddraw->render.viewport.width,
g_ddraw->render.viewport.height,
0,
0,
g_ddraw->width,
g_ddraw->height,
g_ddraw->primary->surface,
g_ddraw->primary->bmi,
DIB_RGB_COLORS,
g_ddraw->render.hdc,
g_ddraw->render.viewport.x,
g_ddraw->render.viewport.y,
g_ddraw->render.viewport.width,
g_ddraw->render.viewport.height,
0,
0,
g_ddraw->width,
g_ddraw->height,
g_ddraw->primary->surface,
g_ddraw->primary->bmi,
DIB_RGB_COLORS,
SRCCOPY);
}
else
{
SetDIBitsToDevice(
g_ddraw->render.hdc,
0,
0,
g_ddraw->width,
g_ddraw->height,
0,
0,
0,
g_ddraw->height,
g_ddraw->primary->surface,
g_ddraw->primary->bmi,
g_ddraw->render.hdc,
0,
0,
g_ddraw->width,
g_ddraw->height,
0,
0,
0,
g_ddraw->height,
g_ddraw->primary->surface,
g_ddraw->primary->bmi,
DIB_RGB_COLORS);
}
}
}
LeaveCriticalSection(&g_ddraw->cs);

50
src/render_ogl.c
View file

@ -22,7 +22,7 @@ static void ogl_delete_context(HGLRC context);
static BOOL ogl_texture_upload_test();
static BOOL ogl_shader_test();
static ogl_renderer g_ogl;
static OGLRENDERER g_ogl;
DWORD WINAPI ogl_render_main(void)
{
@ -70,7 +70,7 @@ static HGLRC ogl_create_core_context(HDC hdc)
if (!wglCreateContextAttribsARB)
return g_ogl.context;
int attribs[] = {
int attribs[] = {
WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
WGL_CONTEXT_MINOR_VERSION_ARB, 2,
WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
@ -79,7 +79,7 @@ static HGLRC ogl_create_core_context(HDC hdc)
HGLRC context = wglCreateContextAttribsARB(hdc, 0, attribs);
BOOL made_current = context && xwglMakeCurrent(hdc, context);
if (made_current)
{
xwglDeleteContext(g_ogl.context);
@ -171,7 +171,7 @@ static void ogl_create_textures(int width, int height)
g_ogl.surface_tex_height =
height <= 512 ? 512 : height <= 1024 ? 1024 : height <= 2048 ? 2048 : height <= 4096 ? 4096 : height;
g_ogl.surface_tex =
g_ogl.surface_tex =
HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, g_ogl.surface_tex_width * g_ogl.surface_tex_height * sizeof(int));
g_ogl.adjust_alignment = (width % 4) != 0;
@ -300,7 +300,7 @@ static void ogl_init_main_program()
glUseProgram(g_ogl.main_program);
glUniform1i(glGetUniformLocation(g_ogl.main_program, "SurfaceTex"), 0);
if (g_ddraw->bpp == 8)
glUniform1i(glGetUniformLocation(g_ogl.main_program, "PaletteTex"), 1);
@ -476,7 +476,16 @@ static void ogl_init_scale_program()
glBindTexture(GL_TEXTURE_2D, g_ogl.frame_buffer_tex_id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, g_ogl.filter_bilinear ? GL_LINEAR : GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, g_ogl.filter_bilinear ? GL_LINEAR : GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, g_ogl.surface_tex_width, g_ogl.surface_tex_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glTexImage2D(
GL_TEXTURE_2D,
0,
GL_RGBA8,
g_ogl.surface_tex_width,
g_ogl.surface_tex_height,
0,
GL_RGBA,
GL_UNSIGNED_BYTE,
0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, g_ogl.frame_buffer_tex_id, 0);
@ -592,7 +601,7 @@ static void ogl_render()
}
}
if (g_ddraw->bpp == 8 &&
if (g_ddraw->bpp == 8 &&
(InterlockedExchange(&g_ddraw->render.palette_updated, FALSE) || g_ddraw->render.minfps == -2))
{
if (++pal_index >= TEXTURE_COUNT)
@ -657,7 +666,7 @@ static void ogl_render()
{
g_ddraw->child_window_exists = FALSE;
EnumChildWindows(g_ddraw->hwnd, util_enum_child_proc, (LPARAM)g_ddraw->primary);
if (g_ddraw->render.width != g_ddraw->width || g_ddraw->render.height != g_ddraw->height)
{
if (g_ddraw->child_window_exists)
@ -733,7 +742,7 @@ static void ogl_render()
if (g_ogl.scale_program && g_ogl.main_program)
{
// draw surface into framebuffer
/* draw surface into framebuffer */
glUseProgram(g_ogl.main_program);
glViewport(0, 0, g_ddraw->width, g_ddraw->height);
@ -760,7 +769,7 @@ static void ogl_render()
g_ddraw->render.viewport.width, g_ddraw->render.viewport.height);
}
// apply filter
/* apply filter */
glUseProgram(g_ogl.scale_program);
glActiveTexture(GL_TEXTURE0);
@ -783,10 +792,10 @@ static void ogl_render()
else
{
glBegin(GL_TRIANGLE_FAN);
glTexCoord2f(0, 0); glVertex2f(-1, 1);
glTexCoord2f(g_ogl.scale_w, 0); glVertex2f( 1, 1);
glTexCoord2f(g_ogl.scale_w, g_ogl.scale_h); glVertex2f( 1, -1);
glTexCoord2f(0, g_ogl.scale_h); glVertex2f(-1, -1);
glTexCoord2f(0, 0); glVertex2f(-1, 1);
glTexCoord2f(g_ogl.scale_w, 0); glVertex2f(1, 1);
glTexCoord2f(g_ogl.scale_w, g_ogl.scale_h); glVertex2f(1, -1);
glTexCoord2f(0, g_ogl.scale_h); glVertex2f(-1, -1);
glEnd();
}
@ -935,7 +944,16 @@ static BOOL ogl_shader_test()
glBindTexture(GL_TEXTURE_2D, fbo_tex_id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, g_ogl.surface_tex_width, g_ogl.surface_tex_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, g_ogl.surface_tex);
glTexImage2D(
GL_TEXTURE_2D,
0,
GL_RGBA8,
g_ogl.surface_tex_width,
g_ogl.surface_tex_height,
0,
GL_RGBA,
GL_UNSIGNED_BYTE,
g_ogl.surface_tex);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fbo_tex_id, 0);
@ -998,7 +1016,7 @@ static BOOL ogl_shader_test()
{
result = FALSE;
break;
}
}
}
}

22
src/screenshot.c
View file

@ -45,37 +45,37 @@ static BOOL ss_screenshot_8bit(char* filename, IDirectDrawSurfaceImpl* src)
static BOOL ss_screenshot_16bit(char* filename, IDirectDrawSurfaceImpl* src)
{
unsigned int error = TRUE;
unsigned int* src_buf = malloc(src->width * src->height * 4);
unsigned int* dst_buf = malloc(src->width * src->height * 4);
if (src_buf)
if (dst_buf)
{
unsigned short* surface = (unsigned short*)dds_GetBuffer(src);
unsigned short* src_buf = (unsigned short*)dds_GetBuffer(src);
for (int y = 0; y < src->height; y++)
{
int src_y = y * src->width;
int dst_row = y * src->width;
for (int x = 0; x < src->width; x++)
{
unsigned short pixel = surface[src_y + x];
unsigned short pixel = src_buf[dst_row + x];
BYTE red = ((pixel & 0xF800) >> 11) << 3;
BYTE green = ((pixel & 0x07E0) >> 5) << 2;
BYTE blue = ((pixel & 0x001F)) << 3;
src_buf[src_y + x] = (0xFF << 24) | (blue << 16) | (green << 8) | red;
dst_buf[dst_row + x] = (0xFF << 24) | (blue << 16) | (green << 8) | red;
}
}
error = lodepng_encode32_file(filename, (unsigned char*)src_buf, src->width, src->height);
error = lodepng_encode32_file(filename, (unsigned char*)dst_buf, src->width, src->height);
free(src_buf);
free(dst_buf);
}
return !error;
}
BOOL ss_take_screenshot(IDirectDrawSurfaceImpl *src)
BOOL ss_take_screenshot(IDirectDrawSurfaceImpl* src)
{
if (!src || !dds_GetBuffer(src))
return FALSE;
@ -87,7 +87,7 @@ BOOL ss_take_screenshot(IDirectDrawSurfaceImpl *src)
strncpy(title, g_ddraw->title, sizeof(g_ddraw->title));
for (int i = 0; i<strlen(title); i++)
for (int i = 0; i < strlen(title); i++)
{
if (title[i] == ' ')
{
@ -111,5 +111,5 @@ BOOL ss_take_screenshot(IDirectDrawSurfaceImpl *src)
return ss_screenshot_16bit(filename, src);
}
return FALSE;;
return FALSE;
}

31
src/utils.c
View file

@ -1,5 +1,5 @@
#include <windows.h>
#include "ddraw.h"
#include <ddraw.h>
#include "dd.h"
#include "ddsurface.h"
#include "hook.h"
@ -16,7 +16,7 @@ void util_limit_game_ticks()
FILETIME ft = { 0 };
GetSystemTimeAsFileTime(&ft);
if (CompareFileTime((FILETIME *)&g_ddraw->ticks_limiter.due_time, &ft) == -1)
if (CompareFileTime((FILETIME*)&g_ddraw->ticks_limiter.due_time, &ft) == -1)
{
memcpy(&g_ddraw->ticks_limiter.due_time, &ft, sizeof(LARGE_INTEGER));
}
@ -119,7 +119,7 @@ void util_update_bnet_pos(int new_x, int new_y)
hwnd = FindWindowEx(HWND_DESKTOP, hwnd, "SDlgDialog", NULL);
}
if (adj_x || adj_y)
{
HWND hwnd = FindWindowEx(HWND_DESKTOP, NULL, "SDlgDialog", NULL);
@ -148,7 +148,13 @@ void util_update_bnet_pos(int new_x, int new_y)
old_y = new_y;
}
BOOL util_get_lowest_resolution(float ratio, SIZE *out_res, DWORD min_width, DWORD min_height, DWORD max_width, DWORD max_height)
BOOL util_get_lowest_resolution(
float ratio,
SIZE* out_res,
DWORD min_width,
DWORD min_height,
DWORD max_width,
DWORD max_height)
{
BOOL result = FALSE;
int org_ratio = (int)((ratio + 0.005f) * 100);
@ -160,7 +166,7 @@ BOOL util_get_lowest_resolution(float ratio, SIZE *out_res, DWORD min_width, DWO
while (EnumDisplaySettings(NULL, i, &m))
{
if (m.dmPelsWidth >= min_width &&
if (m.dmPelsWidth >= min_width &&
m.dmPelsHeight >= min_height &&
m.dmPelsWidth <= max_width &&
m.dmPelsHeight <= max_height &&
@ -229,7 +235,13 @@ void util_toggle_fullscreen()
mouse_unlock();
g_config.window_state = g_ddraw->windowed = FALSE;
real_SetWindowLongA(g_ddraw->hwnd, GWL_STYLE, GetWindowLong(g_ddraw->hwnd, GWL_STYLE) & ~(WS_CAPTION | WS_THICKFRAME | WS_MINIMIZE | WS_MAXIMIZE | WS_SYSMENU));
LONG style = GetWindowLong(g_ddraw->hwnd, GWL_STYLE);
real_SetWindowLongA(
g_ddraw->hwnd,
GWL_STYLE,
style & ~(WS_CAPTION | WS_THICKFRAME | WS_MINIMIZE | WS_MAXIMIZE | WS_SYSMENU));
g_ddraw->altenter = TRUE;
dd_SetDisplayMode(g_ddraw->width, g_ddraw->height, g_ddraw->bpp, FALSE);
util_update_bnet_pos(0, 0);
@ -335,7 +347,8 @@ BOOL CALLBACK util_enum_child_proc(HWND hwnd, LPARAM lparam)
static unsigned char util_get_pixel(int x, int y)
{
return ((unsigned char*)dds_GetBuffer(g_ddraw->primary))[y * g_ddraw->primary->l_pitch + x * g_ddraw->primary->lx_pitch];
return ((unsigned char*)dds_GetBuffer(
g_ddraw->primary))[y * g_ddraw->primary->l_pitch + x * g_ddraw->primary->lx_pitch];
}
BOOL util_detect_low_res_screen()
@ -360,8 +373,8 @@ BOOL util_detect_low_res_screen()
}
else if (g_ddraw->iscnc1)
{
return
util_get_pixel(g_ddraw->upscale_hack_width + 1, 0) == 0 ||
return
util_get_pixel(g_ddraw->upscale_hack_width + 1, 0) == 0 ||
util_get_pixel(g_ddraw->upscale_hack_width + 5, 1) == 0;
}
else if (g_ddraw->iskkndx)

44
src/winapi_hooks.c
View file

@ -13,16 +13,16 @@
BOOL WINAPI fake_GetCursorPos(LPPOINT lpPoint)
{
POINT pt, realpt;
if (!real_GetCursorPos(&pt) || !g_ddraw)
return FALSE;
realpt.x = pt.x;
realpt.y = pt.y;
if(g_ddraw->locked && (!g_ddraw->windowed || real_ScreenToClient(g_ddraw->hwnd, &pt)))
if (g_ddraw->locked && (!g_ddraw->windowed || real_ScreenToClient(g_ddraw->hwnd, &pt)))
{
//fallback solution for possible ClipCursor failure
/* fallback solution for possible ClipCursor failure */
int diffx = 0, diffy = 0;
int max_width = g_ddraw->adjmouse ? g_ddraw->render.viewport.width : g_ddraw->width;
@ -56,7 +56,7 @@ BOOL WINAPI fake_GetCursorPos(LPPOINT lpPoint)
real_SetCursorPos(realpt.x - diffx, realpt.y - diffy);
if(g_ddraw->adjmouse)
if (g_ddraw->adjmouse)
{
g_ddraw->cursor.x = (DWORD)(pt.x * g_ddraw->render.unscale_w);
g_ddraw->cursor.y = (DWORD)(pt.y * g_ddraw->render.unscale_h);
@ -77,7 +77,7 @@ BOOL WINAPI fake_GetCursorPos(LPPOINT lpPoint)
diffx = g_ddraw->cursor.x - g_ddraw->upscale_hack_width;
g_ddraw->cursor.x = g_ddraw->upscale_hack_width;
}
if (g_ddraw->cursor.y > g_ddraw->upscale_hack_height)
{
diffy = g_ddraw->cursor.y - g_ddraw->upscale_hack_height;
@ -94,13 +94,13 @@ BOOL WINAPI fake_GetCursorPos(LPPOINT lpPoint)
lpPoint->x = g_ddraw->cursor.x;
lpPoint->y = g_ddraw->cursor.y;
}
return TRUE;
}
BOOL WINAPI fake_ClipCursor(const RECT *lpRect)
BOOL WINAPI fake_ClipCursor(const RECT* lpRect)
{
if(lpRect)
if (lpRect)
{
/* hack for 640x480 mode */
if (lpRect->bottom == 400 && g_ddraw && g_ddraw->height == 480)
@ -122,16 +122,16 @@ int WINAPI fake_ShowCursor(BOOL bShow)
HCURSOR WINAPI fake_SetCursor(HCURSOR hCursor)
{
if (g_ddraw && !g_ddraw->handlemouse && (g_ddraw->locked || g_ddraw->devmode))
return real_SetCursor(hCursor);
return real_SetCursor(hCursor);
return NULL;
}
BOOL WINAPI fake_GetWindowRect(HWND hWnd, LPRECT lpRect)
{
if (lpRect &&
g_ddraw &&
g_ddraw->hwnd &&
if (lpRect &&
g_ddraw &&
g_ddraw->hwnd &&
(g_hook_method != 2 || g_ddraw->renderer == gdi_render_main))
{
if (g_ddraw->hwnd == hWnd)
@ -161,9 +161,9 @@ BOOL WINAPI fake_GetWindowRect(HWND hWnd, LPRECT lpRect)
BOOL WINAPI fake_GetClientRect(HWND hWnd, LPRECT lpRect)
{
if (lpRect &&
g_ddraw &&
g_ddraw->hwnd == hWnd &&
if (lpRect &&
g_ddraw &&
g_ddraw->hwnd == hWnd &&
(g_hook_method != 2 || g_ddraw->renderer == gdi_render_main))
{
lpRect->bottom = g_ddraw->height;
@ -315,7 +315,7 @@ LRESULT WINAPI fake_SendMessageA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lPar
if (result && g_ddraw && Msg == CB_GETDROPPEDCONTROLRECT)
{
RECT *rc = (RECT *)lParam;
RECT* rc = (RECT*)lParam;
if (rc)
real_MapWindowPoints(HWND_DESKTOP, g_ddraw->hwnd, (LPPOINT)rc, 2);
}
@ -410,9 +410,9 @@ HHOOK WINAPI fake_SetWindowsHookExA(int idHook, HOOKPROC lpfn, HINSTANCE hmod, D
int WINAPI fake_GetDeviceCaps(HDC hdc, int index)
{
if (g_ddraw &&
g_ddraw->bpp &&
index == BITSPIXEL &&
if (g_ddraw &&
g_ddraw->bpp &&
index == BITSPIXEL &&
(g_hook_method != 2 || g_ddraw->renderer == gdi_render_main))
{
return g_ddraw->bpp;

1317
src/wndproc.c
View file

File diff suppressed because it is too large Load diff