backup/cnc-ddraw
1
0
Fork 0
mirror of https://github.com/FunkyFr3sh/cnc-ddraw.git synced 2025-03-15 06:04:49 +01:00
Code Issues Projects Releases Activity

Remove legacy ddraw code

Browse Source
This commit is contained in:
Toni Spets 2010-11-12 19:50:00 +02:00
parent 3308661c9f
commit 34df9fe79a
6 changed files with 77 additions and 359 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -1,5 +1,5 @@
all:
i586-mingw32msvc-gcc -Wall -Wl,--enable-stdcall-fixup -shared -s -o ddraw.dll main.c mouse.c palette.c surface.c clipper.c render_ddraw.c render_opengl.c ddraw.def -lgdi32 -lopengl32
i586-mingw32msvc-gcc -Wall -Wl,--enable-stdcall-fixup -shared -s -o ddraw.dll main.c mouse.c palette.c surface.c clipper.c render.c ddraw.def -lgdi32 -lopengl32
clean:
rm -f ddraw.dll

102
main.c
View File

@ -31,7 +31,6 @@ void mouse_unlock();
IDirectDrawImpl *ddraw = NULL;
extern struct render render_ddraw;
extern struct render render_opengl;
HRESULT __stdcall ddraw_Compact(IDirectDrawImpl *This)
@ -140,7 +139,12 @@ HRESULT __stdcall ddraw_Initialize(IDirectDrawImpl *This, GUID *a)
HRESULT __stdcall ddraw_RestoreDisplayMode(IDirectDrawImpl *This)
{
printf("DirectDraw::RestoreDisplayMode(This=%p)\n", This);
return ddraw->render->RestoreDisplayMode();
if(!ddraw->windowed)
{
This->mode.dmFields = DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT|DM_DISPLAYFLAGS|DM_DISPLAYFREQUENCY|DM_POSITION;
ChangeDisplaySettings(&This->mode, 0);
}
return DD_OK;
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
@ -199,17 +203,17 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
case WM_MOUSEMOVE:
if(ddraw->locked)
{
if(LOWORD(lParam) != ddraw->render->width / 2 || HIWORD(lParam) != ddraw->render->height / 2)
if(LOWORD(lParam) != ddraw->render.width / 2 || HIWORD(lParam) != ddraw->render.height / 2)
{
if(ddraw->adjmouse)
{
ddraw->cursor.x += (LOWORD(lParam) - ddraw->render->width / 2) * ((float)ddraw->width / ddraw->render->width);
ddraw->cursor.y += (HIWORD(lParam) - ddraw->render->height / 2) * ((float)ddraw->height / ddraw->render->height);
ddraw->cursor.x += (LOWORD(lParam) - ddraw->render.width / 2) * ((float)ddraw->width / ddraw->render.width);
ddraw->cursor.y += (HIWORD(lParam) - ddraw->render.height / 2) * ((float)ddraw->height / ddraw->render.height);
}
else
{
ddraw->cursor.x += LOWORD(lParam) - ddraw->render->width / 2;
ddraw->cursor.y += HIWORD(lParam) - ddraw->render->height / 2;
ddraw->cursor.x += LOWORD(lParam) - ddraw->render.width / 2;
ddraw->cursor.y += HIWORD(lParam) - ddraw->render.height / 2;
}
if(ddraw->cursor.x < 0) ddraw->cursor.x = 0;
@ -279,8 +283,6 @@ HRESULT __stdcall ddraw_SetCooperativeLevel(IDirectDrawImpl *This, HWND hWnd, DW
HRESULT __stdcall ddraw_SetDisplayMode(IDirectDrawImpl *This, DWORD width, DWORD height, DWORD bpp)
{
DEVMODE mode;
printf("DirectDraw::SetDisplayMode(This=%p, width=%d, height=%d, bpp=%d)\n", This, (unsigned int)width, (unsigned int)height, (unsigned int)bpp);
/* currently we only support 8 bit modes */
@ -289,10 +291,10 @@ HRESULT __stdcall ddraw_SetDisplayMode(IDirectDrawImpl *This, DWORD width, DWORD
return DDERR_INVALIDMODE;
}
mode.dmSize = sizeof(DEVMODE);
mode.dmDriverExtra = 0;
This->mode.dmSize = sizeof(DEVMODE);
This->mode.dmDriverExtra = 0;
if(EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &mode) == FALSE)
if(EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &This->mode) == FALSE)
{
/* not expected */
return DDERR_UNSUPPORTED;
@ -301,41 +303,51 @@ HRESULT __stdcall ddraw_SetDisplayMode(IDirectDrawImpl *This, DWORD width, DWORD
This->width = width;
This->height = height;
This->bpp = bpp;
This->freq = mode.dmDisplayFrequency;
if(This->render->width < This->width)
if(This->render.width < This->width)
{
This->render->width = This->width;
This->render.width = This->width;
}
if(This->render->height < This->height)
if(This->render.height < This->height)
{
This->render->height = This->height;
This->render.height = This->height;
}
mouse_unlock();
if(!This->windowed)
{
mouse_lock();
}
if(This->windowed)
{
SetWindowLong(This->hWnd, GWL_STYLE, GetWindowLong(This->hWnd, GWL_STYLE) | WS_CAPTION | WS_BORDER);
/* center the window with correct dimensions */
int x = (mode.dmPelsWidth / 2) - (This->render->width / 2);
int y = (mode.dmPelsHeight / 2) - (This->render->height / 2);
RECT dst = { x, y, This->render->width+x, This->render->height+y };
int x = (This->mode.dmPelsWidth / 2) - (This->render.width / 2);
int y = (This->mode.dmPelsHeight / 2) - (This->render.height / 2);
RECT dst = { x, y, This->render.width+x, This->render.height+y };
AdjustWindowRect(&dst, GetWindowLong(This->hWnd, GWL_STYLE), FALSE);
SetWindowPos(This->hWnd, HWND_NOTOPMOST, dst.left, dst.top, (dst.right - dst.left), (dst.bottom - dst.top), SWP_SHOWWINDOW);
}
else
{
SetWindowPos(This->hWnd, HWND_TOPMOST, 0, 0, This->render->width, This->render->height, SWP_SHOWWINDOW);
SetWindowPos(This->hWnd, HWND_TOPMOST, 0, 0, This->render.width, This->render.height, SWP_SHOWWINDOW);
SendMessage(This->hWnd, WM_WINDOWPOSCHANGED, 0, 0);
mouse_lock();
memset(&This->render.mode, 0, sizeof(DEVMODE));
This->render.mode.dmSize = sizeof(DEVMODE);
This->render.mode.dmFields = DM_PELSWIDTH|DM_PELSHEIGHT;
This->render.mode.dmPelsWidth = This->render.width;
This->render.mode.dmPelsHeight = This->render.height;
if(This->render.bpp)
{
This->render.mode.dmFields |= DM_BITSPERPEL;
This->render.mode.dmBitsPerPel = This->render.bpp;
}
return ChangeDisplaySettings(&This->render.mode, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL ? DD_OK : DDERR_INVALIDMODE;
}
return ddraw->render->SetDisplayMode(width, height);
return DD_OK;
}
HRESULT __stdcall ddraw_WaitForVerticalBlank(IDirectDrawImpl *This, DWORD a, HANDLE b)
@ -343,7 +355,7 @@ HRESULT __stdcall ddraw_WaitForVerticalBlank(IDirectDrawImpl *This, DWORD a, HAN
#if _DEBUG
printf("DirectDraw::WaitForVerticalBlank(This=%p, ...)\n", This);
#endif
WaitForSingleObject(ddraw->render->ev, INFINITE);
WaitForSingleObject(This->render.ev, INFINITE);
return DD_OK;
}
@ -483,16 +495,6 @@ HRESULT WINAPI DirectDrawCreate(GUID FAR* lpGUID, LPDIRECTDRAW FAR* lplpDD, IUnk
fclose(fh);
}
GetPrivateProfileStringA("ddraw", "renderer", "opengl", tmp, sizeof(tmp), ini_path);
if(tolower(tmp[0]) == 'd')
{
This->render = &render_ddraw;
}
else
{
This->render = &render_opengl;
}
GetPrivateProfileStringA("ddraw", "windowed", "TRUE", tmp, sizeof(tmp), ini_path);
if(tolower(tmp[0]) == 'n' || tolower(tmp[0]) == 'f' || tmp[0] == '0')
{
@ -503,32 +505,32 @@ HRESULT WINAPI DirectDrawCreate(GUID FAR* lpGUID, LPDIRECTDRAW FAR* lplpDD, IUnk
This->windowed = TRUE;
}
This->render->maxfps = GetPrivateProfileIntA("ddraw", "maxfps", 120, ini_path);
This->render->width = GetPrivateProfileIntA("ddraw", "width", 640, ini_path);
if(This->render->width < 640)
This->render.maxfps = GetPrivateProfileIntA("ddraw", "maxfps", 120, ini_path);
This->render.width = GetPrivateProfileIntA("ddraw", "width", 640, ini_path);
if(This->render.width < 640)
{
This->render->width = 640;
This->render.width = 640;
}
This->render->height = GetPrivateProfileIntA("ddraw", "height", 400, ini_path);
if(This->render->height < 400)
This->render.height = GetPrivateProfileIntA("ddraw", "height", 400, ini_path);
if(This->render.height < 400)
{
This->render->height = 400;
This->render.height = 400;
}
This->render->bpp = GetPrivateProfileIntA("ddraw", "bpp", 32, ini_path);
if(This->render->bpp != 16 && This->render->bpp != 24 && This->render->bpp != 32)
This->render.bpp = GetPrivateProfileIntA("ddraw", "bpp", 32, ini_path);
if(This->render.bpp != 16 && This->render.bpp != 24 && This->render.bpp != 32)
{
This->render->bpp = 0;
This->render.bpp = 0;
}
GetPrivateProfileStringA("ddraw", "filter", tmp, tmp, sizeof(tmp), ini_path);
if(tolower(tmp[0]) == 'l' || tolower(tmp[3]) == 'l')
{
This->render->filter = 1;
This->render.filter = 1;
}
else
{
This->render->filter = 0;
This->render.filter = 0;
}
GetPrivateProfileStringA("ddraw", "adjmouse", "TRUE", tmp, sizeof(tmp), ini_path);
if(tolower(tmp[0]) == 'y' || tolower(tmp[0]) == 't' || tmp[0] == '1')
@ -540,8 +542,6 @@ HRESULT WINAPI DirectDrawCreate(GUID FAR* lpGUID, LPDIRECTDRAW FAR* lplpDD, IUnk
This->adjmouse = FALSE;
}
This->render->Initialize();
This->Ref = 0;
ddraw_AddRef(This);

12
main.h
View File

@ -38,17 +38,13 @@ typedef struct IDirectDrawImpl
DWORD bpp;
DWORD freq;
BOOL windowed;
DEVMODE mode;
/* real export from system32\ddraw.dll */
HRESULT WINAPI (*DirectDrawCreate)(GUID FAR*, LPDIRECTDRAW FAR*, IUnknown FAR*);
struct render
struct
{
LPTHREAD_START_ROUTINE (*main)(void *);
HRESULT WINAPI (*Initialize)(void);
HRESULT WINAPI (*SetDisplayMode)(DWORD width, DWORD height);
HRESULT WINAPI (*RestoreDisplayMode)(void);
int maxfps;
int width;
int height;
@ -58,9 +54,9 @@ typedef struct IDirectDrawImpl
HANDLE thread;
BOOL run;
HANDLE ev;
DEVMODE mode;
/* rest is private */
} *render;
} render;
HWND hWnd;
LRESULT CALLBACK (*WndProc)(HWND, UINT, WPARAM, LPARAM);

113
render_opengl.c → render.c
View File

@ -20,90 +20,7 @@
#include "main.h"
#include "surface.h"
struct render_opengl_impl
{
DWORD WINAPI (*main)(IDirectDrawSurfaceImpl *surface);
HRESULT WINAPI (*Initialize)(void);
HRESULT WINAPI (*SetDisplayMode)(DWORD width, DWORD height);
HRESULT WINAPI (*RestoreDisplayMode)(void);
int maxfps;
int width;
int height;
int bpp;
int filter;
HANDLE thread;
BOOL run;
HANDLE ev;
DEVMODE restore;
};
DWORD WINAPI render_opengl_main(IDirectDrawSurfaceImpl *surface);
HRESULT WINAPI render_opengl_Initialize();
HRESULT WINAPI render_opengl_SetDisplayMode(DWORD width, DWORD height);
HRESULT WINAPI render_opengl_RestoreDisplayMode(void);
struct render_opengl_impl render_opengl =
{
render_opengl_main,
render_opengl_Initialize,
render_opengl_SetDisplayMode,
render_opengl_RestoreDisplayMode,
0,
0,
0,
0,
0,
NULL,
TRUE,
NULL
};
HRESULT WINAPI render_opengl_Initialize()
{
return DD_OK;
}
HRESULT WINAPI render_opengl_SetDisplayMode(DWORD width, DWORD height)
{
DEVMODE mode;
EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &render_opengl.restore);
if(ddraw->windowed)
{
return DD_OK;
}
memset(&mode, 0, sizeof(DEVMODE));
mode.dmSize = sizeof(DEVMODE);
mode.dmFields = DM_PELSWIDTH|DM_PELSHEIGHT;
mode.dmPelsWidth = render_opengl.width;
mode.dmPelsHeight = render_opengl.height;
if(render_opengl.bpp)
{
mode.dmFields |= DM_BITSPERPEL;
mode.dmBitsPerPel = render_opengl.bpp;
}
return ChangeDisplaySettings(&mode, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL ? DD_OK : DDERR_INVALIDMODE;
}
HRESULT WINAPI render_opengl_RestoreDisplayMode(void)
{
if(!ddraw->windowed)
{
render_opengl.restore.dmFields = DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT|DM_DISPLAYFLAGS|DM_DISPLAYFREQUENCY|DM_POSITION;
ChangeDisplaySettings(&render_opengl.restore, 0);
}
return DD_OK;
}
DWORD WINAPI render_opengl_main(IDirectDrawSurfaceImpl *surface)
DWORD WINAPI render_main(IDirectDrawSurfaceImpl *surface)
{
int i,j;
PIXELFORMATDESCRIPTOR pfd;
@ -123,7 +40,7 @@ DWORD WINAPI render_opengl_main(IDirectDrawSurfaceImpl *surface)
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = render_opengl.bpp ? render_opengl.bpp : render_opengl.restore.dmBitsPerPel;
pfd.cColorBits = ddraw->render.bpp ? ddraw->render.bpp : ddraw->mode.dmBitsPerPel;
pfd.iLayerType = PFD_MAIN_PLANE;
SetPixelFormat( hDC, ChoosePixelFormat( hDC, &pfd ), &pfd );
@ -134,22 +51,22 @@ DWORD WINAPI render_opengl_main(IDirectDrawSurfaceImpl *surface)
DWORD tick_end;
DWORD frame_len;
if(render_opengl.maxfps < 0)
if(ddraw->render.maxfps < 0)
{
render_opengl.maxfps = ddraw->freq;
ddraw->render.maxfps = ddraw->freq;
}
if(render_opengl.maxfps > 0)
if(ddraw->render.maxfps > 0)
{
frame_len = 1000.0f / render_opengl.maxfps;
frame_len = 1000.0f / ddraw->render.maxfps;
}
render_opengl.ev = CreateEvent(NULL, TRUE, FALSE, NULL);
ddraw->render.ev = CreateEvent(NULL, TRUE, FALSE, NULL);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tex_width, tex_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex);
glViewport(0, 0, render_opengl.width, render_opengl.height);
glViewport(0, 0, ddraw->render.width, ddraw->render.height);
if(render_opengl.filter)
if(ddraw->render.filter)
{
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
@ -162,11 +79,11 @@ DWORD WINAPI render_opengl_main(IDirectDrawSurfaceImpl *surface)
glEnable(GL_TEXTURE_2D);
while(render_opengl.run)
while(ddraw->render.run)
{
ResetEvent(render_opengl.ev);
ResetEvent(ddraw->render.ev);
if(render_opengl.maxfps > 0)
if(ddraw->render.maxfps > 0)
{
tick_start = GetTickCount();
}
@ -194,7 +111,7 @@ DWORD WINAPI render_opengl_main(IDirectDrawSurfaceImpl *surface)
SwapBuffers(hDC);
if(render_opengl.maxfps > 0)
if(ddraw->render.maxfps > 0)
{
tick_end = GetTickCount();
@ -204,10 +121,10 @@ DWORD WINAPI render_opengl_main(IDirectDrawSurfaceImpl *surface)
}
}
SetEvent(render_opengl.ev);
SetEvent(ddraw->render.ev);
}
CloseHandle(render_opengl.ev);
CloseHandle(ddraw->render.ev);
free(tex);

197
render_ddraw.c
View File

@ -1,197 +0,0 @@
/*
* Copyright (c) 2010 Toni Spets <toni.spets@iki.fi>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <windows.h>
#include <stdio.h>
#include "main.h"
#include "surface.h"
struct render_ddraw_impl
{
DWORD WINAPI (*main)(IDirectDrawSurfaceImpl *surface);
HRESULT WINAPI (*Initialize)(void);
HRESULT WINAPI (*SetDisplayMode)(DWORD width, DWORD height);
HRESULT WINAPI (*RestoreDisplayMode)(void);
int maxfps;
int width;
int height;
int bpp;
int filter;
HANDLE thread;
BOOL run;
HANDLE ev;
LPDIRECTDRAW ddraw;
};
DWORD WINAPI render_ddraw_main(IDirectDrawSurfaceImpl *surface);
HRESULT WINAPI render_ddraw_Initialize();
HRESULT WINAPI render_ddraw_SetDisplayMode(DWORD width, DWORD height);
HRESULT WINAPI render_ddraw_RestoreDisplayMode(void);
struct render_ddraw_impl render_ddraw =
{
render_ddraw_main,
render_ddraw_Initialize,
render_ddraw_SetDisplayMode,
render_ddraw_RestoreDisplayMode,
0,
0,
0,
0,
0,
NULL,
TRUE,
NULL,
NULL
};
HRESULT WINAPI render_ddraw_Initialize()
{
if(ddraw->DirectDrawCreate(NULL, &render_ddraw.ddraw, NULL) != DD_OK)
{
return DDERR_GENERIC;
}
return DD_OK;
}
HRESULT WINAPI render_ddraw_SetDisplayMode(DWORD width, DWORD height)
{
if(ddraw->windowed == FALSE)
{
return IDirectDraw_SetDisplayMode(render_ddraw.ddraw, width, height, 24);
}
return DD_OK;
}
HRESULT WINAPI render_ddraw_RestoreDisplayMode(void)
{
if(ddraw->windowed == FALSE)
{
return IDirectDraw_RestoreDisplayMode(render_ddraw.ddraw);
}
return DD_OK;
}
DWORD WINAPI render_ddraw_main(IDirectDrawSurfaceImpl *surface)
{
int i,j;
DDSURFACEDESC ddsd;
LPDIRECTDRAWSURFACE primary;
LPDIRECTDRAWCLIPPER clipper;
DWORD width;
if(render_ddraw.ddraw == NULL)
{
return FALSE;
}
render_ddraw.run = TRUE;
if(ddraw->windowed)
{
IDirectDraw_SetCooperativeLevel(render_ddraw.ddraw, ddraw->hWnd, DDSCL_NORMAL);
}
else
{
IDirectDraw_SetCooperativeLevel(render_ddraw.ddraw, ddraw->hWnd, DDSCL_EXCLUSIVE|DDSCL_FULLSCREEN);
}
memset(&ddsd, 0, sizeof(DDSURFACEDESC));
ddsd.dwSize = sizeof(DDSURFACEDESC);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
IDirectDraw_CreateSurface(render_ddraw.ddraw, &ddsd, &primary, NULL);
memset(&ddsd, 0, sizeof(DDSURFACEDESC));
ddsd.dwSize = sizeof(DDSURFACEDESC);
IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd);
width = ddsd.dwWidth * ddsd.lPitch / (ddsd.dwWidth * ddsd.ddpfPixelFormat.dwRGBBitCount / 8);
IDirectDraw_CreateClipper(render_ddraw.ddraw, 0, &clipper, NULL);
IDirectDrawClipper_SetHWnd(clipper, 0, ddraw->hWnd);
IDirectDrawSurface_SetClipper(primary, clipper);
DWORD tick_start;
DWORD tick_end;
DWORD frame_len;
if(render_ddraw.maxfps < 0)
{
render_ddraw.maxfps = ddraw->freq;
}
if(render_ddraw.maxfps > 0)
{
frame_len = 1000.0f / render_ddraw.maxfps;
}
render_ddraw.ev = CreateEvent(NULL, TRUE, FALSE, NULL);
while(render_ddraw.run)
{
ResetEvent(render_ddraw.ev);
if(render_ddraw.maxfps > 0)
{
tick_start = GetTickCount();
}
IDirectDrawSurface_Lock(primary, NULL, &ddsd, DDLOCK_WRITEONLY|DDLOCK_WAIT, NULL);
if(surface->palette)
{
for(i=0; i<surface->height; i++)
{
for(j=0; j<surface->width; j++)
{
((int *)ddsd.lpSurface)[(i+ddraw->winpos.y)*width+(j+ddraw->winpos.x)] = surface->palette->data_rgb[((unsigned char *)surface->surface)[i*surface->lPitch + j*surface->lXPitch]];
}
}
}
IDirectDrawSurface_Unlock(primary, NULL);
if(render_ddraw.maxfps > 0)
{
tick_end = GetTickCount();
if(tick_end - tick_start < frame_len)
{
Sleep( frame_len - (tick_end - tick_start) );
}
}
SetEvent(render_ddraw.ev);
}
CloseHandle(render_ddraw.ev);
IDirectDrawClipper_Release(clipper);
IDirectDrawSurface_Release(primary);
IDirectDraw_Release(render_ddraw.ddraw);
return 0;
}

10
surface.c
View File

@ -20,6 +20,7 @@
#include "main.h"
#include "surface.h"
DWORD WINAPI render_main(IDirectDrawSurfaceImpl *);
IDirectDrawSurfaceImpl *ddraw_primary = NULL;
void dump_ddscaps(DWORD dwCaps);
@ -48,8 +49,8 @@ ULONG __stdcall ddraw_surface_Release(IDirectDrawSurfaceImpl *This)
{
if(This->caps == DDSCAPS_PRIMARYSURFACE)
{
ddraw->render->run = FALSE;
WaitForSingleObject(ddraw->render->thread, INFINITE);
ddraw->render.run = FALSE;
WaitForSingleObject(ddraw->render.thread, INFINITE);
}
if(This->surface)
{
@ -96,7 +97,7 @@ HRESULT __stdcall ddraw_surface_Blt(IDirectDrawSurfaceImpl *This, LPRECT lpDestR
if(This->caps & DDSCAPS_PRIMARYSURFACE)
{
WaitForSingleObject(ddraw->render->ev, INFINITE);
WaitForSingleObject(ddraw->render.ev, INFINITE);
}
if(Source)
@ -446,7 +447,8 @@ HRESULT __stdcall ddraw_CreateSurface(IDirectDrawImpl *This, LPDDSURFACEDESC lpD
if(Surface->caps & DDSCAPS_PRIMARYSURFACE)
{
This->render->thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)This->render->main, (void *)Surface, 0, NULL);
This->render.run = TRUE;
This->render.thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)render_main, (void *)Surface, 0, NULL);
}
return DD_OK;