2020-10-13 09:20:52 +02:00
|
|
|
#include <windows.h>
|
2023-12-29 01:40:49 +01:00
|
|
|
#include <math.h>
|
2021-06-14 09:57:26 +02:00
|
|
|
#include "ddraw.h"
|
2020-10-15 05:13:37 +02:00
|
|
|
#include "IDirectDraw.h"
|
2020-10-13 09:20:52 +02:00
|
|
|
#include "dd.h"
|
|
|
|
#include "hook.h"
|
|
|
|
#include "config.h"
|
|
|
|
#include "mouse.h"
|
|
|
|
#include "wndproc.h"
|
|
|
|
#include "render_d3d9.h"
|
|
|
|
#include "render_gdi.h"
|
|
|
|
#include "render_ogl.h"
|
2021-02-02 18:15:25 +01:00
|
|
|
#include "fps_limiter.h"
|
2020-10-13 09:20:52 +02:00
|
|
|
#include "debug.h"
|
|
|
|
#include "utils.h"
|
2022-09-13 09:34:48 +02:00
|
|
|
#include "blt.h"
|
2024-05-04 07:19:02 +02:00
|
|
|
#include "versionhelpers.h"
|
2020-10-13 09:20:52 +02:00
|
|
|
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
CNCDDRAW g_ddraw;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2021-06-11 20:30:43 +02:00
|
|
|
HRESULT dd_EnumDisplayModes(
|
|
|
|
DWORD dwFlags,
|
2021-06-14 09:57:26 +02:00
|
|
|
LPDDSURFACEDESC lpDDSurfaceDesc,
|
2021-06-11 20:30:43 +02:00
|
|
|
LPVOID lpContext,
|
2021-06-14 09:57:26 +02:00
|
|
|
LPDDENUMMODESCALLBACK lpEnumModesCallback)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2022-09-30 14:16:30 +02:00
|
|
|
dbg_dump_edm_flags(dwFlags);
|
|
|
|
|
2023-08-11 12:58:48 +02:00
|
|
|
DWORD bpp_filter = 0;
|
|
|
|
|
|
|
|
if (lpDDSurfaceDesc)
|
|
|
|
{
|
|
|
|
dbg_dump_dds_flags(lpDDSurfaceDesc->dwFlags);
|
|
|
|
dbg_dump_dds_caps(lpDDSurfaceDesc->ddsCaps.dwCaps);
|
|
|
|
|
|
|
|
if (lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT)
|
|
|
|
{
|
|
|
|
TRACE(" ddpfPixelFormat.dwRGBBitCount=%u\n", lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount);
|
|
|
|
|
|
|
|
switch (lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount)
|
|
|
|
{
|
|
|
|
case 8:
|
|
|
|
case 16:
|
|
|
|
case 32:
|
|
|
|
bpp_filter = lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
DWORD i = 0;
|
2022-10-11 23:13:04 +02:00
|
|
|
DWORD res_count = 0;
|
2021-06-11 20:30:43 +02:00
|
|
|
DDSURFACEDESC2 s;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2021-06-11 20:30:43 +02:00
|
|
|
/* Some games crash when you feed them with too many resolutions so we have to keep the list short */
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2022-09-05 03:48:24 +02:00
|
|
|
DWORD max_w = 0;
|
|
|
|
DWORD max_h = 0;
|
|
|
|
DEVMODE reg_m;
|
|
|
|
|
|
|
|
memset(®_m, 0, sizeof(DEVMODE));
|
|
|
|
reg_m.dmSize = sizeof(DEVMODE);
|
|
|
|
|
2024-06-10 00:05:04 +02:00
|
|
|
if (real_EnumDisplaySettingsA(NULL, ENUM_REGISTRY_SETTINGS, ®_m))
|
2022-09-05 03:48:24 +02:00
|
|
|
{
|
|
|
|
max_w = reg_m.dmPelsWidth;
|
|
|
|
max_h = reg_m.dmPelsHeight;
|
2024-03-22 04:36:30 +01:00
|
|
|
|
|
|
|
TRACE(" max_w=%u, max_h=%u\n", reg_m.dmPelsWidth, reg_m.dmPelsHeight);
|
2022-09-05 03:48:24 +02:00
|
|
|
}
|
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.stronghold_hack && max_w && (max_w % 8))
|
2023-08-07 10:15:52 +02:00
|
|
|
{
|
|
|
|
while (--max_w % 8);
|
|
|
|
}
|
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
BOOL rlf = g_config.resolutions == RESLIST_FULL;
|
|
|
|
BOOL rlm = g_config.resolutions == RESLIST_MINI;
|
2023-08-10 17:28:09 +02:00
|
|
|
|
2021-06-10 03:48:26 +02:00
|
|
|
SIZE resolutions[] =
|
|
|
|
{
|
|
|
|
{ 320, 200 },
|
|
|
|
{ 320, 240 },
|
2023-08-21 17:56:01 +02:00
|
|
|
{ rlm ? 0 : 512, rlm ? 0 : 384 },
|
2021-06-10 03:48:26 +02:00
|
|
|
{ 640, 400 },
|
|
|
|
{ 640, 480 },
|
|
|
|
{ 800, 600 },
|
|
|
|
{ 1024, 768 },
|
|
|
|
{ 1280, 1024 },
|
2023-08-21 17:56:01 +02:00
|
|
|
{ rlm ? 0 : 1600, rlm ? 0 : 1200 },
|
2023-08-18 11:18:15 +02:00
|
|
|
{ 1280, 720 },
|
2023-08-10 17:28:09 +02:00
|
|
|
{ rlf ? 1024 : 0, rlf ? 600 : 0 },
|
|
|
|
/* 4:3 */
|
|
|
|
{ rlf ? 1280 : 0, rlf ? 960 : 0 },
|
|
|
|
{ rlf ? 2048 : 0, rlf ? 1536 : 0 },
|
|
|
|
/* 16:10 */
|
|
|
|
{ rlf ? 960 : 0, rlf ? 600 : 0 },
|
|
|
|
{ rlf ? 1440 : 0, rlf ? 900 : 0 },
|
|
|
|
{ rlf ? 1680 : 0, rlf ? 1050 : 0 },
|
|
|
|
{ rlf ? 1920 : 0, rlf ? 1200 : 0 },
|
|
|
|
{ rlf ? 2560 : 0, rlf ? 1600 : 0 },
|
|
|
|
/* 16:9 */
|
|
|
|
{ rlf ? 960 : 0, rlf ? 540 : 0 },
|
|
|
|
{ rlf ? 1360 : 0, rlf ? 768 : 0 },
|
|
|
|
{ rlf ? 1600 : 0, rlf ? 900 : 0 },
|
|
|
|
{ rlf ? 1920 : 0, rlf ? 1080 : 0 },
|
|
|
|
{ rlf ? 2560 : 0, rlf ? 1440 : 0 },
|
|
|
|
/* 21:9 */
|
2023-08-17 13:55:30 +02:00
|
|
|
{ rlf ? 1280 : 0, rlf ? 540 : 0 },
|
2023-08-10 17:28:09 +02:00
|
|
|
{ rlf ? 1720 : 0, rlf ? 720 : 0 },
|
|
|
|
{ rlf ? 2560 : 0, rlf ? 1080 : 0 },
|
2023-08-19 18:19:30 +02:00
|
|
|
/* Inject custom resolution */
|
2023-09-22 00:38:42 +02:00
|
|
|
{ g_config.custom_width, g_config.custom_height },
|
2022-09-05 03:48:24 +02:00
|
|
|
{ max_w, max_h },
|
2021-06-10 03:48:26 +02:00
|
|
|
};
|
2022-09-05 03:48:24 +02:00
|
|
|
|
|
|
|
for (int x = 0; x < (sizeof(resolutions) / sizeof(resolutions[0])) - 1; x++)
|
|
|
|
{
|
|
|
|
if (resolutions[x].cx == max_w && resolutions[x].cy == max_h)
|
|
|
|
{
|
|
|
|
resolutions[x].cx = 0;
|
|
|
|
resolutions[x].cy = 0;
|
|
|
|
}
|
|
|
|
}
|
2021-06-10 03:48:26 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if ((g_ddraw.bpp && g_config.resolutions == RESLIST_NORMAL) || g_config.resolutions == RESLIST_FULL)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
TRACE(" g_ddraw.bpp=%u\n", g_ddraw.bpp);
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2021-06-10 03:48:26 +02:00
|
|
|
/* set up some filters to keep the list short */
|
2020-10-13 09:20:52 +02:00
|
|
|
DWORD refresh_rate = 0;
|
|
|
|
DWORD bpp = 0;
|
|
|
|
DWORD flags = 99998;
|
|
|
|
DWORD fixed_output = 99998;
|
|
|
|
DEVMODE m;
|
2020-10-13 21:58:04 +02:00
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
memset(&m, 0, sizeof(DEVMODE));
|
|
|
|
m.dmSize = sizeof(DEVMODE);
|
|
|
|
|
2024-06-10 00:05:04 +02:00
|
|
|
while (real_EnumDisplaySettingsA(NULL, i, &m))
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2022-02-15 10:36:41 +01:00
|
|
|
TRACE_EXT(
|
|
|
|
" %u: %ux%u@%u %u bpp | flags=0x%08X, FO=%u\n",
|
|
|
|
i,
|
|
|
|
m.dmPelsWidth,
|
|
|
|
m.dmPelsHeight,
|
|
|
|
m.dmDisplayFrequency,
|
|
|
|
m.dmBitsPerPel,
|
|
|
|
m.dmDisplayFlags,
|
|
|
|
m.dmDisplayFixedOutput);
|
|
|
|
|
2023-09-24 19:51:50 +02:00
|
|
|
if (refresh_rate != 60 && refresh_rate < 120 && m.dmDisplayFrequency >= 50)
|
|
|
|
refresh_rate = m.dmDisplayFrequency;
|
|
|
|
|
|
|
|
/* Some setups with 144hz monitors only contain a very few 60hz resolutions so we can't use 60hz as filter */
|
|
|
|
if (m.dmDisplayFrequency > refresh_rate && m.dmDisplayFrequency >= 120)
|
2020-10-13 09:20:52 +02:00
|
|
|
refresh_rate = m.dmDisplayFrequency;
|
|
|
|
|
|
|
|
if (bpp != 32 && m.dmBitsPerPel >= 16)
|
|
|
|
bpp = m.dmBitsPerPel;
|
|
|
|
|
|
|
|
if (flags != 0)
|
|
|
|
flags = m.dmDisplayFlags;
|
|
|
|
|
|
|
|
if (fixed_output != DMDFO_DEFAULT)
|
|
|
|
fixed_output = m.dmDisplayFixedOutput;
|
|
|
|
|
|
|
|
memset(&m, 0, sizeof(DEVMODE));
|
|
|
|
m.dmSize = sizeof(DEVMODE);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&m, 0, sizeof(DEVMODE));
|
|
|
|
m.dmSize = sizeof(DEVMODE);
|
|
|
|
i = 0;
|
2020-10-13 11:29:52 +02:00
|
|
|
|
2023-11-17 02:26:19 +01:00
|
|
|
BOOL custom_res_injected = FALSE;
|
|
|
|
|
2024-06-10 00:05:04 +02:00
|
|
|
while (real_EnumDisplaySettingsA(NULL, i, &m))
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
|
|
|
if (refresh_rate == m.dmDisplayFrequency &&
|
|
|
|
bpp == m.dmBitsPerPel &&
|
|
|
|
flags == m.dmDisplayFlags &&
|
|
|
|
fixed_output == m.dmDisplayFixedOutput)
|
|
|
|
{
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.stronghold_hack && m.dmPelsWidth && (m.dmPelsWidth % 8))
|
2023-08-10 17:24:27 +02:00
|
|
|
{
|
|
|
|
while (--m.dmPelsWidth % 8);
|
|
|
|
}
|
|
|
|
|
2023-11-17 02:26:19 +01:00
|
|
|
if (!custom_res_injected && g_config.custom_width && g_config.custom_height)
|
2023-09-14 01:06:37 +02:00
|
|
|
{
|
2023-09-22 00:38:42 +02:00
|
|
|
m.dmPelsWidth = g_config.custom_width;
|
|
|
|
m.dmPelsHeight = g_config.custom_height;
|
2023-11-17 02:26:19 +01:00
|
|
|
custom_res_injected = TRUE;
|
2023-09-14 01:06:37 +02:00
|
|
|
}
|
|
|
|
|
2023-08-10 14:41:42 +02:00
|
|
|
TRACE(
|
2021-06-11 20:30:43 +02:00
|
|
|
" %u: %ux%u@%u %u bpp\n",
|
|
|
|
i,
|
|
|
|
m.dmPelsWidth,
|
|
|
|
m.dmPelsHeight,
|
|
|
|
m.dmDisplayFrequency,
|
|
|
|
m.dmBitsPerPel);
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2021-06-11 20:30:43 +02:00
|
|
|
memset(&s, 0, sizeof(s));
|
2020-10-15 01:17:40 +02:00
|
|
|
|
2022-09-10 00:12:31 +02:00
|
|
|
s.ddpfPixelFormat.dwFlags = DDPF_PALETTEINDEXED8 | DDPF_RGB;
|
|
|
|
s.ddpfPixelFormat.dwRGBBitCount = 8;
|
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
s.dwSize = sizeof(DDSURFACEDESC);
|
2021-05-23 08:09:15 +02:00
|
|
|
s.dwFlags = DDSD_HEIGHT | DDSD_REFRESHRATE | DDSD_WIDTH | DDSD_PITCH | DDSD_PIXELFORMAT;
|
2020-10-13 09:20:52 +02:00
|
|
|
s.dwRefreshRate = 60;
|
2022-09-10 00:12:31 +02:00
|
|
|
s.dwHeight = m.dmPelsHeight;
|
|
|
|
s.dwWidth = m.dmPelsWidth;
|
2024-01-09 20:44:04 +01:00
|
|
|
s.lPitch = ((s.dwWidth * s.ddpfPixelFormat.dwRGBBitCount + 63) & ~63) >> 3;
|
2020-10-13 09:20:52 +02:00
|
|
|
s.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
|
|
|
|
|
2023-08-11 12:58:48 +02:00
|
|
|
if (s.ddpfPixelFormat.dwRGBBitCount == bpp_filter || !bpp_filter)
|
2021-06-10 03:48:26 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.bpp == 8 || g_config.resolutions == RESLIST_FULL)
|
2022-10-11 23:13:04 +02:00
|
|
|
{
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.max_resolutions && res_count++ >= g_config.max_resolutions)
|
2023-08-11 12:58:48 +02:00
|
|
|
{
|
|
|
|
TRACE(" resolution limit reached, stopping\n");
|
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lpEnumModesCallback((LPDDSURFACEDESC)&s, lpContext) == DDENUMRET_CANCEL)
|
|
|
|
{
|
|
|
|
TRACE(" DDENUMRET_CANCEL returned, stopping\n");
|
|
|
|
return DD_OK;
|
|
|
|
}
|
2021-06-10 03:48:26 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
s.ddpfPixelFormat.dwFlags = DDPF_RGB;
|
|
|
|
s.ddpfPixelFormat.dwRGBBitCount = 16;
|
|
|
|
s.ddpfPixelFormat.dwRBitMask = 0xF800;
|
|
|
|
s.ddpfPixelFormat.dwGBitMask = 0x07E0;
|
|
|
|
s.ddpfPixelFormat.dwBBitMask = 0x001F;
|
2024-01-09 20:44:04 +01:00
|
|
|
s.lPitch = ((s.dwWidth * s.ddpfPixelFormat.dwRGBBitCount + 63) & ~63) >> 3;
|
2021-06-10 03:48:26 +02:00
|
|
|
|
2023-08-11 12:58:48 +02:00
|
|
|
if (s.ddpfPixelFormat.dwRGBBitCount == bpp_filter || !bpp_filter)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.bpp == 16 || g_config.resolutions == RESLIST_FULL)
|
2022-10-11 23:13:04 +02:00
|
|
|
{
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.max_resolutions && res_count++ >= g_config.max_resolutions)
|
2023-08-11 12:58:48 +02:00
|
|
|
{
|
|
|
|
TRACE(" resolution limit reached, stopping\n");
|
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lpEnumModesCallback((LPDDSURFACEDESC)&s, lpContext) == DDENUMRET_CANCEL)
|
|
|
|
{
|
|
|
|
TRACE(" DDENUMRET_CANCEL returned, stopping\n");
|
|
|
|
return DD_OK;
|
|
|
|
}
|
2021-06-10 03:48:26 +02:00
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2021-06-10 03:48:26 +02:00
|
|
|
s.ddpfPixelFormat.dwFlags = DDPF_RGB;
|
|
|
|
s.ddpfPixelFormat.dwRGBBitCount = 32;
|
|
|
|
s.ddpfPixelFormat.dwRBitMask = 0xFF0000;
|
|
|
|
s.ddpfPixelFormat.dwGBitMask = 0x00FF00;
|
|
|
|
s.ddpfPixelFormat.dwBBitMask = 0x0000FF;
|
2024-01-09 20:44:04 +01:00
|
|
|
s.lPitch = ((s.dwWidth * s.ddpfPixelFormat.dwRGBBitCount + 63) & ~63) >> 3;
|
2021-06-10 03:48:26 +02:00
|
|
|
|
2023-08-11 12:58:48 +02:00
|
|
|
if (s.ddpfPixelFormat.dwRGBBitCount == bpp_filter || !bpp_filter)
|
2021-06-02 01:52:45 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.bpp == 32 || g_config.resolutions == RESLIST_FULL)
|
2021-06-10 03:48:26 +02:00
|
|
|
{
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.max_resolutions && res_count++ >= g_config.max_resolutions)
|
2023-08-11 12:58:48 +02:00
|
|
|
{
|
|
|
|
TRACE(" resolution limit reached, stopping\n");
|
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lpEnumModesCallback((LPDDSURFACEDESC)&s, lpContext) == DDENUMRET_CANCEL)
|
|
|
|
{
|
|
|
|
TRACE(" DDENUMRET_CANCEL returned, stopping\n");
|
|
|
|
return DD_OK;
|
|
|
|
}
|
2021-06-10 03:48:26 +02:00
|
|
|
}
|
2023-08-11 12:58:48 +02:00
|
|
|
}
|
2021-06-02 01:52:45 +02:00
|
|
|
|
2021-06-10 03:48:26 +02:00
|
|
|
for (int x = 0; x < sizeof(resolutions) / sizeof(resolutions[0]); x++)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2021-06-10 03:48:26 +02:00
|
|
|
if (resolutions[x].cx == m.dmPelsWidth && resolutions[x].cy == m.dmPelsHeight)
|
|
|
|
{
|
|
|
|
resolutions[x].cx = 0;
|
|
|
|
resolutions[x].cy = 0;
|
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
}
|
2020-10-13 11:29:52 +02:00
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
memset(&m, 0, sizeof(DEVMODE));
|
|
|
|
m.dmSize = sizeof(DEVMODE);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (!g_ddraw.bpp || g_config.resolutions != RESLIST_NORMAL)
|
2021-06-10 03:48:26 +02:00
|
|
|
{
|
2020-10-13 09:20:52 +02:00
|
|
|
for (i = 0; i < sizeof(resolutions) / sizeof(resolutions[0]); i++)
|
|
|
|
{
|
2021-06-10 03:48:26 +02:00
|
|
|
if (!resolutions[i].cx || !resolutions[i].cy)
|
|
|
|
continue;
|
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
if (!(resolutions[i].cx == g_config.custom_width && resolutions[i].cy == g_config.custom_height) &&
|
2023-09-14 01:06:37 +02:00
|
|
|
((max_w && resolutions[i].cx > max_w) || (max_h && resolutions[i].cy > max_h)))
|
2021-06-07 01:36:47 +02:00
|
|
|
{
|
2022-09-05 03:48:24 +02:00
|
|
|
DEVMODE m;
|
2021-06-07 01:36:47 +02:00
|
|
|
memset(&m, 0, sizeof(DEVMODE));
|
|
|
|
|
|
|
|
m.dmSize = sizeof(DEVMODE);
|
|
|
|
m.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
|
|
|
|
m.dmPelsWidth = resolutions[i].cx;
|
|
|
|
m.dmPelsHeight = resolutions[i].cy;
|
2023-08-10 17:28:09 +02:00
|
|
|
|
2021-06-07 01:36:47 +02:00
|
|
|
if (ChangeDisplaySettings(&m, CDS_TEST) != DISP_CHANGE_SUCCESSFUL)
|
2024-03-22 04:36:30 +01:00
|
|
|
{
|
|
|
|
TRACE(" SKIPPED: %ux%u\n", m.dmPelsWidth, m.dmPelsHeight);
|
2021-06-07 01:36:47 +02:00
|
|
|
continue;
|
2024-03-22 04:36:30 +01:00
|
|
|
}
|
2021-06-07 01:36:47 +02:00
|
|
|
}
|
2023-09-14 01:07:22 +02:00
|
|
|
|
2021-06-11 20:30:43 +02:00
|
|
|
memset(&s, 0, sizeof(s));
|
2020-10-15 01:17:40 +02:00
|
|
|
|
2022-09-10 00:12:31 +02:00
|
|
|
s.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
|
|
|
|
s.ddpfPixelFormat.dwFlags = DDPF_PALETTEINDEXED8 | DDPF_RGB;
|
|
|
|
s.ddpfPixelFormat.dwRGBBitCount = 8;
|
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
s.dwSize = sizeof(DDSURFACEDESC);
|
2021-05-23 08:09:15 +02:00
|
|
|
s.dwFlags = DDSD_HEIGHT | DDSD_REFRESHRATE | DDSD_WIDTH | DDSD_PITCH | DDSD_PIXELFORMAT;
|
2022-09-10 00:12:31 +02:00
|
|
|
s.dwRefreshRate = 60;
|
2020-10-13 09:20:52 +02:00
|
|
|
s.dwHeight = resolutions[i].cy;
|
|
|
|
s.dwWidth = resolutions[i].cx;
|
2024-01-09 20:44:04 +01:00
|
|
|
s.lPitch = ((s.dwWidth * s.ddpfPixelFormat.dwRGBBitCount + 63) & ~63) >> 3;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2023-08-11 12:58:48 +02:00
|
|
|
if (s.ddpfPixelFormat.dwRGBBitCount == bpp_filter || !bpp_filter)
|
2022-10-11 23:13:04 +02:00
|
|
|
{
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.max_resolutions && res_count++ >= g_config.max_resolutions)
|
2023-08-11 12:58:48 +02:00
|
|
|
{
|
|
|
|
TRACE(" resolution limit reached, stopping\n");
|
|
|
|
return DD_OK;
|
|
|
|
}
|
2022-10-11 23:13:04 +02:00
|
|
|
|
2023-08-11 12:58:48 +02:00
|
|
|
if (lpEnumModesCallback((LPDDSURFACEDESC)&s, lpContext) == DDENUMRET_CANCEL)
|
|
|
|
{
|
|
|
|
TRACE(" DDENUMRET_CANCEL returned, stopping\n");
|
|
|
|
return DD_OK;
|
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
s.ddpfPixelFormat.dwFlags = DDPF_RGB;
|
|
|
|
s.ddpfPixelFormat.dwRGBBitCount = 16;
|
|
|
|
s.ddpfPixelFormat.dwRBitMask = 0xF800;
|
|
|
|
s.ddpfPixelFormat.dwGBitMask = 0x07E0;
|
|
|
|
s.ddpfPixelFormat.dwBBitMask = 0x001F;
|
2024-01-09 20:44:04 +01:00
|
|
|
s.lPitch = ((s.dwWidth * s.ddpfPixelFormat.dwRGBBitCount + 63) & ~63) >> 3;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2023-08-11 12:58:48 +02:00
|
|
|
if (s.ddpfPixelFormat.dwRGBBitCount == bpp_filter || !bpp_filter)
|
2022-10-11 23:13:04 +02:00
|
|
|
{
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.max_resolutions && res_count++ >= g_config.max_resolutions)
|
2023-08-11 12:58:48 +02:00
|
|
|
{
|
|
|
|
TRACE(" resolution limit reached, stopping\n");
|
|
|
|
return DD_OK;
|
|
|
|
}
|
2022-10-11 23:13:04 +02:00
|
|
|
|
2023-08-11 12:58:48 +02:00
|
|
|
if (lpEnumModesCallback((LPDDSURFACEDESC)&s, lpContext) == DDENUMRET_CANCEL)
|
|
|
|
{
|
|
|
|
TRACE(" DDENUMRET_CANCEL returned, stopping\n");
|
|
|
|
return DD_OK;
|
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
2021-06-02 01:52:45 +02:00
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.resolutions == RESLIST_MINI)
|
2021-06-10 03:48:26 +02:00
|
|
|
continue;
|
|
|
|
|
2021-06-02 01:52:45 +02:00
|
|
|
s.ddpfPixelFormat.dwFlags = DDPF_RGB;
|
|
|
|
s.ddpfPixelFormat.dwRGBBitCount = 32;
|
|
|
|
s.ddpfPixelFormat.dwRBitMask = 0xFF0000;
|
|
|
|
s.ddpfPixelFormat.dwGBitMask = 0x00FF00;
|
|
|
|
s.ddpfPixelFormat.dwBBitMask = 0x0000FF;
|
2024-01-09 20:44:04 +01:00
|
|
|
s.lPitch = ((s.dwWidth * s.ddpfPixelFormat.dwRGBBitCount + 63) & ~63) >> 3;
|
2021-06-02 01:52:45 +02:00
|
|
|
|
2023-08-11 12:58:48 +02:00
|
|
|
if (s.ddpfPixelFormat.dwRGBBitCount == bpp_filter || !bpp_filter)
|
2022-10-11 23:13:04 +02:00
|
|
|
{
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.max_resolutions && res_count++ >= g_config.max_resolutions)
|
2023-08-11 12:58:48 +02:00
|
|
|
{
|
|
|
|
TRACE(" resolution limit reached, stopping\n");
|
|
|
|
return DD_OK;
|
|
|
|
}
|
2022-10-11 23:13:04 +02:00
|
|
|
|
2023-08-11 12:58:48 +02:00
|
|
|
if (lpEnumModesCallback((LPDDSURFACEDESC)&s, lpContext) == DDENUMRET_CANCEL)
|
|
|
|
{
|
|
|
|
TRACE(" DDENUMRET_CANCEL returned, stopping\n");
|
|
|
|
return DD_OK;
|
|
|
|
}
|
2021-06-02 01:52:45 +02:00
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
|
2021-06-14 09:18:14 +02:00
|
|
|
HRESULT dd_GetCaps(LPDDCAPS_DX1 lpDDDriverCaps, LPDDCAPS_DX1 lpDDEmulCaps)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2020-10-17 04:52:31 +02:00
|
|
|
if (lpDDDriverCaps)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2021-06-14 09:18:14 +02:00
|
|
|
int size =
|
|
|
|
lpDDDriverCaps->dwSize == sizeof(DDCAPS_DX3) ? sizeof(DDCAPS_DX3) :
|
|
|
|
lpDDDriverCaps->dwSize == sizeof(DDCAPS_DX5) ? sizeof(DDCAPS_DX5) :
|
|
|
|
lpDDDriverCaps->dwSize == sizeof(DDCAPS_DX6) ? sizeof(DDCAPS_DX6) :
|
|
|
|
lpDDDriverCaps->dwSize == sizeof(DDCAPS_DX7) ? sizeof(DDCAPS_DX7) :
|
|
|
|
sizeof(DDCAPS_DX1);
|
|
|
|
|
|
|
|
memset(lpDDDriverCaps, 0, size);
|
|
|
|
|
|
|
|
lpDDDriverCaps->dwSize = size;
|
2021-06-11 20:30:43 +02:00
|
|
|
lpDDDriverCaps->dwCaps =
|
|
|
|
DDCAPS_BLT |
|
|
|
|
DDCAPS_PALETTE |
|
|
|
|
DDCAPS_BLTCOLORFILL |
|
|
|
|
DDCAPS_BLTSTRETCH |
|
|
|
|
DDCAPS_CANCLIP |
|
2023-07-29 02:57:47 +02:00
|
|
|
DDCAPS_CANBLTSYSMEM |
|
2023-09-10 02:31:28 +02:00
|
|
|
DDCAPS_CANCLIPSTRETCHED |
|
|
|
|
DDCAPS_COLORKEY;
|
2023-07-29 02:57:47 +02:00
|
|
|
|
|
|
|
lpDDDriverCaps->dwCaps2 =
|
|
|
|
DDCAPS2_NOPAGELOCKREQUIRED |
|
|
|
|
DDCAPS2_WIDESURFACES;
|
|
|
|
|
|
|
|
lpDDDriverCaps->dwCKeyCaps =
|
|
|
|
DDCKEYCAPS_SRCBLT |
|
|
|
|
DDCKEYCAPS_SRCBLTCLRSPACE;
|
|
|
|
|
|
|
|
lpDDDriverCaps->dwFXCaps =
|
|
|
|
DDFXCAPS_BLTMIRRORLEFTRIGHT |
|
|
|
|
DDFXCAPS_BLTMIRRORUPDOWN;
|
|
|
|
|
|
|
|
lpDDDriverCaps->dwPalCaps =
|
|
|
|
DDPCAPS_8BIT |
|
|
|
|
DDPCAPS_PRIMARYSURFACE;
|
2021-06-11 20:30:43 +02:00
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
lpDDDriverCaps->dwVidMemTotal = 16777216;
|
|
|
|
lpDDDriverCaps->dwVidMemFree = 16777216;
|
2021-06-14 09:18:14 +02:00
|
|
|
lpDDDriverCaps->ddsCaps.dwCaps = DDSCAPS_FLIP;
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2020-10-17 04:52:31 +02:00
|
|
|
if (lpDDEmulCaps)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2021-06-14 09:18:14 +02:00
|
|
|
int size =
|
|
|
|
lpDDEmulCaps->dwSize == sizeof(DDCAPS_DX3) ? sizeof(DDCAPS_DX3) :
|
|
|
|
lpDDEmulCaps->dwSize == sizeof(DDCAPS_DX5) ? sizeof(DDCAPS_DX5) :
|
|
|
|
lpDDEmulCaps->dwSize == sizeof(DDCAPS_DX6) ? sizeof(DDCAPS_DX6) :
|
|
|
|
lpDDEmulCaps->dwSize == sizeof(DDCAPS_DX7) ? sizeof(DDCAPS_DX7) :
|
|
|
|
sizeof(DDCAPS_DX1);
|
|
|
|
|
|
|
|
memset(lpDDEmulCaps, 0, size);
|
|
|
|
|
|
|
|
lpDDEmulCaps->dwSize = size;
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
|
2021-06-14 09:57:26 +02:00
|
|
|
HRESULT dd_GetDisplayMode(LPDDSURFACEDESC lpDDSurfaceDesc)
|
2020-10-20 16:38:51 +02:00
|
|
|
{
|
|
|
|
if (lpDDSurfaceDesc)
|
|
|
|
{
|
2021-06-11 20:30:43 +02:00
|
|
|
int size = lpDDSurfaceDesc->dwSize == sizeof(DDSURFACEDESC2) ? sizeof(DDSURFACEDESC2) : sizeof(DDSURFACEDESC);
|
|
|
|
|
|
|
|
memset(lpDDSurfaceDesc, 0, size);
|
2020-10-20 16:38:51 +02:00
|
|
|
|
2024-05-22 23:23:27 +02:00
|
|
|
unsigned long width = 1024;
|
|
|
|
unsigned long height = 768;
|
|
|
|
unsigned long bpp = 16;
|
|
|
|
|
|
|
|
if (g_ddraw.width)
|
|
|
|
{
|
|
|
|
width = g_ddraw.width;
|
|
|
|
height = g_ddraw.height;
|
|
|
|
bpp = g_ddraw.bpp;
|
|
|
|
}
|
|
|
|
else if (g_config.fake_mode[0])
|
|
|
|
{
|
|
|
|
char* e = &g_config.fake_mode[0];
|
|
|
|
|
|
|
|
width = strtoul(e, &e, 0);
|
|
|
|
height = strtoul(e + 1, &e, 0);
|
|
|
|
bpp = strtoul(e + 1, &e, 0);
|
|
|
|
}
|
|
|
|
|
2022-09-10 00:12:31 +02:00
|
|
|
lpDDSurfaceDesc->ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
|
2024-05-22 23:23:27 +02:00
|
|
|
lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = bpp;
|
2022-09-10 00:12:31 +02:00
|
|
|
|
2021-06-11 20:30:43 +02:00
|
|
|
lpDDSurfaceDesc->dwSize = size;
|
2020-10-20 16:38:51 +02:00
|
|
|
lpDDSurfaceDesc->dwFlags = DDSD_HEIGHT | DDSD_REFRESHRATE | DDSD_WIDTH | DDSD_PITCH | DDSD_PIXELFORMAT;
|
2022-09-10 00:12:31 +02:00
|
|
|
lpDDSurfaceDesc->dwRefreshRate = 60;
|
2024-05-22 23:23:27 +02:00
|
|
|
lpDDSurfaceDesc->dwWidth = width;
|
|
|
|
lpDDSurfaceDesc->dwHeight = height;
|
2020-10-20 16:38:51 +02:00
|
|
|
|
2024-05-22 23:23:27 +02:00
|
|
|
if (bpp == 32)
|
2021-06-02 01:52:45 +02:00
|
|
|
{
|
|
|
|
lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB;
|
|
|
|
lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0xFF0000;
|
|
|
|
lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x00FF00;
|
|
|
|
lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x0000FF;
|
|
|
|
}
|
2024-05-22 23:23:27 +02:00
|
|
|
else if (bpp == 8)
|
|
|
|
{
|
|
|
|
lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_PALETTEINDEXED8 | DDPF_RGB;
|
|
|
|
}
|
|
|
|
else
|
2020-10-20 16:38:51 +02:00
|
|
|
{
|
|
|
|
lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB;
|
|
|
|
lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = 16;
|
|
|
|
lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0xF800;
|
|
|
|
lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x07E0;
|
|
|
|
lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x001F;
|
|
|
|
}
|
2024-05-22 23:23:27 +02:00
|
|
|
|
|
|
|
lpDDSurfaceDesc->lPitch =
|
|
|
|
((lpDDSurfaceDesc->dwWidth * lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount + 63) & ~63) >> 3;
|
2020-10-20 16:38:51 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
|
2020-10-13 22:55:49 +02:00
|
|
|
HRESULT dd_GetMonitorFrequency(LPDWORD lpdwFreq)
|
|
|
|
{
|
2022-09-10 00:12:31 +02:00
|
|
|
if (lpdwFreq)
|
|
|
|
*lpdwFreq = 60;
|
|
|
|
|
2020-10-13 22:55:49 +02:00
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
HRESULT dd_RestoreDisplayMode()
|
|
|
|
{
|
2024-06-08 22:08:23 +02:00
|
|
|
if (!g_ddraw.render.run)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-06-08 22:08:23 +02:00
|
|
|
return DD_OK;
|
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-06-08 22:08:23 +02:00
|
|
|
EnterCriticalSection(&g_ddraw.cs);
|
|
|
|
g_ddraw.render.run = FALSE;
|
|
|
|
ReleaseSemaphore(g_ddraw.render.sem, 1, NULL);
|
|
|
|
LeaveCriticalSection(&g_ddraw.cs);
|
|
|
|
|
|
|
|
if (g_ddraw.render.thread)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(g_ddraw.render.thread, INFINITE);
|
|
|
|
g_ddraw.render.thread = NULL;
|
2022-09-23 02:59:02 +02:00
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
if (!g_config.windowed)
|
2022-09-23 02:59:02 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.renderer == d3d9_render_main && !g_config.nonexclusive)
|
2020-10-13 21:58:04 +02:00
|
|
|
{
|
2022-09-23 02:45:59 +02:00
|
|
|
if (!d3d9_reset(TRUE))
|
|
|
|
d3d9_release();
|
2020-10-13 21:58:04 +02:00
|
|
|
}
|
2022-09-23 02:59:02 +02:00
|
|
|
else
|
2020-10-13 21:58:04 +02:00
|
|
|
{
|
2020-10-13 09:20:52 +02:00
|
|
|
ChangeDisplaySettings(NULL, 0);
|
2020-10-13 21:58:04 +02:00
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
|
2021-07-03 18:07:38 +02:00
|
|
|
HRESULT dd_SetDisplayMode(DWORD dwWidth, DWORD dwHeight, DWORD dwBPP, DWORD dwFlags)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-05-27 23:33:47 +02:00
|
|
|
if (!dwWidth)
|
2024-05-27 23:54:19 +02:00
|
|
|
dwWidth = g_ddraw.width ? g_ddraw.width : 800;
|
2024-05-27 23:33:47 +02:00
|
|
|
|
|
|
|
if (!dwHeight)
|
2024-05-27 23:54:19 +02:00
|
|
|
dwHeight = g_ddraw.height ? g_ddraw.height : 600;
|
2024-05-27 23:33:47 +02:00
|
|
|
|
|
|
|
if (!dwBPP)
|
2024-05-27 23:54:19 +02:00
|
|
|
dwBPP = g_ddraw.bpp ? g_ddraw.bpp : 16;
|
2024-05-27 23:33:47 +02:00
|
|
|
|
2021-06-11 20:30:43 +02:00
|
|
|
if (dwBPP != 8 && dwBPP != 16 && dwBPP != 32)
|
2020-10-13 09:20:52 +02:00
|
|
|
return DDERR_INVALIDMODE;
|
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.mgs_hack && dwHeight == 480) dwHeight -= 32; /* Remove black bar in Metal Gear Solid */
|
2023-08-31 19:30:51 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.render.thread)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
EnterCriticalSection(&g_ddraw.cs);
|
|
|
|
g_ddraw.render.run = FALSE;
|
|
|
|
ReleaseSemaphore(g_ddraw.render.sem, 1, NULL);
|
|
|
|
LeaveCriticalSection(&g_ddraw.cs);
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
WaitForSingleObject(g_ddraw.render.thread, INFINITE);
|
|
|
|
g_ddraw.render.thread = NULL;
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (!g_ddraw.mode.dmPelsWidth)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2021-05-24 10:20:00 +02:00
|
|
|
ChangeDisplaySettings(NULL, 0);
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.mode.dmSize = sizeof(DEVMODE);
|
|
|
|
g_ddraw.mode.dmDriverExtra = 0;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-06-10 00:05:04 +02:00
|
|
|
if (real_EnumDisplaySettingsA(NULL, ENUM_CURRENT_SETTINGS, &g_ddraw.mode) == FALSE)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.mode.dmSize = sizeof(DEVMODE);
|
|
|
|
g_ddraw.mode.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL | DM_DISPLAYFREQUENCY;
|
|
|
|
g_ddraw.mode.dmPelsWidth = real_GetSystemMetrics(SM_CXSCREEN);
|
|
|
|
g_ddraw.mode.dmPelsHeight = real_GetSystemMetrics(SM_CYSCREEN);
|
|
|
|
g_ddraw.mode.dmDisplayFrequency = 60;
|
|
|
|
g_ddraw.mode.dmBitsPerPel = 32;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (!g_ddraw.mode.dmPelsWidth || !g_ddraw.mode.dmPelsHeight)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2023-09-22 00:38:42 +02:00
|
|
|
g_config.fullscreen = FALSE;
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-07-24 07:58:55 +02:00
|
|
|
BOOL zooming = g_ddraw.zoom.enabled;
|
|
|
|
g_ddraw.zoom.enabled = FALSE;
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.width = g_config.window_rect.right;
|
|
|
|
g_ddraw.render.height = g_config.window_rect.bottom;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2021-06-11 20:30:43 +02:00
|
|
|
/* temporary fix: center window for games that keep changing their resolution */
|
2024-03-22 22:27:00 +01:00
|
|
|
if ((g_ddraw.width || g_config.infantryhack) &&
|
|
|
|
(g_ddraw.width != dwWidth || g_ddraw.height != dwHeight) &&
|
2021-06-11 20:30:43 +02:00
|
|
|
(dwWidth > g_config.window_rect.right || dwHeight > g_config.window_rect.bottom))
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
|
|
|
g_config.window_rect.left = -32000;
|
|
|
|
g_config.window_rect.top = -32000;
|
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.width = dwWidth;
|
|
|
|
g_ddraw.height = dwHeight;
|
|
|
|
g_ddraw.bpp = dwBPP;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-07-26 08:27:42 +02:00
|
|
|
//InterlockedExchange((LONG*)&g_ddraw.cursor.x, dwWidth / 2);
|
|
|
|
//InterlockedExchange((LONG*)&g_ddraw.cursor.y, dwHeight / 2);
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
BOOL border = g_config.border;
|
2021-07-30 13:14:12 +02:00
|
|
|
BOOL nonexclusive = FALSE;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.fullscreen)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.width = g_ddraw.mode.dmPelsWidth;
|
|
|
|
g_ddraw.render.height = g_ddraw.mode.dmPelsHeight;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.windowed) /* windowed-fullscreen aka borderless */
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
|
|
|
border = FALSE;
|
2020-10-15 01:17:40 +02:00
|
|
|
|
2024-04-20 00:34:46 +02:00
|
|
|
if (!g_config.remove_menu && GetMenu(g_ddraw.hwnd))
|
|
|
|
{
|
|
|
|
g_ddraw.render.height -= real_GetSystemMetrics(SM_CYMENU);
|
|
|
|
}
|
|
|
|
|
2021-06-11 20:30:43 +02:00
|
|
|
/* prevent OpenGL from going automatically into fullscreen exclusive mode */
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.renderer == ogl_render_main)
|
2021-07-30 13:14:12 +02:00
|
|
|
nonexclusive = TRUE;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
|
|
|
}
|
|
|
|
}
|
2024-07-24 07:58:55 +02:00
|
|
|
else if (zooming)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-07-24 07:58:55 +02:00
|
|
|
if (g_ddraw.width > g_ddraw.mode.dmPelsWidth ||
|
|
|
|
g_ddraw.height > g_ddraw.mode.dmPelsHeight)
|
|
|
|
{
|
|
|
|
/* Downscaling requires adjmouse to be enabled */
|
|
|
|
g_config.adjmouse = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Do not change display resolution when zooming */
|
|
|
|
g_ddraw.render.width = g_ddraw.render.mode.dmPelsWidth;
|
|
|
|
g_ddraw.render.height = g_ddraw.render.mode.dmPelsHeight;
|
|
|
|
|
|
|
|
/* Resize and alt+enter are not supported yet with zooming */
|
|
|
|
g_config.resizable = FALSE;
|
|
|
|
g_config.hotkeys.toggle_fullscreen = 0;
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
2020-10-13 21:58:04 +02:00
|
|
|
|
2024-07-24 07:58:55 +02:00
|
|
|
if (!zooming || g_config.fullscreen)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-07-24 07:58:55 +02:00
|
|
|
if (g_ddraw.render.width < g_ddraw.width)
|
|
|
|
{
|
|
|
|
g_ddraw.render.width = g_ddraw.width;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (g_ddraw.render.height < g_ddraw.height)
|
|
|
|
{
|
|
|
|
g_ddraw.render.height = g_ddraw.height;
|
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.run = TRUE;
|
2021-06-11 20:30:43 +02:00
|
|
|
|
2022-09-20 08:59:36 +02:00
|
|
|
BOOL lock_mouse = g_mouse_locked;
|
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
mouse_unlock();
|
2021-06-11 20:30:43 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
memset(&g_ddraw.render.mode, 0, sizeof(DEVMODE));
|
|
|
|
g_ddraw.render.mode.dmSize = sizeof(DEVMODE);
|
2020-10-13 21:58:04 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
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;
|
2023-10-04 23:21:21 +02:00
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.refresh_rate)
|
2023-08-18 16:48:59 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.mode.dmFields |= DM_DISPLAYFREQUENCY;
|
|
|
|
g_ddraw.render.mode.dmDisplayFrequency = g_config.refresh_rate;
|
2023-10-04 19:51:53 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (ChangeDisplaySettings(&g_ddraw.render.mode, CDS_TEST) != DISP_CHANGE_SUCCESSFUL)
|
2023-08-18 18:01:53 +02:00
|
|
|
{
|
2023-09-22 00:38:42 +02:00
|
|
|
g_config.refresh_rate = 0;
|
2023-08-18 18:01:53 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.mode.dmFields &= ~DM_DISPLAYFREQUENCY;
|
|
|
|
g_ddraw.render.mode.dmDisplayFrequency = 0;
|
2023-08-18 18:01:53 +02:00
|
|
|
}
|
2023-08-18 16:48:59 +02:00
|
|
|
}
|
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
if (!g_config.windowed)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2021-06-11 20:30:43 +02:00
|
|
|
/* Making sure the chosen resolution is valid */
|
2024-03-22 22:27:00 +01:00
|
|
|
if (ChangeDisplaySettings(&g_ddraw.render.mode, CDS_TEST) != DISP_CHANGE_SUCCESSFUL)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2021-10-31 21:19:16 +01:00
|
|
|
/* Try without upscaling */
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.width = g_ddraw.width;
|
|
|
|
g_ddraw.render.height = g_ddraw.height;
|
2021-10-08 14:29:00 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.mode.dmPelsWidth = g_ddraw.render.width;
|
|
|
|
g_ddraw.render.mode.dmPelsHeight = g_ddraw.render.height;
|
2021-10-08 14:29:00 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (ChangeDisplaySettings(&g_ddraw.render.mode, CDS_TEST) != DISP_CHANGE_SUCCESSFUL)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2021-10-31 21:19:16 +01:00
|
|
|
/* Try 2x scaling */
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.width *= 2;
|
|
|
|
g_ddraw.render.height *= 2;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.mode.dmPelsWidth = g_ddraw.render.width;
|
|
|
|
g_ddraw.render.mode.dmPelsHeight = g_ddraw.render.height;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
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)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2021-10-31 21:19:16 +01:00
|
|
|
SIZE res = { 0 };
|
|
|
|
|
|
|
|
/* try to get a resolution with the same aspect ratio as the requested resolution */
|
|
|
|
BOOL found_res = util_get_lowest_resolution(
|
2024-03-22 22:27:00 +01:00
|
|
|
(float)g_ddraw.width / g_ddraw.height,
|
2021-10-31 21:19:16 +01:00
|
|
|
&res,
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.width + 1, /* don't return the original resolution since we tested that one already */
|
|
|
|
g_ddraw.height,
|
|
|
|
g_ddraw.mode.dmPelsWidth,
|
|
|
|
g_ddraw.mode.dmPelsHeight);
|
2021-10-31 21:19:16 +01:00
|
|
|
|
|
|
|
if (!found_res)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2021-10-31 21:19:16 +01:00
|
|
|
/* try to get a resolution with the same aspect ratio as the current display mode */
|
|
|
|
found_res = util_get_lowest_resolution(
|
2024-03-22 22:27:00 +01:00
|
|
|
(float)g_ddraw.mode.dmPelsWidth / g_ddraw.mode.dmPelsHeight,
|
2020-10-13 09:20:52 +02:00
|
|
|
&res,
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.width,
|
|
|
|
g_ddraw.height,
|
|
|
|
g_ddraw.mode.dmPelsWidth,
|
|
|
|
g_ddraw.mode.dmPelsHeight);
|
2021-10-31 21:19:16 +01:00
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.width = res.cx;
|
|
|
|
g_ddraw.render.height = res.cy;
|
2021-06-11 20:30:43 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.mode.dmPelsWidth = g_ddraw.render.width;
|
|
|
|
g_ddraw.render.mode.dmPelsHeight = g_ddraw.render.height;
|
2021-10-31 21:19:16 +01:00
|
|
|
|
|
|
|
if (!found_res ||
|
2024-03-22 22:27:00 +01:00
|
|
|
ChangeDisplaySettings(&g_ddraw.render.mode, CDS_TEST) != DISP_CHANGE_SUCCESSFUL)
|
2021-10-31 21:19:16 +01:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.width > g_ddraw.mode.dmPelsWidth ||
|
|
|
|
g_ddraw.height > g_ddraw.mode.dmPelsHeight)
|
2023-09-13 19:05:49 +02:00
|
|
|
{
|
|
|
|
/* Downscaling requires adjmouse to be enabled */
|
2023-09-22 00:38:42 +02:00
|
|
|
g_config.adjmouse = TRUE;
|
2023-09-13 19:05:49 +02:00
|
|
|
}
|
|
|
|
|
2021-10-31 21:19:16 +01:00
|
|
|
/* try current display settings */
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.width = g_ddraw.mode.dmPelsWidth;
|
|
|
|
g_ddraw.render.height = g_ddraw.mode.dmPelsHeight;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.mode.dmPelsWidth = g_ddraw.render.width;
|
|
|
|
g_ddraw.render.mode.dmPelsHeight = g_ddraw.render.height;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (ChangeDisplaySettings(&g_ddraw.render.mode, CDS_TEST) != DISP_CHANGE_SUCCESSFUL)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2023-09-13 21:21:18 +02:00
|
|
|
/* everything failed, use borderless mode instead */
|
2023-08-24 19:05:20 +02:00
|
|
|
ChangeDisplaySettings(NULL, 0);
|
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
g_config.windowed = TRUE;
|
|
|
|
g_config.fullscreen = TRUE;
|
2023-09-13 21:21:18 +02:00
|
|
|
border = FALSE;
|
2023-08-24 18:37:16 +02:00
|
|
|
|
2023-09-13 21:21:18 +02:00
|
|
|
/* prevent OpenGL from going automatically into fullscreen exclusive mode */
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.renderer == ogl_render_main)
|
2023-09-13 21:21:18 +02:00
|
|
|
nonexclusive = TRUE;
|
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-09-13 21:21:18 +02:00
|
|
|
|
|
|
|
/* Support downscaling in borderless mode */
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.windowed && g_config.fullscreen)
|
2023-09-13 19:26:30 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.width > g_ddraw.mode.dmPelsWidth ||
|
|
|
|
g_ddraw.height > g_ddraw.mode.dmPelsHeight)
|
2023-09-13 19:26:30 +02:00
|
|
|
{
|
|
|
|
/* Downscaling requires adjmouse to be enabled */
|
2023-09-22 00:38:42 +02:00
|
|
|
g_config.adjmouse = TRUE;
|
2023-09-13 19:26:30 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.width = g_ddraw.mode.dmPelsWidth;
|
|
|
|
g_ddraw.render.height = g_ddraw.mode.dmPelsHeight;
|
2023-09-13 19:26:30 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.mode.dmPelsWidth = g_ddraw.render.width;
|
|
|
|
g_ddraw.render.mode.dmPelsHeight = g_ddraw.render.height;
|
2023-09-13 19:26:30 +02:00
|
|
|
}
|
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.viewport.width = g_ddraw.render.width;
|
|
|
|
g_ddraw.render.viewport.height = g_ddraw.render.height;
|
|
|
|
g_ddraw.render.viewport.x = 0;
|
|
|
|
g_ddraw.render.viewport.y = 0;
|
2021-06-11 20:30:43 +02:00
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.boxing)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.viewport.width = g_ddraw.width;
|
|
|
|
g_ddraw.render.viewport.height = g_ddraw.height;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2021-06-11 20:30:43 +02:00
|
|
|
for (int i = 20; i-- > 1;)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.width * i <= g_ddraw.render.width && g_ddraw.height * i <= g_ddraw.render.height)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.viewport.width *= i;
|
|
|
|
g_ddraw.render.viewport.height *= i;
|
2020-10-13 09:20:52 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
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;
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
2023-09-22 00:38:42 +02:00
|
|
|
else if (g_config.maintas)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
double dst_ar = (double)g_ddraw.height / g_ddraw.width;
|
|
|
|
double src_ar = (double)g_ddraw.render.height / g_ddraw.render.width;
|
2023-12-31 04:16:45 +01:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.viewport.width = g_ddraw.render.width;
|
|
|
|
g_ddraw.render.viewport.height = (int)round(dst_ar * g_ddraw.render.viewport.width);
|
2021-06-11 20:30:43 +02:00
|
|
|
|
2023-12-31 04:16:45 +01:00
|
|
|
if (src_ar < dst_ar)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.viewport.width =
|
|
|
|
(int)round(((double)g_ddraw.render.viewport.width / g_ddraw.render.viewport.height) * g_ddraw.render.height);
|
2021-06-11 20:30:43 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.viewport.height = g_ddraw.render.height;
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
2021-06-11 20:30:43 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.viewport.width = min(g_ddraw.render.viewport.width, g_ddraw.render.width);
|
|
|
|
g_ddraw.render.viewport.height = min(g_ddraw.render.viewport.height, g_ddraw.render.height);
|
2023-12-30 22:16:55 +01:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
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;
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
2021-06-11 20:30:43 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
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);
|
|
|
|
g_ddraw.render.unscale_h = ((float)g_ddraw.height / g_ddraw.render.viewport.height);
|
2023-08-01 07:59:22 +02:00
|
|
|
|
2024-05-12 21:35:28 +02:00
|
|
|
/* Hack for games that require the cursor to be in the exact center of the screen (Worms 2 / Atlantis) */
|
|
|
|
if (g_config.center_cursor_fix)
|
|
|
|
{
|
|
|
|
g_ddraw.mouse.scale_x = ((float)(g_ddraw.render.viewport.width) / (g_ddraw.width));
|
|
|
|
g_ddraw.mouse.scale_y = ((float)(g_ddraw.render.viewport.height) / (g_ddraw.height));
|
|
|
|
g_ddraw.mouse.unscale_x = ((float)(g_ddraw.width) / (g_ddraw.render.viewport.width));
|
|
|
|
g_ddraw.mouse.unscale_y = ((float)(g_ddraw.height) / (g_ddraw.render.viewport.height));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
g_ddraw.mouse.scale_x = ((float)(g_ddraw.render.viewport.width - 1) / (g_ddraw.width - 1));
|
|
|
|
g_ddraw.mouse.scale_y = ((float)(g_ddraw.render.viewport.height - 1) / (g_ddraw.height - 1));
|
|
|
|
g_ddraw.mouse.unscale_x = ((float)(g_ddraw.width - 1) / (g_ddraw.render.viewport.width - 1));
|
|
|
|
g_ddraw.mouse.unscale_y = ((float)(g_ddraw.height - 1) / (g_ddraw.render.viewport.height - 1));
|
|
|
|
}
|
2023-09-14 16:47:28 +02:00
|
|
|
|
2024-06-02 02:02:27 +02:00
|
|
|
g_ddraw.mouse.x_adjust = g_ddraw.render.viewport.x;
|
|
|
|
g_ddraw.mouse.y_adjust = g_ddraw.render.viewport.y;
|
2024-06-02 01:54:14 +02:00
|
|
|
|
|
|
|
if (g_config.lock_mouse_top_left)
|
|
|
|
{
|
|
|
|
g_ddraw.mouse.x_adjust = 0;
|
|
|
|
g_ddraw.mouse.y_adjust = 0;
|
2024-05-29 06:16:57 +02:00
|
|
|
}
|
2021-09-19 03:04:45 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.mouse.rc.left = g_ddraw.mouse.x_adjust;
|
|
|
|
g_ddraw.mouse.rc.top = g_ddraw.mouse.y_adjust;
|
|
|
|
g_ddraw.mouse.rc.right = g_ddraw.width + g_ddraw.mouse.x_adjust;
|
|
|
|
g_ddraw.mouse.rc.bottom = g_ddraw.height + g_ddraw.mouse.y_adjust;
|
2021-09-19 03:04:45 +02:00
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.adjmouse)
|
2021-09-19 03:04:45 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.mouse.rc.right = g_ddraw.render.viewport.width + g_ddraw.mouse.x_adjust;
|
|
|
|
g_ddraw.mouse.rc.bottom = g_ddraw.render.viewport.height + g_ddraw.mouse.y_adjust;
|
2021-09-19 03:04:45 +02:00
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (nonexclusive || (g_config.nonexclusive && !g_config.windowed && g_ddraw.renderer == ogl_render_main))
|
2021-07-30 13:14:12 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.height++;
|
|
|
|
g_ddraw.render.opengl_y_align = 1;
|
2023-07-07 01:24:16 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.opengl_y_align = 0;
|
2021-07-30 13:14:12 +02:00
|
|
|
}
|
|
|
|
|
2024-06-02 08:18:35 +02:00
|
|
|
//dbg_dump_wnd_styles(real_GetWindowLongA(g_ddraw.hwnd, GWL_STYLE), real_GetWindowLongA(g_ddraw.hwnd, GWL_EXSTYLE));
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.windowed)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_config.remove_menu && GetMenu(g_ddraw.hwnd))
|
|
|
|
SetMenu(g_ddraw.hwnd, NULL);
|
2023-08-10 19:47:46 +02:00
|
|
|
|
2024-05-06 02:00:58 +02:00
|
|
|
if (!IsWine())
|
2023-07-09 06:25:37 +02:00
|
|
|
{
|
|
|
|
MSG msg; /* workaround for "Not Responding" window problem in cnc games */
|
2024-03-22 22:27:00 +01:00
|
|
|
real_PeekMessageA(&msg, g_ddraw.hwnd, 0, 0, PM_NOREMOVE | PM_QS_INPUT);
|
2023-07-09 06:25:37 +02:00
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
|
|
|
|
if (!border)
|
|
|
|
{
|
2021-06-11 20:30:43 +02:00
|
|
|
real_SetWindowLongA(
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.hwnd,
|
2021-06-11 20:30:43 +02:00
|
|
|
GWL_STYLE,
|
2022-09-21 21:24:04 +02:00
|
|
|
real_GetWindowLongA(
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.hwnd,
|
2024-04-20 00:34:46 +02:00
|
|
|
GWL_STYLE) & ~(WS_CAPTION | WS_THICKFRAME | WS_MINIMIZE | WS_MAXIMIZE | WS_SYSMENU));
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-06-11 20:30:43 +02:00
|
|
|
real_SetWindowLongA(
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.hwnd,
|
2021-06-11 20:30:43 +02:00
|
|
|
GWL_STYLE,
|
2024-05-29 04:28:05 +02:00
|
|
|
(real_GetWindowLongA(g_ddraw.hwnd, GWL_STYLE) | WS_OVERLAPPEDWINDOW) & ~(WS_MAXIMIZE));
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
LONG exstyle = real_GetWindowLongA(g_ddraw.hwnd, GWL_EXSTYLE);
|
2023-07-29 08:51:56 +02:00
|
|
|
|
|
|
|
if ((exstyle & WS_EX_TOOLWINDOW))
|
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
real_SetWindowLongA(g_ddraw.hwnd, GWL_EXSTYLE, exstyle & ~(WS_EX_TOOLWINDOW));
|
2023-07-29 08:51:56 +02:00
|
|
|
}
|
|
|
|
|
2024-05-21 06:55:23 +02:00
|
|
|
exstyle = real_GetWindowLongA(g_ddraw.hwnd, GWL_EXSTYLE);
|
|
|
|
|
|
|
|
if ((exstyle & WS_EX_CLIENTEDGE))
|
|
|
|
{
|
|
|
|
real_SetWindowLongA(g_ddraw.hwnd, GWL_EXSTYLE, exstyle & ~(WS_EX_CLIENTEDGE));
|
|
|
|
}
|
|
|
|
|
2024-05-24 02:26:46 +02:00
|
|
|
if (!g_config.wine_allow_resize && IsWine())
|
2023-08-10 11:33:19 +02:00
|
|
|
{
|
|
|
|
real_SetWindowLongA(
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.hwnd,
|
2023-08-10 11:33:19 +02:00
|
|
|
GWL_STYLE,
|
2024-03-22 22:27:00 +01:00
|
|
|
(real_GetWindowLongA(g_ddraw.hwnd, GWL_STYLE) | WS_MINIMIZEBOX) & ~(WS_MAXIMIZEBOX | WS_THICKFRAME));
|
2023-08-10 11:33:19 +02:00
|
|
|
}
|
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
/* center the window with correct dimensions */
|
2024-03-22 22:27:00 +01:00
|
|
|
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);
|
2021-06-11 20:30:43 +02:00
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.fullscreen)
|
2022-10-03 13:20:59 +02:00
|
|
|
{
|
|
|
|
x = y = 0;
|
2024-04-20 00:34:46 +02:00
|
|
|
|
2024-04-20 04:41:04 +02:00
|
|
|
if (GetMenu(g_ddraw.hwnd))
|
2024-04-20 00:34:46 +02:00
|
|
|
{
|
|
|
|
y = real_GetSystemMetrics(SM_CYMENU);
|
|
|
|
}
|
2022-10-03 13:20:59 +02:00
|
|
|
}
|
2023-08-24 19:18:12 +02:00
|
|
|
else if (border && g_config.window_rect.top == -32000 && y < 0)
|
|
|
|
{
|
|
|
|
/* Make window titlebar visible if window does not fit into screen */
|
|
|
|
y = real_GetSystemMetrics(SM_CYCAPTION) + real_GetSystemMetrics(SM_CYSIZEFRAME);
|
|
|
|
}
|
2022-10-03 13:20:59 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (util_is_minimized(g_ddraw.hwnd))
|
|
|
|
real_ShowWindow(g_ddraw.hwnd, SW_RESTORE);
|
2022-10-14 22:20:14 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
RECT dst = { x, y, g_ddraw.render.width + x, g_ddraw.render.height + y };
|
2021-06-11 20:30:43 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
LONG style = real_GetWindowLongA(g_ddraw.hwnd, GWL_STYLE);
|
|
|
|
exstyle = real_GetWindowLongA(g_ddraw.hwnd, GWL_EXSTYLE);
|
2023-07-07 20:43:54 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
AdjustWindowRectEx(&dst, style, GetMenu(g_ddraw.hwnd) != NULL, exstyle);
|
2022-09-21 21:13:08 +02:00
|
|
|
|
2023-07-08 04:11:26 +02:00
|
|
|
real_SetWindowPos(
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.hwnd,
|
2023-07-08 04:11:26 +02:00
|
|
|
HWND_NOTOPMOST,
|
|
|
|
dst.left,
|
|
|
|
dst.top,
|
|
|
|
(dst.right - dst.left),
|
|
|
|
(dst.bottom - dst.top),
|
|
|
|
SWP_SHOWWINDOW | SWP_FRAMECHANGED);
|
2022-09-21 21:13:08 +02:00
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
|
|
|
|
BOOL d3d9_active = FALSE;
|
2020-10-13 11:29:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.renderer == d3d9_render_main)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
|
|
|
d3d9_active = d3d9_create();
|
2020-10-13 11:29:52 +02:00
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
if (!d3d9_active)
|
|
|
|
{
|
|
|
|
d3d9_release();
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.show_driver_warning = TRUE;
|
|
|
|
g_ddraw.renderer = gdi_render_main;
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
}
|
2024-07-22 09:02:31 +02:00
|
|
|
else if (g_ddraw.renderer == ogl_render_main)
|
|
|
|
{
|
|
|
|
if (!ogl_create())
|
|
|
|
{
|
|
|
|
ogl_release();
|
|
|
|
g_ddraw.show_driver_warning = TRUE;
|
|
|
|
g_ddraw.renderer = gdi_render_main;
|
|
|
|
}
|
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (lock_mouse || (g_config.fullscreen && real_GetForegroundWindow() == g_ddraw.hwnd))
|
2020-10-13 09:20:52 +02:00
|
|
|
mouse_lock();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2024-04-20 04:41:04 +02:00
|
|
|
int menu_height = 0;
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (GetMenu(g_ddraw.hwnd))
|
2024-04-20 04:41:04 +02:00
|
|
|
{
|
|
|
|
if (g_config.remove_menu || !g_config.nonexclusive)
|
|
|
|
{
|
|
|
|
SetMenu(g_ddraw.hwnd, NULL);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
menu_height = real_GetSystemMetrics(SM_CYMENU);
|
|
|
|
}
|
|
|
|
}
|
2023-07-07 20:43:54 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
LONG style = real_GetWindowLongA(g_ddraw.hwnd, GWL_STYLE);
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2022-09-28 21:07:06 +02:00
|
|
|
DWORD swp_flags = SWP_SHOWWINDOW;
|
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
if ((style & WS_CAPTION))
|
|
|
|
{
|
2022-09-28 21:07:06 +02:00
|
|
|
swp_flags |= SWP_FRAMECHANGED;
|
|
|
|
|
2021-06-11 20:30:43 +02:00
|
|
|
real_SetWindowLongA(
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.hwnd,
|
2021-06-11 20:30:43 +02:00
|
|
|
GWL_STYLE,
|
|
|
|
style & ~(WS_CAPTION | WS_THICKFRAME | WS_MINIMIZE | WS_MAXIMIZE | WS_SYSMENU));
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
LONG exstyle = real_GetWindowLongA(g_ddraw.hwnd, GWL_EXSTYLE);
|
2023-07-29 08:51:56 +02:00
|
|
|
|
|
|
|
if ((exstyle & WS_EX_TOOLWINDOW))
|
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
real_SetWindowLongA(g_ddraw.hwnd, GWL_EXSTYLE, exstyle & ~(WS_EX_TOOLWINDOW));
|
2023-07-29 08:51:56 +02:00
|
|
|
}
|
|
|
|
|
2024-05-21 06:55:23 +02:00
|
|
|
exstyle = real_GetWindowLongA(g_ddraw.hwnd, GWL_EXSTYLE);
|
|
|
|
|
|
|
|
if ((exstyle & WS_EX_CLIENTEDGE))
|
|
|
|
{
|
2024-05-31 02:43:20 +02:00
|
|
|
swp_flags |= SWP_FRAMECHANGED;
|
|
|
|
|
2024-05-21 06:55:23 +02:00
|
|
|
real_SetWindowLongA(g_ddraw.hwnd, GWL_EXSTYLE, exstyle & ~(WS_EX_CLIENTEDGE));
|
|
|
|
}
|
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
BOOL d3d9_active = FALSE;
|
2020-10-13 11:29:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.renderer == d3d9_render_main)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.nonexclusive)
|
2023-08-14 20:07:31 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
if (util_is_minimized(g_ddraw.hwnd))
|
|
|
|
real_ShowWindow(g_ddraw.hwnd, SW_RESTORE);
|
2023-08-14 20:07:31 +02:00
|
|
|
|
|
|
|
real_SetWindowPos(
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.hwnd,
|
2023-08-14 20:07:31 +02:00
|
|
|
HWND_TOPMOST,
|
|
|
|
0,
|
|
|
|
0,
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.width,
|
2024-04-20 04:41:04 +02:00
|
|
|
g_ddraw.render.height + menu_height,
|
2023-08-14 20:07:31 +02:00
|
|
|
swp_flags);
|
2023-08-14 20:12:42 +02:00
|
|
|
|
|
|
|
swp_flags = SWP_SHOWWINDOW;
|
2023-08-14 20:07:31 +02:00
|
|
|
}
|
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
d3d9_active = d3d9_create();
|
2020-10-13 11:29:52 +02:00
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
if (!d3d9_active)
|
|
|
|
{
|
|
|
|
d3d9_release();
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.show_driver_warning = TRUE;
|
|
|
|
g_ddraw.renderer = gdi_render_main;
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
}
|
2024-07-22 09:02:31 +02:00
|
|
|
else if (g_ddraw.renderer == ogl_render_main)
|
|
|
|
{
|
|
|
|
if (!ogl_create())
|
|
|
|
{
|
|
|
|
ogl_release();
|
|
|
|
g_ddraw.show_driver_warning = TRUE;
|
|
|
|
g_ddraw.renderer = gdi_render_main;
|
|
|
|
}
|
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-02-17 06:27:18 +01:00
|
|
|
if (!d3d9_active || g_config.nonexclusive)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-07-24 07:58:55 +02:00
|
|
|
if (!zooming && ChangeDisplaySettings(&g_ddraw.render.mode, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
|
2024-02-17 06:27:18 +01:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.run = FALSE;
|
2024-02-17 06:27:18 +01:00
|
|
|
g_config.windowed = TRUE;
|
|
|
|
g_config.fullscreen = TRUE;
|
|
|
|
return dd_SetDisplayMode(dwWidth, dwHeight, dwBPP, dwFlags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Fix wayland bug:
|
|
|
|
ChangeDisplaySettings fails silently - enable borderless mode in case display resolution was not changed
|
|
|
|
*/
|
2024-05-06 02:00:58 +02:00
|
|
|
if (IsWine() &&
|
2024-03-22 22:27:00 +01:00
|
|
|
(g_ddraw.render.mode.dmPelsWidth != real_GetSystemMetrics(SM_CXSCREEN) ||
|
|
|
|
g_ddraw.render.mode.dmPelsHeight != real_GetSystemMetrics(SM_CYSCREEN)))
|
2024-02-17 06:27:18 +01:00
|
|
|
{
|
2024-02-17 06:33:56 +01:00
|
|
|
ChangeDisplaySettings(NULL, 0);
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.run = FALSE;
|
2024-02-17 06:27:18 +01:00
|
|
|
g_config.windowed = TRUE;
|
|
|
|
g_config.fullscreen = TRUE;
|
|
|
|
return dd_SetDisplayMode(dwWidth, dwHeight, dwBPP, dwFlags);
|
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2024-05-06 02:00:58 +02:00
|
|
|
if (IsWine())
|
2020-10-13 11:29:52 +02:00
|
|
|
{
|
2022-09-21 21:24:04 +02:00
|
|
|
real_SetWindowLongA(
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.hwnd,
|
2022-09-21 21:24:04 +02:00
|
|
|
GWL_STYLE,
|
2024-03-22 22:27:00 +01:00
|
|
|
real_GetWindowLongA(g_ddraw.hwnd, GWL_STYLE) | WS_MINIMIZEBOX);
|
2020-10-13 11:29:52 +02:00
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (util_is_minimized(g_ddraw.hwnd))
|
|
|
|
real_ShowWindow(g_ddraw.hwnd, SW_RESTORE);
|
2022-10-14 23:00:23 +02:00
|
|
|
|
2021-06-11 20:30:43 +02:00
|
|
|
real_SetWindowPos(
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.hwnd,
|
2021-06-11 20:30:43 +02:00
|
|
|
HWND_TOPMOST,
|
|
|
|
0,
|
|
|
|
0,
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.width,
|
2024-04-20 04:41:04 +02:00
|
|
|
g_ddraw.render.height + menu_height,
|
2022-09-28 21:07:06 +02:00
|
|
|
swp_flags);
|
2021-06-11 20:30:43 +02:00
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
if (d3d9_active && g_config.nonexclusive)
|
2023-08-15 06:27:54 +02:00
|
|
|
d3d9_reset(TRUE);
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.last_set_window_pos_tick = timeGetTime();
|
2020-10-13 09:20:52 +02:00
|
|
|
|
|
|
|
mouse_lock();
|
|
|
|
}
|
2021-06-11 20:30:43 +02:00
|
|
|
|
2024-07-14 07:59:39 +02:00
|
|
|
/* Age Of Empires 2 textbox align */
|
2024-07-14 07:21:07 +02:00
|
|
|
if (g_ddraw.textbox.hwnd &&
|
|
|
|
g_ddraw.textbox.x &&
|
|
|
|
g_ddraw.textbox.y &&
|
|
|
|
IsWindow(g_ddraw.textbox.hwnd) &&
|
|
|
|
GetParent(g_ddraw.textbox.hwnd) == g_ddraw.hwnd)
|
|
|
|
{
|
|
|
|
char class_name[MAX_PATH] = { 0 };
|
|
|
|
GetClassNameA(g_ddraw.textbox.hwnd, class_name, sizeof(class_name) - 1);
|
|
|
|
|
|
|
|
if (_strcmpi(class_name, "Edit") == 0)
|
|
|
|
{
|
|
|
|
real_SetWindowPos(
|
|
|
|
g_ddraw.textbox.hwnd,
|
|
|
|
0,
|
2024-07-18 01:50:31 +02:00
|
|
|
(int)(g_ddraw.render.viewport.x + (g_ddraw.textbox.x * g_ddraw.render.scale_w)),
|
|
|
|
(int)(g_ddraw.render.viewport.y + (g_ddraw.textbox.y * g_ddraw.render.scale_h)),
|
2024-07-14 07:21:07 +02:00
|
|
|
0,
|
|
|
|
0,
|
|
|
|
SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
RedrawWindow(g_ddraw.hwnd, NULL, NULL, RDW_ERASE | RDW_INVALIDATE);
|
2023-07-08 00:28:17 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.render.viewport.x != 0 || g_ddraw.render.viewport.y != 0)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
InterlockedExchange(&g_ddraw.render.clear_screen, TRUE);
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.render.thread == NULL)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
InterlockedExchange(&g_ddraw.render.palette_updated, TRUE);
|
|
|
|
InterlockedExchange(&g_ddraw.render.surface_updated, TRUE);
|
|
|
|
ReleaseSemaphore(g_ddraw.render.sem, 1, NULL);
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)g_ddraw.renderer, NULL, 0, NULL);
|
|
|
|
SetThreadPriority(g_ddraw.render.thread, THREAD_PRIORITY_ABOVE_NORMAL);
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
if ((dwFlags & SDM_MODE_SET_BY_GAME) && !g_config.infantryhack)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
real_SendMessageA(g_ddraw.hwnd, WM_SIZE_DDRAW, 0, MAKELPARAM(g_ddraw.width, g_ddraw.height));
|
|
|
|
real_SendMessageA(g_ddraw.hwnd, WM_DISPLAYCHANGE_DDRAW, g_ddraw.bpp, MAKELPARAM(g_ddraw.width, g_ddraw.height));
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
HRESULT dd_SetCooperativeLevel(HWND hwnd, DWORD dwFlags)
|
|
|
|
{
|
2022-09-30 14:16:30 +02:00
|
|
|
dbg_dump_scl_flags(dwFlags);
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-05-22 23:51:48 +02:00
|
|
|
if (!hwnd)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-05-22 23:51:48 +02:00
|
|
|
if (!g_ddraw.hwnd && g_config.fake_mode[0])
|
|
|
|
{
|
|
|
|
EnumThreadWindows(GetCurrentThreadId(), (WNDENUMPROC)util_enum_thread_wnd_proc, 0);
|
|
|
|
hwnd = g_ddraw.hwnd;
|
|
|
|
|
|
|
|
if (!hwnd)
|
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return DD_OK;
|
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2024-05-22 23:51:48 +02:00
|
|
|
if (!g_ddraw.hwnd)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.hwnd = hwnd;
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (!g_ddraw.wndproc)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-06-02 22:17:26 +02:00
|
|
|
hook_init();
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.wndproc = (WNDPROC)real_SetWindowLongA(g_ddraw.hwnd, GWL_WNDPROC, (LONG)fake_WndProc);
|
|
|
|
g_ddraw.gui_thread_id = GetWindowThreadProcessId(g_ddraw.hwnd, NULL);
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (!g_ddraw.render.hdc)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.hdc = GetDC(g_ddraw.hwnd);
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-06-21 23:00:40 +02:00
|
|
|
if (g_ddraw.renderer == ogl_render_main)
|
|
|
|
{
|
|
|
|
PIXELFORMATDESCRIPTOR pfd;
|
|
|
|
memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
|
|
|
|
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
|
2021-06-11 20:30:43 +02:00
|
|
|
|
2024-06-21 23:00:40 +02:00
|
|
|
pfd.nVersion = 1;
|
|
|
|
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER | PFD_SUPPORT_OPENGL;
|
|
|
|
pfd.iPixelType = PFD_TYPE_RGBA;
|
|
|
|
pfd.cColorBits = g_ddraw.mode.dmBitsPerPel;
|
|
|
|
pfd.iLayerType = PFD_MAIN_PLANE;
|
2020-10-13 21:58:04 +02:00
|
|
|
|
2024-06-21 23:00:40 +02:00
|
|
|
SetPixelFormat(g_ddraw.render.hdc, ChoosePixelFormat(g_ddraw.render.hdc, &pfd), &pfd);
|
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
if (!g_config.devmode)
|
2021-06-19 04:28:15 +02:00
|
|
|
{
|
|
|
|
HCURSOR cursor = real_SetCursor(LoadCursor(NULL, IDC_ARROW));
|
2023-07-07 23:54:59 +02:00
|
|
|
|
|
|
|
if (cursor != LoadCursor(NULL, IDC_WAIT))
|
2024-03-22 22:27:00 +01:00
|
|
|
InterlockedExchange((LONG*)&g_ddraw.old_cursor, (LONG)cursor);
|
2021-06-19 04:28:15 +02:00
|
|
|
}
|
|
|
|
|
2021-06-17 04:12:05 +02:00
|
|
|
int cursor_count = real_ShowCursor(TRUE) - 1;
|
2024-03-22 22:27:00 +01:00
|
|
|
InterlockedExchange((LONG*)&g_ddraw.show_cursor_count, cursor_count);
|
2021-06-17 04:12:05 +02:00
|
|
|
real_ShowCursor(FALSE);
|
|
|
|
|
2021-06-16 05:57:19 +02:00
|
|
|
/* Make sure the cursor is visible in windowed mode initially */
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.windowed && !g_config.fullscreen && !g_config.devmode && cursor_count < 0)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2021-06-19 04:28:15 +02:00
|
|
|
while (real_ShowCursor(TRUE) < 0);
|
2021-06-16 05:57:19 +02:00
|
|
|
}
|
2021-06-16 07:47:15 +02:00
|
|
|
|
2023-08-02 06:13:53 +02:00
|
|
|
/* Starcraft locks the cursor before ddraw.dll was loaded */
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.windowed)
|
2023-08-02 06:13:53 +02:00
|
|
|
{
|
|
|
|
real_ClipCursor(NULL);
|
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
GetWindowText(g_ddraw.hwnd, (LPTSTR)&g_ddraw.title, sizeof(g_ddraw.title));
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.isredalert = strcmp(g_ddraw.title, "Red Alert") == 0;
|
|
|
|
g_ddraw.iscnc1 = strcmp(g_ddraw.title, "Command & Conquer") == 0;
|
|
|
|
g_ddraw.iskkndx = strcmp(g_ddraw.title, "KKND Xtreme") == 0;
|
2024-05-08 05:54:56 +02:00
|
|
|
g_ddraw.isworms2 = strcmp(g_ddraw.title, "worms2") == 0;
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-05-08 07:17:54 +02:00
|
|
|
if (g_ddraw.iskkndx)
|
2021-05-15 00:41:50 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.upscale_hack_width = 640;
|
|
|
|
g_ddraw.upscale_hack_height = 480;
|
2021-05-15 00:41:50 +02:00
|
|
|
}
|
2024-03-22 22:27:00 +01:00
|
|
|
else if (g_ddraw.isredalert || g_ddraw.iscnc1)
|
2021-05-15 00:41:50 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.upscale_hack_width = 640;
|
|
|
|
g_ddraw.upscale_hack_height = 400;
|
2021-05-15 00:41:50 +02:00
|
|
|
}
|
2024-05-08 07:17:54 +02:00
|
|
|
else if (g_ddraw.isworms2)
|
|
|
|
{
|
2024-05-13 04:21:54 +02:00
|
|
|
if (memcmp((char*)GetModuleHandleA(NULL) + 0x00010000, "\x17\x81\xC2\x00\x80\x00\x00\x89", 8) != 0)
|
|
|
|
{
|
|
|
|
g_ddraw.isworms2 = FALSE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
g_ddraw.upscale_hack_width = 80;
|
|
|
|
g_ddraw.upscale_hack_height = 60;
|
|
|
|
}
|
2024-05-08 07:17:54 +02:00
|
|
|
}
|
2021-05-15 00:41:50 +02:00
|
|
|
|
2024-05-08 05:54:56 +02:00
|
|
|
if (g_config.vhack && !g_ddraw.isredalert && !g_ddraw.iscnc1 && !g_ddraw.iskkndx && !g_ddraw.isworms2)
|
2020-10-13 11:29:52 +02:00
|
|
|
{
|
2023-09-22 00:38:42 +02:00
|
|
|
g_config.vhack = 0;
|
2020-10-13 11:29:52 +02:00
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2022-02-05 04:02:06 +01:00
|
|
|
/* Infantry Online Zone List Window */
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.infantryhack)
|
2022-01-24 01:35:11 +01:00
|
|
|
{
|
2024-03-28 17:48:31 +01:00
|
|
|
static BOOL windowed, fullscreen, devmode;
|
2022-02-05 04:02:06 +01:00
|
|
|
|
2022-02-17 20:22:17 +01:00
|
|
|
if (dwFlags & DDSCL_FULLSCREEN)
|
|
|
|
{
|
2023-09-22 00:38:42 +02:00
|
|
|
g_config.windowed = windowed;
|
|
|
|
g_config.fullscreen = fullscreen;
|
2024-03-28 17:48:31 +01:00
|
|
|
g_config.devmode = devmode;
|
2022-02-17 20:22:17 +01:00
|
|
|
}
|
|
|
|
else if (dwFlags & DDSCL_NOWINDOWCHANGES)
|
2022-02-05 04:02:06 +01:00
|
|
|
{
|
2023-09-22 00:38:42 +02:00
|
|
|
windowed = g_config.windowed;
|
|
|
|
fullscreen = g_config.fullscreen;
|
2024-03-28 17:48:31 +01:00
|
|
|
devmode = g_config.devmode;
|
2022-02-05 04:02:06 +01:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (GetMenu(g_ddraw.hwnd) != NULL)
|
2022-02-25 00:04:07 +01:00
|
|
|
{
|
2023-09-22 00:38:42 +02:00
|
|
|
g_config.windowed = TRUE;
|
|
|
|
g_config.fullscreen = FALSE;
|
2024-03-28 17:48:31 +01:00
|
|
|
g_config.devmode = TRUE;
|
2024-04-12 01:25:00 +02:00
|
|
|
|
|
|
|
/*
|
2024-04-12 01:37:44 +02:00
|
|
|
if (!g_config.window_rect.right && g_config.window_rect.left == -32000)
|
2024-04-12 01:25:00 +02:00
|
|
|
{
|
|
|
|
if (real_GetSystemMetrics(SM_CYSCREEN) >= 2160)
|
|
|
|
{
|
|
|
|
g_config.window_rect.right = 640 * 3;
|
|
|
|
g_config.window_rect.bottom = 480 * 3;
|
|
|
|
}
|
|
|
|
else if (real_GetSystemMetrics(SM_CYSCREEN) >= 1440)
|
|
|
|
{
|
|
|
|
g_config.window_rect.right = 640 * 2;
|
|
|
|
g_config.window_rect.bottom = 480 * 2;
|
|
|
|
}
|
|
|
|
else if (real_GetSystemMetrics(SM_CYSCREEN) >= 1080)
|
|
|
|
{
|
|
|
|
g_config.window_rect.right = (LONG)(640 * 1.5f);
|
|
|
|
g_config.window_rect.bottom = (LONG)(480 * 1.5f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*/
|
2022-02-25 00:04:07 +01:00
|
|
|
}
|
2022-02-17 20:22:17 +01:00
|
|
|
|
2022-02-17 17:00:34 +01:00
|
|
|
dd_SetDisplayMode(640, 480, 16, SDM_MODE_SET_BY_GAME);
|
2022-02-05 04:02:06 +01:00
|
|
|
}
|
2022-01-24 01:35:11 +01:00
|
|
|
}
|
|
|
|
|
2023-10-20 03:59:35 +02:00
|
|
|
if (dwFlags & DDSCL_NORMAL)
|
|
|
|
{
|
2024-05-22 23:23:27 +02:00
|
|
|
if (g_config.fake_mode[0])
|
2023-10-20 03:59:35 +02:00
|
|
|
{
|
2024-05-22 23:23:27 +02:00
|
|
|
char* e = &g_config.fake_mode[0];
|
|
|
|
|
|
|
|
unsigned long width = strtoul(e, &e, 0);
|
|
|
|
unsigned long height = strtoul(e + 1, &e, 0);
|
|
|
|
unsigned long bpp = strtoul(e + 1, &e, 0);
|
|
|
|
|
|
|
|
dd_SetDisplayMode(width, height, bpp, 0);
|
2023-10-20 03:59:35 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
|
2021-06-11 20:30:43 +02:00
|
|
|
HRESULT dd_WaitForVerticalBlank(DWORD dwFlags, HANDLE hEvent)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2023-09-22 00:38:42 +02:00
|
|
|
if (g_config.maxgameticks == -2)
|
2021-02-19 03:24:11 +01:00
|
|
|
{
|
2024-05-04 07:19:02 +02:00
|
|
|
/* Workaround for DwmFlush() freeze (e.g. slow alt+tab) issue on windows 7 SP1 */
|
2024-05-06 02:00:58 +02:00
|
|
|
if (g_ddraw.renderer == ogl_render_main && !IsWine() && !IsWindows8OrGreater())
|
2024-05-04 07:19:02 +02:00
|
|
|
{
|
|
|
|
if (fpsl_wait_for_vblank())
|
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (fpsl_dwm_flush() || fpsl_wait_for_vblank())
|
|
|
|
return DD_OK;
|
|
|
|
}
|
2021-02-19 03:24:11 +01:00
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (!g_ddraw.flip_limiter.tick_length)
|
2020-10-13 09:20:52 +02:00
|
|
|
return DD_OK;
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.flip_limiter.htimer)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2023-08-01 13:47:27 +02:00
|
|
|
FILETIME ft = { 0 };
|
|
|
|
GetSystemTimeAsFileTime(&ft);
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (CompareFileTime((FILETIME*)&g_ddraw.flip_limiter.due_time, &ft) == -1)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
memcpy(&g_ddraw.flip_limiter.due_time, &ft, sizeof(LARGE_INTEGER));
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
WaitForSingleObject(g_ddraw.flip_limiter.htimer, g_ddraw.flip_limiter.tick_length * 2);
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
2023-08-01 13:47:27 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.flip_limiter.due_time.QuadPart += g_ddraw.flip_limiter.tick_length_ns;
|
|
|
|
SetWaitableTimer(g_ddraw.flip_limiter.htimer, &g_ddraw.flip_limiter.due_time, 0, NULL, NULL, FALSE);
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
static DWORD next_game_tick;
|
2020-10-13 11:29:52 +02:00
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
if (!next_game_tick)
|
|
|
|
{
|
|
|
|
next_game_tick = timeGetTime();
|
|
|
|
return DD_OK;
|
|
|
|
}
|
2020-10-13 11:29:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
next_game_tick += g_ddraw.flip_limiter.tick_length;
|
2020-10-13 09:20:52 +02:00
|
|
|
DWORD tick_count = timeGetTime();
|
|
|
|
|
|
|
|
int sleep_time = next_game_tick - tick_count;
|
2020-10-13 11:29:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (sleep_time <= 0 || sleep_time > g_ddraw.flip_limiter.tick_length)
|
2020-10-13 11:29:52 +02:00
|
|
|
{
|
2020-10-13 09:20:52 +02:00
|
|
|
next_game_tick = tick_count;
|
2020-10-13 11:29:52 +02:00
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
else
|
2020-10-13 11:29:52 +02:00
|
|
|
{
|
2020-10-13 09:20:52 +02:00
|
|
|
Sleep(sleep_time);
|
2020-10-13 11:29:52 +02:00
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
ULONG dd_AddRef()
|
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
return InterlockedIncrement(&g_ddraw.ref);
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
ULONG dd_Release()
|
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
LONG ref = InterlockedDecrement(&g_ddraw.ref);
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (ref == 0)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.bpp)
|
2020-10-15 01:17:40 +02:00
|
|
|
{
|
2020-10-13 09:20:52 +02:00
|
|
|
cfg_save();
|
2020-10-15 01:17:40 +02:00
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-06-08 22:08:23 +02:00
|
|
|
if (g_ddraw.render.run)
|
|
|
|
{
|
|
|
|
EnterCriticalSection(&g_ddraw.cs);
|
|
|
|
g_ddraw.render.run = FALSE;
|
|
|
|
ReleaseSemaphore(g_ddraw.render.sem, 1, NULL);
|
|
|
|
LeaveCriticalSection(&g_ddraw.cs);
|
|
|
|
|
|
|
|
if (g_ddraw.render.thread)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(g_ddraw.render.thread, INFINITE);
|
|
|
|
g_ddraw.render.thread = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!g_config.windowed)
|
|
|
|
{
|
|
|
|
if (g_ddraw.renderer == d3d9_render_main && !g_config.nonexclusive)
|
|
|
|
{
|
|
|
|
if (!d3d9_reset(TRUE))
|
|
|
|
d3d9_release();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ChangeDisplaySettings(NULL, 0);
|
|
|
|
}
|
|
|
|
}
|
2020-10-13 09:20:52 +02:00
|
|
|
|
2024-07-22 09:02:31 +02:00
|
|
|
if (g_ddraw.renderer == ogl_render_main)
|
|
|
|
{
|
|
|
|
ogl_release();
|
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.render.hdc)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
ReleaseDC(g_ddraw.hwnd, g_ddraw.render.hdc);
|
|
|
|
g_ddraw.render.hdc = NULL;
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.ticks_limiter.htimer)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
CancelWaitableTimer(g_ddraw.ticks_limiter.htimer);
|
|
|
|
CloseHandle(g_ddraw.ticks_limiter.htimer);
|
|
|
|
g_ddraw.ticks_limiter.htimer = NULL;
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.flip_limiter.htimer)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
CancelWaitableTimer(g_ddraw.flip_limiter.htimer);
|
|
|
|
CloseHandle(g_ddraw.flip_limiter.htimer);
|
|
|
|
g_ddraw.flip_limiter.htimer = NULL;
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2021-02-02 18:15:25 +01:00
|
|
|
if (g_fpsl.htimer)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2021-02-02 18:15:25 +01:00
|
|
|
CancelWaitableTimer(g_fpsl.htimer);
|
|
|
|
CloseHandle(g_fpsl.htimer);
|
|
|
|
g_fpsl.htimer = NULL;
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.real_dd)
|
2021-05-29 20:52:57 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.real_dd->lpVtbl->Release(g_ddraw.real_dd);
|
2021-05-29 20:52:57 +02:00
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
DeleteCriticalSection(&g_ddraw.cs);
|
2020-10-13 09:20:52 +02:00
|
|
|
|
|
|
|
/* restore old wndproc, subsequent ddraw creation will otherwise fail */
|
2024-03-22 22:27:00 +01:00
|
|
|
if (g_ddraw.hwnd)
|
2023-07-28 05:50:23 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
real_SetWindowLongA(g_ddraw.hwnd, GWL_WNDPROC, (LONG)g_ddraw.wndproc);
|
2023-07-28 05:50:23 +02:00
|
|
|
}
|
2024-03-22 22:27:00 +01:00
|
|
|
|
|
|
|
memset(&g_ddraw, 0, sizeof(g_ddraw));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2020-10-13 11:29:52 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
if (ref < 0)
|
|
|
|
{
|
|
|
|
InterlockedExchange(&g_ddraw.ref, 0);
|
2020-10-13 09:20:52 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
return (ULONG)ref;
|
2020-10-13 09:20:52 +02:00
|
|
|
}
|
|
|
|
|
2021-06-14 09:57:26 +02:00
|
|
|
HRESULT dd_GetAvailableVidMem(LPDDSCAPS lpDDCaps, LPDWORD lpdwTotal, LPDWORD lpdwFree)
|
2020-10-13 09:20:52 +02:00
|
|
|
{
|
2021-08-02 17:13:31 +02:00
|
|
|
if (lpdwTotal)
|
|
|
|
*lpdwTotal = 16777216;
|
|
|
|
|
|
|
|
if (lpdwFree)
|
|
|
|
*lpdwFree = 16777216;
|
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
HRESULT dd_GetVerticalBlankStatus(LPBOOL lpbIsInVB)
|
|
|
|
{
|
2021-09-02 22:22:48 +02:00
|
|
|
if (lpbIsInVB)
|
|
|
|
*lpbIsInVB = TRUE;
|
|
|
|
|
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
|
2024-05-31 21:43:33 +02:00
|
|
|
HRESULT dd_TestCooperativeLevel()
|
|
|
|
{
|
|
|
|
if (g_config.limiter_type == LIMIT_TESTCOOP && g_ddraw.ticks_limiter.tick_length > 0)
|
|
|
|
{
|
|
|
|
g_ddraw.ticks_limiter.dds_unlock_limiter_disabled = TRUE;
|
|
|
|
util_limit_game_ticks();
|
|
|
|
}
|
|
|
|
|
|
|
|
return g_config.tlc_hack ? DDERR_NOEXCLUSIVEMODE : DD_OK;
|
|
|
|
}
|
|
|
|
|
2021-09-02 22:22:48 +02:00
|
|
|
HRESULT dd_GetDeviceIdentifier(LPDDDEVICEIDENTIFIER pDDDI, DWORD dwFlags, REFIID riid)
|
|
|
|
{
|
|
|
|
if (!pDDDI)
|
|
|
|
return DDERR_INVALIDPARAMS;
|
|
|
|
|
|
|
|
if (IsEqualGUID(&IID_IDirectDraw7, riid))
|
|
|
|
{
|
|
|
|
memset(pDDDI, 0, sizeof(DDDEVICEIDENTIFIER2));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
memset(pDDDI, 0, sizeof(DDDEVICEIDENTIFIER));
|
|
|
|
}
|
|
|
|
|
2020-10-13 09:20:52 +02:00
|
|
|
return DD_OK;
|
|
|
|
}
|
2020-10-15 05:13:37 +02:00
|
|
|
|
|
|
|
HRESULT dd_CreateEx(GUID* lpGuid, LPVOID* lplpDD, REFIID iid, IUnknown* pUnkOuter)
|
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
if (InterlockedExchangeAdd((LONG*)&g_ddraw.ref, 0) == 0)
|
2021-05-08 23:42:29 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
InterlockedIncrement(&g_ddraw.ref);
|
2021-05-08 23:42:29 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
InitializeCriticalSection(&g_ddraw.cs);
|
2020-10-15 05:13:37 +02:00
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.render.sem = CreateSemaphore(NULL, 0, 1, NULL);
|
2022-09-19 13:13:34 +02:00
|
|
|
g_blt_use_avx = util_is_avx_supported();
|
2021-05-08 23:42:29 +02:00
|
|
|
|
2023-09-23 17:48:06 +02:00
|
|
|
if (g_config.minfps > 1000)
|
|
|
|
g_config.minfps = 1000;
|
|
|
|
|
|
|
|
if (g_config.minfps > 0)
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.minfps_tick_len = (DWORD)(1000.0f / g_config.minfps);
|
2023-09-23 17:48:06 +02:00
|
|
|
|
2024-06-15 05:28:06 +02:00
|
|
|
|
|
|
|
HANDLE (WINAPI *createTimerExW)(LPSECURITY_ATTRIBUTES, LPCWSTR, DWORD, DWORD) = NULL;
|
|
|
|
|
|
|
|
if (!IsWine() && IsWindows10Version1803OrGreater())
|
|
|
|
{
|
|
|
|
createTimerExW = (void*)real_GetProcAddress(real_LoadLibraryA("Kernel32.dll"), "CreateWaitableTimerExW");
|
|
|
|
}
|
|
|
|
|
|
|
|
DWORD timer_flags = CREATE_WAITABLE_TIMER_MANUAL_RESET | CREATE_WAITABLE_TIMER_HIGH_RESOLUTION;
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
/* can't fully set it up here due to missing g_ddraw.mode.dmDisplayFrequency */
|
2024-06-15 05:28:06 +02:00
|
|
|
g_fpsl.htimer = createTimerExW ? createTimerExW(NULL, NULL, timer_flags, TIMER_ALL_ACCESS) : NULL;
|
|
|
|
|
|
|
|
if (!g_fpsl.htimer)
|
|
|
|
g_fpsl.htimer = CreateWaitableTimer(NULL, TRUE, NULL);
|
2023-09-22 00:38:42 +02:00
|
|
|
|
|
|
|
if (g_config.maxgameticks > 0 && g_config.maxgameticks <= 1000)
|
|
|
|
{
|
2024-06-15 05:28:06 +02:00
|
|
|
g_ddraw.ticks_limiter.htimer = createTimerExW ? createTimerExW(NULL, NULL, timer_flags, TIMER_ALL_ACCESS) : NULL;
|
|
|
|
|
|
|
|
if (!g_ddraw.ticks_limiter.htimer)
|
|
|
|
g_ddraw.ticks_limiter.htimer = CreateWaitableTimer(NULL, TRUE, NULL);
|
2023-09-22 00:38:42 +02:00
|
|
|
|
|
|
|
float len = 1000.0f / g_config.maxgameticks;
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.ticks_limiter.tick_length_ns = (LONGLONG)(len * 10000);
|
|
|
|
g_ddraw.ticks_limiter.tick_length = (DWORD)(len + 0.5f);
|
2023-09-22 00:38:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (g_config.maxgameticks >= 0 || g_config.maxgameticks == -2)
|
|
|
|
{
|
|
|
|
/* always using 60 fps for flip... */
|
2024-06-15 05:28:06 +02:00
|
|
|
g_ddraw.flip_limiter.htimer = createTimerExW ? createTimerExW(NULL, NULL, timer_flags, TIMER_ALL_ACCESS) : NULL;
|
|
|
|
|
|
|
|
if (!g_ddraw.flip_limiter.htimer)
|
|
|
|
g_ddraw.flip_limiter.htimer = CreateWaitableTimer(NULL, TRUE, NULL);
|
2023-09-22 00:38:42 +02:00
|
|
|
|
|
|
|
float flip_len = 1000.0f / 60;
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.flip_limiter.tick_length_ns = (LONGLONG)(flip_len * 10000);
|
|
|
|
g_ddraw.flip_limiter.tick_length = (DWORD)(flip_len + 0.5f);
|
2023-09-22 00:38:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
DWORD system_affinity;
|
|
|
|
DWORD proc_affinity;
|
|
|
|
HANDLE proc = GetCurrentProcess();
|
|
|
|
|
|
|
|
if (g_config.singlecpu)
|
|
|
|
{
|
|
|
|
SetProcessAffinityMask(proc, 1);
|
|
|
|
}
|
|
|
|
else if (GetProcessAffinityMask(proc, &proc_affinity, &system_affinity))
|
|
|
|
{
|
|
|
|
SetProcessAffinityMask(proc, system_affinity);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (GetProcessAffinityMask(proc, &proc_affinity, &system_affinity))
|
|
|
|
{
|
|
|
|
TRACE(" proc_affinity=%08X, system_affinity=%08X\n", proc_affinity, system_affinity);
|
|
|
|
}
|
|
|
|
|
2023-10-21 06:27:59 +02:00
|
|
|
|
2023-09-22 00:38:42 +02:00
|
|
|
if (_strcmpi(g_config.renderer, "direct3d9on12") == 0)
|
|
|
|
{
|
2024-03-11 17:48:27 +01:00
|
|
|
g_config.d3d9on12 = TRUE;
|
2023-09-22 00:38:42 +02:00
|
|
|
}
|
|
|
|
else if (_strcmpi(g_config.renderer, "openglcore") == 0)
|
|
|
|
{
|
2024-03-11 17:48:27 +01:00
|
|
|
g_config.opengl_core = TRUE;
|
2023-09-22 00:38:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (tolower(g_config.renderer[0]) == 'd') /* direct3d9 or direct3d9on12*/
|
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.renderer = d3d9_render_main;
|
2023-09-22 00:38:42 +02:00
|
|
|
}
|
|
|
|
else if (tolower(g_config.renderer[0]) == 's' || tolower(g_config.renderer[0]) == 'g') /* gdi */
|
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.renderer = gdi_render_main;
|
2023-09-22 00:38:42 +02:00
|
|
|
}
|
|
|
|
else if (tolower(g_config.renderer[0]) == 'o') /* opengl or openglcore */
|
|
|
|
{
|
|
|
|
if (oglu_load_dll())
|
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.renderer = ogl_render_main;
|
2023-09-22 00:38:42 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.show_driver_warning = TRUE;
|
|
|
|
g_ddraw.renderer = gdi_render_main;
|
2023-09-22 00:38:42 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else /* auto */
|
|
|
|
{
|
2024-05-06 02:00:58 +02:00
|
|
|
if (!IsWine() && d3d9_is_available())
|
2023-09-22 00:38:42 +02:00
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.renderer = d3d9_render_main;
|
2023-09-22 00:38:42 +02:00
|
|
|
}
|
|
|
|
else if (oglu_load_dll())
|
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.renderer = ogl_render_main;
|
2023-09-22 00:38:42 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2024-03-22 22:27:00 +01:00
|
|
|
g_ddraw.show_driver_warning = TRUE;
|
|
|
|
g_ddraw.renderer = gdi_render_main;
|
2023-09-22 00:38:42 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-22 22:27:00 +01:00
|
|
|
LONG ref = InterlockedDecrement(&g_ddraw.ref);
|
|
|
|
|
|
|
|
if (ref < 0)
|
|
|
|
InterlockedExchange(&g_ddraw.ref, 0);
|
2021-05-08 23:42:29 +02:00
|
|
|
}
|
2024-03-09 21:38:24 +01:00
|
|
|
|
2020-10-15 05:13:37 +02:00
|
|
|
IDirectDrawImpl* dd = (IDirectDrawImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawImpl));
|
2021-09-02 22:22:48 +02:00
|
|
|
memcpy(&dd->guid, iid, sizeof(dd->guid));
|
2021-06-11 20:30:43 +02:00
|
|
|
|
2021-09-02 22:22:48 +02:00
|
|
|
if (IsEqualGUID(&IID_IDirectDraw, iid))
|
2020-10-15 05:13:37 +02:00
|
|
|
{
|
2021-06-11 20:30:43 +02:00
|
|
|
TRACE(" GUID = %08X (IID_IDirectDraw), ddraw = %p\n", ((GUID*)iid)->Data1, dd);
|
2020-10-15 05:13:37 +02:00
|
|
|
|
|
|
|
dd->lpVtbl = &g_dd_vtbl1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-09-02 22:22:48 +02:00
|
|
|
TRACE(" GUID = %08X (IID_IDirectDrawX), ddraw = %p\n", ((GUID*)iid)->Data1, dd);
|
2020-10-15 05:13:37 +02:00
|
|
|
|
|
|
|
dd->lpVtbl = &g_dd_vtblx;
|
|
|
|
}
|
|
|
|
|
|
|
|
IDirectDraw_AddRef(dd);
|
|
|
|
|
|
|
|
*lplpDD = (LPVOID)dd;
|
|
|
|
|
|
|
|
return DD_OK;
|
|
|
|
}
|