isledecomp/isle-portable
1
0
Fork 0
mirror of https://github.com/isledecomp/isle-portable.git synced 2026-02-03 12:31:15 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into emscripten

Browse Source
This commit is contained in:
Christian Semmler 2025-06-12 13:58:07 -07:00
commit eb84da0476
No known key found for this signature in database
GPG Key ID: 086DAA1360BEEE5C
15 changed files with 74 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
ISLE/isleapp.cpp
View File

@ -94,7 +94,7 @@ IsleApp::IsleApp()
m_cdPath = NULL;
m_deviceId = NULL;
m_savePath = NULL;
m_fullScreen = FALSE;
m_fullScreen = TRUE;
m_flipSurfaces = FALSE;
m_backBuffersInVram = TRUE;
m_using8bit = FALSE;
@ -378,7 +378,6 @@ SDL_AppResult SDL_AppEvent(void* appstate, SDL_Event* event)
// [library:window]
// Remaining functionality to be implemented:
// Full screen - crashes when minimizing/maximizing, but this will probably be fixed once DirectDraw is replaced
// WM_TIMER - use SDL_Timer functionality instead
#ifdef __EMSCRIPTEN__
@ -387,6 +386,17 @@ SDL_AppResult SDL_AppEvent(void* appstate, SDL_Event* event)
static bool detectedTouchEvents = false;
#endif
switch (event->type) {
case SDL_EVENT_MOUSE_MOTION:
case SDL_EVENT_MOUSE_BUTTON_DOWN:
case SDL_EVENT_MOUSE_BUTTON_UP:
IDirect3DRMMiniwinDevice* device = GetD3DRMMiniwinDevice();
if (device && !device->ConvertEventToRenderCoordinates(event)) {
SDL_Log("Failed to convert event coordinates: %s", SDL_GetError());
}
break;
}
switch (event->type) {
case SDL_EVENT_WINDOW_FOCUS_GAINED:
if (!IsleDebug_Enabled()) {

26
LEGO1/mxdirectx/legodxinfo.cpp
View File

@ -284,11 +284,6 @@ int LegoDeviceEnumerate::FUN_1009d210()
}
for (list<MxDriver>::iterator it = m_list.begin(); it != m_list.end();) {
if (!DriverSupportsRequiredDisplayMode(*it)) {
m_list.erase(it++);
continue;
}
MxDriver& driver = *it;
for (list<Direct3DDeviceInfo>::iterator it2 = driver.m_devices.begin(); it2 != driver.m_devices.end();) {
@ -315,27 +310,6 @@ int LegoDeviceEnumerate::FUN_1009d210()
return 0;
}
// FUNCTION: CONFIG 0x00402b00
// FUNCTION: LEGO1 0x1009d370
// FUNCTION: BETA10 0x1011d176
unsigned char LegoDeviceEnumerate::DriverSupportsRequiredDisplayMode(MxDriver& p_driver)
{
#ifdef __EMSCRIPTEN__
return true;
#endif
for (list<MxDisplayMode>::iterator it = p_driver.m_displayModes.begin(); it != p_driver.m_displayModes.end();
it++) {
if ((*it).m_width == 640 && (*it).m_height == 480) {
if ((*it).m_bitsPerPixel == 8 || (*it).m_bitsPerPixel == 16) {
return TRUE;
}
}
}
return FALSE;
}
// FUNCTION: CONFIG 0x00402b60
// FUNCTION: LEGO1 0x1009d3d0
// FUNCTION: BETA10 0x1011d235

1
LEGO1/mxdirectx/legodxinfo.h
View File

@ -18,7 +18,6 @@ class LegoDeviceEnumerate : public MxDeviceEnumerate {
static bool SupportsSIMD();
static bool SupportsCPUID();
int FUN_1009d210();
unsigned char DriverSupportsRequiredDisplayMode(MxDriver& p_driver);
unsigned char FUN_1009d3d0(Direct3DDeviceInfo& p_device);
// SYNTHETIC: BETA10 0x100d8d10

23
LEGO1/mxdirectx/mxdirect3d.cpp
View File

@ -167,14 +167,6 @@ BOOL MxDirect3D::D3DSetMode()
}
DeviceModesInfo::Mode mode = *CurrentMode();
if (IsFullScreen()) {
if (!IsSupportedMode(mode.width, mode.height, mode.bitsPerPixel)) {
Error("This device cannot support the current display mode", DDERR_GENERIC);
return FALSE;
}
}
LPDIRECTDRAWSURFACE frontBuffer = FrontBuffer();
LPDIRECTDRAWSURFACE backBuffer = BackBuffer();
@ -277,21 +269,6 @@ BOOL MxDirect3D::SetDevice(MxDeviceEnumerate& p_deviceEnumerate, MxDriver* p_dri
*d->m_deviceInfo->m_guid = *driver.m_guid;
}
d->m_deviceInfo->m_count = driver.m_displayModes.size();
if (d->m_deviceInfo->m_count > 0) {
int j = 0;
d->m_deviceInfo->m_modeArray = new DeviceModesInfo::Mode[d->m_deviceInfo->m_count];
for (list<MxDisplayMode>::iterator it2 = driver.m_displayModes.begin();
it2 != driver.m_displayModes.end();
it2++, j++) {
d->m_deviceInfo->m_modeArray[j].width = (*it2).m_width;
d->m_deviceInfo->m_modeArray[j].height = (*it2).m_height;
d->m_deviceInfo->m_modeArray[j].bitsPerPixel = (*it2).m_bitsPerPixel;
}
}
d->m_deviceInfo->m_ddcaps = driver.m_ddCaps;
if (i == 0) {

23
LEGO1/mxdirectx/mxdirectdraw.cpp
View File

@ -283,23 +283,6 @@ BOOL MxDirectDraw::DDInit(BOOL fullscreen)
return TRUE;
}
// FUNCTION: LEGO1 0x1009d9d0
// FUNCTION: BETA10 0x10120e45
BOOL MxDirectDraw::IsSupportedMode(int width, int height, int bpp)
{
DeviceModesInfo::Mode mode = {width, height, bpp};
assert(m_currentDevInfo);
for (int i = 0; i < m_currentDevInfo->m_count; i++) {
if (m_currentDevInfo->m_modeArray[i] == mode) {
return TRUE;
}
}
return FALSE;
}
// FUNCTION: LEGO1 0x1009da20
// FUNCTION: BETA10 0x10120efb
void EnableResizing(HWND p_hwnd, BOOL p_flag)
@ -339,12 +322,6 @@ BOOL MxDirectDraw::DDSetMode(int width, int height, int bpp)
}
#endif
if (!IsSupportedMode(width, height, bpp)) {
width = m_currentDevInfo->m_modeArray[0].width;
height = m_currentDevInfo->m_modeArray[0].height;
bpp = m_currentDevInfo->m_modeArray[0].bitsPerPixel;
}
m_bIgnoreWMSIZE = TRUE;
result = m_pDirectDraw->SetDisplayMode(width, height, bpp);
m_bIgnoreWMSIZE = FALSE;

2
LEGO1/mxdirectx/mxdirectdraw.h
View File

@ -55,8 +55,6 @@ class MxDirectDraw {
// FUNCTION: BETA10 0x1011c170
BOOL IsFullScreen() { return m_bFullScreen; }
BOOL IsSupportedMode(int width, int height, int bpp);
int Pause(BOOL);
BOOL RestoreSurfaces();

31
LEGO1/mxdirectx/mxdirectxinfo.cpp
View File

@ -216,7 +216,6 @@ BOOL MxDeviceEnumerate::EnumDirectDrawCallback(LPGUID p_guid, LPSTR p_driverDesc
BuildErrorString("DirectDraw Create failed: %s\n", EnumerateErrorToString(result));
}
else {
lpDD->EnumDisplayModes(0, NULL, this, DisplayModesEnumerateCallback);
newDevice.m_ddCaps.dwSize = sizeof(newDevice.m_ddCaps);
result = lpDD->GetCaps(&newDevice.m_ddCaps, NULL);
@ -267,18 +266,6 @@ void MxDeviceEnumerate::BuildErrorString(const char* p_format, ...)
va_end(args);
}
// FUNCTION: CONFIG 0x00401bf0
// FUNCTION: LEGO1 0x1009c4f0
// FUNCTION: BETA10 0x1011e1dd
HRESULT CALLBACK MxDeviceEnumerate::DisplayModesEnumerateCallback(LPDDSURFACEDESC p_ddsd, LPVOID p_context)
{
if (p_context == NULL) {
assert(0);
}
return ((MxDeviceEnumerate*) p_context)->EnumDisplayModesCallback(p_ddsd);
}
// FUNCTION: CONFIG 0x00401c10
// FUNCTION: LEGO1 0x1009c510
// FUNCTION: BETA10 0x1011e226
@ -299,20 +286,6 @@ HRESULT CALLBACK MxDeviceEnumerate::DevicesEnumerateCallback(
->EnumDevicesCallback(p_guid, p_deviceDesc, p_deviceName, p_HWDesc, p_HELDesc);
}
// FUNCTION: CONFIG 0x00401c40
// FUNCTION: LEGO1 0x1009c540
// FUNCTION: BETA10 0x1011e27f
HRESULT MxDeviceEnumerate::EnumDisplayModesCallback(LPDDSURFACEDESC p_ddsd)
{
assert(m_list.size() > 0);
assert(p_ddsd);
// TODO: compat_mode?
MxDisplayMode displayMode(p_ddsd->dwWidth, p_ddsd->dwHeight, p_ddsd->ddpfPixelFormat.dwRGBBitCount);
m_list.back().m_displayModes.push_back(displayMode);
return DDENUMRET_OK;
}
// FUNCTION: CONFIG 0x00401cd0
// FUNCTION: LEGO1 0x1009c5d0
// FUNCTION: BETA10 0x1011e32f
@ -582,8 +555,4 @@ DeviceModesInfo::~DeviceModesInfo()
if (m_guid != NULL) {
delete m_guid;
}
if (m_modeArray != NULL) {
delete[] m_modeArray;
}
}

12
LEGO1/mxdirectx/mxdirectxinfo.h
View File

@ -28,11 +28,10 @@ struct DeviceModesInfo {
DeviceModesInfo();
~DeviceModesInfo();
GUID* m_guid; // 0x00
Mode* m_modeArray; // 0x04
int m_count; // 0x08
DDCAPS m_ddcaps; // 0x0c
void* m_unk0x178; // 0x178
GUID* m_guid; // 0x00
int m_count; // 0x08
DDCAPS m_ddcaps; // 0x0c
void* m_unk0x178; // 0x178
// SYNTHETIC: BETA10 0x1011c650
// DeviceModesInfo::`scalar deleting destructor'
@ -128,7 +127,6 @@ struct MxDriver {
char* m_driverName; // 0x08
DDCAPS m_ddCaps; // 0x0c
list<Direct3DDeviceInfo> m_devices; // 0x178
list<MxDisplayMode> m_displayModes; // 0x184
int operator==(MxDriver) const { return 0; }
int operator<(MxDriver) const { return 0; }
@ -199,7 +197,6 @@ class MxDeviceEnumerate {
virtual int DoEnumerate(); // vtable+0x00
BOOL EnumDirectDrawCallback(LPGUID p_guid, LPSTR p_driverDesc, LPSTR p_driverName);
HRESULT EnumDisplayModesCallback(LPDDSURFACEDESC p_ddsd);
HRESULT EnumDevicesCallback(
LPGUID p_guid,
LPCSTR p_deviceDesc,
@ -211,7 +208,6 @@ class MxDeviceEnumerate {
static void BuildErrorString(const char*, ...);
static BOOL CALLBACK
DirectDrawEnumerateCallback(LPGUID p_guid, LPSTR p_driverDesc, LPSTR p_driverName, LPVOID p_context);
static HRESULT CALLBACK DisplayModesEnumerateCallback(LPDDSURFACEDESC p_ddsd, LPVOID p_context);
static HRESULT CALLBACK DevicesEnumerateCallback(
LPGUID p_guid,
LPSTR p_deviceDesc,

1
miniwin/include/miniwin/miniwindevice.h
View File

@ -3,6 +3,7 @@
DEFINE_GUID(IID_IDirect3DRMMiniwinDevice, 0x6eb09673, 0x8d30, 0x4d8a, 0x8d, 0x81, 0x34, 0xea, 0x69, 0x30, 0x12, 0x01);
struct IDirect3DRMMiniwinDevice : virtual public IUnknown {
virtual bool ConvertEventToRenderCoordinates(SDL_Event* event) = 0;
virtual float GetShininessFactor() = 0;
virtual HRESULT SetShininessFactor(float factor) = 0;
};

5
miniwin/src/d3drm/d3drmdevice.cpp
View File

@ -144,6 +144,11 @@ float Direct3DRMDevice2Impl::GetShininessFactor()
return m_renderer->GetShininessFactor();
}
bool Direct3DRMDevice2Impl::ConvertEventToRenderCoordinates(SDL_Event* event)
{
return m_renderer->ConvertEventToRenderCoordinates(event);
}
HRESULT Direct3DRMDevice2Impl::SetShininessFactor(float factor)
{
return m_renderer->SetShininessFactor(factor);

5
miniwin/src/ddraw/ddraw.cpp
View File

@ -17,6 +17,9 @@
SDL_Window* DDWindow;
SDL_Surface* DDBackBuffer;
SDL_Texture* HWBackBuffer;
SDL_PixelFormat HWBackBufferFormat;
SDL_Renderer* DDRenderer;
HRESULT DirectDrawImpl::QueryInterface(const GUID& riid, void** ppvObject)
{
@ -302,6 +305,8 @@ HRESULT DirectDrawImpl::SetCooperativeLevel(HWND hWnd, DDSCLFlags dwFlags)
return DDERR_GENERIC;
}
DDWindow = sdlWindow;
DDRenderer = SDL_CreateRenderer(DDWindow, NULL);
SDL_SetRenderLogicalPresentation(DDRenderer, 640, 480, SDL_LOGICAL_PRESENTATION_LETTERBOX);
}
return DD_OK;
}

46
miniwin/src/ddraw/ddsurface.cpp
View File

@ -55,6 +55,31 @@ static SDL_Rect ConvertRect(const RECT* r)
return {r->left, r->top, r->right - r->left, r->bottom - r->top};
}
bool SetupHWBackBuffer()
{
HWBackBuffer = SDL_CreateTextureFromSurface(DDRenderer, DDBackBuffer);
if (!HWBackBuffer) {
return false;
}
SDL_PropertiesID props = SDL_GetTextureProperties(HWBackBuffer);
if (!props) {
SDL_DestroyTexture(HWBackBuffer);
HWBackBuffer = nullptr;
return false;
}
HWBackBufferFormat =
(SDL_PixelFormat) SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_FORMAT_NUMBER, SDL_PIXELFORMAT_UNKNOWN);
if (HWBackBufferFormat == SDL_PIXELFORMAT_UNKNOWN) {
SDL_DestroyTexture(HWBackBuffer);
HWBackBuffer = nullptr;
return false;
}
return true;
}
HRESULT DirectDrawSurfaceImpl::Blt(
LPRECT lpDestRect,
LPDIRECTDRAWSURFACE lpDDSrcSurface,
@ -69,6 +94,9 @@ HRESULT DirectDrawSurfaceImpl::Blt(
}
if (m_autoFlip) {
DDBackBuffer = srcSurface->m_surface;
if (!HWBackBuffer && !SetupHWBackBuffer()) {
return DDERR_GENERIC;
}
return Flip(nullptr, DDFLIP_WAIT);
}
@ -126,18 +154,15 @@ HRESULT DirectDrawSurfaceImpl::BltFast(
HRESULT DirectDrawSurfaceImpl::Flip(LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride, DDFlipFlags dwFlags)
{
if (!DDBackBuffer) {
if (!DDBackBuffer || !DDRenderer) {
return DDERR_GENERIC;
}
SDL_Surface* windowSurface = SDL_GetWindowSurface(DDWindow);
if (!windowSurface) {
return DDERR_GENERIC;
}
SDL_Rect srcRect{0, 0, DDBackBuffer->w, DDBackBuffer->h};
SDL_Surface* copy = SDL_ConvertSurface(DDBackBuffer, windowSurface->format);
SDL_BlitSurface(copy, &srcRect, windowSurface, &srcRect);
SDL_Surface* copy = SDL_ConvertSurface(DDBackBuffer, HWBackBufferFormat);
SDL_UpdateTexture(HWBackBuffer, nullptr, copy->pixels, copy->pitch);
SDL_DestroySurface(copy);
SDL_UpdateWindowSurface(DDWindow);
SDL_RenderTexture(DDRenderer, HWBackBuffer, nullptr, nullptr);
SDL_RenderPresent(DDRenderer);
return DD_OK;
}
@ -147,6 +172,9 @@ HRESULT DirectDrawSurfaceImpl::GetAttachedSurface(LPDDSCAPS lpDDSCaps, LPDIRECTD
return DDERR_INVALIDPARAMS;
}
DDBackBuffer = m_surface;
if (!SetupHWBackBuffer()) {
return DDERR_GENERIC;
}
*lplpDDAttachedSurface = static_cast<IDirectDrawSurface*>(this);
return DD_OK;
}

1
miniwin/src/internal/d3drmdevice_impl.h
View File

@ -33,6 +33,7 @@ struct Direct3DRMDevice2Impl : public Direct3DRMObjectBaseImpl<IDirect3DRMDevice
HRESULT GetViewports(IDirect3DRMViewportArray** ppViewportArray) override;
// IDirect3DRMMiniwinDevice interface
bool ConvertEventToRenderCoordinates(SDL_Event* event) override;
float GetShininessFactor() override;
HRESULT SetShininessFactor(float factor) override;

6
miniwin/src/internal/d3drmrenderer.h
View File

@ -31,6 +31,8 @@ struct SceneLight {
};
static_assert(sizeof(SceneLight) == 48);
extern SDL_Renderer* DDRenderer;
class Direct3DRMRenderer : public IDirect3DDevice2 {
public:
virtual void PushLights(const SceneLight* vertices, size_t count) = 0;
@ -51,6 +53,10 @@ class Direct3DRMRenderer : public IDirect3DDevice2 {
) = 0;
virtual HRESULT FinalizeFrame() = 0;
bool ConvertEventToRenderCoordinates(SDL_Event* event)
{
return SDL_ConvertEventToRenderCoordinates(DDRenderer, event);
}
float GetShininessFactor() { return m_shininessFactor; }
HRESULT SetShininessFactor(float factor)
{

3
miniwin/src/internal/ddraw_impl.h
View File

@ -8,6 +8,9 @@
extern SDL_Window* DDWindow;
extern SDL_Surface* DDBackBuffer;
extern SDL_Texture* HWBackBuffer;
extern SDL_PixelFormat HWBackBufferFormat;
extern SDL_Renderer* DDRenderer;
struct DirectDrawImpl : public IDirectDraw2, public IDirect3D2 {
// IUnknown interface