feat(input): Implement SDL3 input and window management

CMakeLists.txt

@@ -67,6 +67,10 @@ include(cmake/gamespy.cmake)
 include(cmake/lzhl.cmake)
 include(cmake/stb.cmake)
 
+if(RTS_BUILD_OPTION_SDL3 AND NOT IS_VS6_BUILD)
+    include(cmake/sdl3.cmake)
+endif()
+
 if (IS_VS6_BUILD)
     # The original max sdk does not compile against a modern compiler.
     # If there is a desire to make this work, then a fixed max sdk needs to be created.

Core/GameEngine/Include/GameClient/Display.h

@@ -90,6 +90,11 @@ class Display : public SubsystemInterface
 	virtual UnsignedInt getBitDepth() { return m_bitDepth; }
 	virtual void setWindowed( Bool windowed ) { m_windowed = windowed; }  ///< set windowed/fullscreen flag
 	virtual Bool getWindowed() { return m_windowed; }				///< return widowed/fullscreen flag
+
+#if RTS_SDL3_ENABLE
+	virtual Bool getViewportRect( Int& x, Int& y, Int& width, Int& height ) const { return FALSE; }
+#endif
+
 	virtual Bool setDisplayMode( UnsignedInt xres, UnsignedInt yres, UnsignedInt bitdepth, Bool windowed );	///<sets screen resolution/mode
 	virtual Int getDisplayModeCount() {return 0;}	///<return number of display modes/resolutions supported by video card.
 	virtual void getDisplayModeDescription(Int modeIndex, Int *xres, Int *yres, Int *bitDepth) {}	///<return description of mode

Core/GameEngine/Include/GameClient/LookAtXlat.h

@@ -53,6 +53,7 @@ class LookAtTranslator : public GameMessageTranslator
 	Bool hasMouseMovedRecently();
 	void setCurrentPos( const ICoord2D& pos );
 	void setScreenEdgeScrollMode(ScreenEdgeScrollMode mode);
+	void setControllerInputActive(Bool active);
 
 	void resetModes(); //Used when disabling input, so when we reenable it we aren't stuck in a mode.
 
@@ -82,11 +83,13 @@ class LookAtTranslator : public GameMessageTranslator
 	ViewLocation m_viewLocation[ MAX_VIEW_LOCS ];
 	ScrollType m_scrollType;
 	ScreenEdgeScrollMode m_screenEdgeScrollMode;
+	Bool m_controllerInputActive;
 	UnsignedInt m_lastMouseMoveTimeMsec;				// real-time in milliseconds when mouse last moved
 
 	void setScrolling( ScrollType scrollType );
 	void stopScrolling();
 	Bool canScrollAtScreenEdge() const;
+	Real getControllerScrollScale() const;
 };
 
 extern LookAtTranslator *TheLookAtTranslator;

Core/GameEngine/Include/GameClient/View.h

@@ -204,6 +204,8 @@ class View : public Snapshot
 	virtual Real getZoom() { return m_zoom; }
 	virtual void setZoom(Real z) { m_zoom = z; }
 	virtual Real getHeightAboveGround() { return m_heightAboveGround; }
+	Real getMinHeightAboveGround() const { return m_minHeightAboveGround; }
+	Real getMaxHeightAboveGround() const { return m_maxHeightAboveGround; }
 	virtual void setHeightAboveGround(Real z);
 	virtual void zoom( Real height ); ///< Zoom in/out, closer to the ground, limit to min, or farther away from the ground, limit to max
 	virtual void setZoomToDefault() { m_zoom  = 1.0f; } ///< Set zoom to default value

Core/GameEngine/Source/GameClient/MessageStream/LookAtXlat.cpp

@@ -76,44 +76,39 @@ static Bool scrollDir[4] = { false, false, false, false };
 
 constexpr const Real SCROLL_MULTIPLIER = 2.0f;
 constexpr const Real SCROLL_AMT = 100.0f * SCROLL_MULTIPLIER;
+constexpr const Real MIN_CONTROLLER_SCROLL_SCALE = 0.4f;
 
 static const Int edgeScrollSize = 3;
 
 static Mouse::MouseCursor prevCursor = Mouse::ARROW;
 
 //-----------------------------------------------------------------------------
-void LookAtTranslator::setScrolling(ScrollType scrollType)
+//-----------------------------------------------------------------------------
+void LookAtTranslator::setScrolling( ScrollType scrollType )
 {
-	if (!TheInGameUI->getInputEnabled())
-		return;
+	if (!m_isScrolling && TheStatsCollector != nullptr)
+		TheStatsCollector->startScrollTime();
 
-	prevCursor = TheMouse->getMouseCursor();
 	m_isScrolling = true;
-	TheInGameUI->setScrolling( TRUE );
-	TheTacticalView->setMouseLock( TRUE );
 	m_scrollType = scrollType;
-	if(TheStatsCollector)
-		TheStatsCollector->startScrollTime();
 }
 
 //-----------------------------------------------------------------------------
 void LookAtTranslator::stopScrolling()
 {
-	m_isScrolling = false;
-	TheInGameUI->setScrolling( FALSE );
-	TheTacticalView->setMouseLock( FALSE );
-	TheMouse->setCursor(prevCursor);
-	m_scrollType = SCROLL_NONE;
-
-	// increment the stats if we have a stats collector
-	if(TheStatsCollector)
+	if (m_isScrolling && TheStatsCollector != nullptr)
 		TheStatsCollector->endScrollTime();
 
+	m_isScrolling = false;
+	m_scrollType = SCROLL_NONE;
 }
 
 //-----------------------------------------------------------------------------
 Bool LookAtTranslator::canScrollAtScreenEdge() const
 {
+	if (m_controllerInputActive)
+		return false;
+
 	if (!TheMouse->isCursorCaptured())
 		return false;
 
@@ -131,6 +126,22 @@ Bool LookAtTranslator::canScrollAtScreenEdge() const
 	return true;
 }
 
+//-----------------------------------------------------------------------------
+Real LookAtTranslator::getControllerScrollScale() const
+{
+	if (!m_controllerInputActive || !TheTacticalView)
+		return 1.0f;
+
+	const Real minHeight = TheTacticalView->getMinHeightAboveGround();
+	const Real maxHeight = TheTacticalView->getMaxHeightAboveGround();
+	const Real heightRange = maxHeight - minHeight;
+	if (heightRange <= 0.0f)
+		return 1.0f;
+
+	const Real zoomOutFraction = clamp(0.0f, (TheTacticalView->getHeightAboveGround() - minHeight) / heightRange, 1.0f);
+	return MIN_CONTROLLER_SCROLL_SCALE + zoomOutFraction * (1.0f - MIN_CONTROLLER_SCROLL_SCALE);
+}
+
 //-----------------------------------------------------------------------------
 LookAtTranslator::LookAtTranslator() :
 	m_isScrolling(false),
@@ -140,8 +151,9 @@ LookAtTranslator::LookAtTranslator() :
 	m_isChangingFOV(false),
 	m_middleButtonDownTimeMsec(0),
 	m_lastPlaneID(INVALID_DRAWABLE_ID),
-	m_lastMouseMoveTimeMsec(0),
-	m_scrollType(SCROLL_NONE)
+	m_scrollType(SCROLL_NONE),
+	m_controllerInputActive(false),
+	m_lastMouseMoveTimeMsec(0)
 {
 	m_anchor.x = m_anchor.y = 0;
 	m_currentPos.x = m_currentPos.y = 0;
@@ -190,6 +202,14 @@ void LookAtTranslator::setScreenEdgeScrollMode(ScreenEdgeScrollMode mode)
 	m_screenEdgeScrollMode = mode;
 }
 
+void LookAtTranslator::setControllerInputActive(Bool active)
+{
+	m_controllerInputActive = active;
+
+	if (active && m_isScrolling && m_scrollType == SCROLL_SCREENEDGE)
+		stopScrolling();
+}
+
 //-----------------------------------------------------------------------------
 /**
  * The LookAt Translator is responsible for camera movements. It is directly responsible for
@@ -485,21 +505,22 @@ GameMessageDisposition LookAtTranslator::translateGameMessage(const GameMessage
 					break;
 				case SCROLL_KEY:
 					{
+						const Real scrollAmount = SCROLL_AMT * getControllerScrollScale();
 						if (scrollDir[DIR_UP])
 						{
-							offset.y -= TheGlobalData->m_verticalScrollSpeedFactor * fpsRatio * SCROLL_AMT * TheGlobalData->m_keyboardScrollFactor;
+							offset.y -= TheGlobalData->m_verticalScrollSpeedFactor * fpsRatio * scrollAmount * TheGlobalData->m_keyboardScrollFactor;
 						}
 						if (scrollDir[DIR_DOWN])
 						{
-							offset.y += TheGlobalData->m_verticalScrollSpeedFactor * fpsRatio * SCROLL_AMT * TheGlobalData->m_keyboardScrollFactor;
+							offset.y += TheGlobalData->m_verticalScrollSpeedFactor * fpsRatio * scrollAmount * TheGlobalData->m_keyboardScrollFactor;
 						}
 						if (scrollDir[DIR_LEFT])
 						{
-							offset.x -= TheGlobalData->m_horizontalScrollSpeedFactor * fpsRatio * SCROLL_AMT * TheGlobalData->m_keyboardScrollFactor;
+							offset.x -= TheGlobalData->m_horizontalScrollSpeedFactor * fpsRatio * scrollAmount * TheGlobalData->m_keyboardScrollFactor;
 						}
 						if (scrollDir[DIR_RIGHT])
 						{
-							offset.x += TheGlobalData->m_horizontalScrollSpeedFactor * fpsRatio * SCROLL_AMT * TheGlobalData->m_keyboardScrollFactor;
+							offset.x += TheGlobalData->m_horizontalScrollSpeedFactor * fpsRatio * scrollAmount * TheGlobalData->m_keyboardScrollFactor;
 						}
 					}
 					break;

Core/GameEngineDevice/CMakeLists.txt

@@ -197,6 +197,18 @@ set(GAMEENGINEDEVICE_SRC
     Source/Win32Device/GameClient/Win32Mouse.cpp
 )
 
+# Add Core-level SDL3 implementation
+if(RTS_BUILD_OPTION_SDL3 AND NOT IS_VS6_BUILD)
+    list(APPEND GAMEENGINEDEVICE_SRC
+        Include/SDL3Device/Common/SDL3GameEngine.h
+        Include/SDL3Device/GameClient/SDL3Input.h
+        Include/SDL3Device/GameClient/SDL3Cursor.h
+        Source/SDL3Device/Common/SDL3GameEngine.cpp
+        Source/SDL3Device/GameClient/SDL3Input.cpp
+        Source/SDL3Device/GameClient/SDL3Cursor.cpp
+    )
+endif()
+
 # Add C++ 17 FileSystem implementation for non-VS6 builds
 if(NOT IS_VS6_BUILD)
     list(APPEND GAMEENGINEDEVICE_SRC
@@ -233,6 +245,14 @@ target_link_libraries(corei_gameenginedevice_public INTERFACE
     milesstub
 )
 
+# Export SDL3 dependencies for modern builds
+if(RTS_BUILD_OPTION_SDL3 AND NOT IS_VS6_BUILD)
+    target_link_libraries(corei_gameenginedevice_public INTERFACE
+        SDL3::SDL3
+        SDL3_image::SDL3_image
+    )
+endif()
+
 if(RTS_BUILD_OPTION_FFMPEG)
     find_package(FFMPEG REQUIRED)
 

Core/GameEngineDevice/Include/SDL3Device/Common/SDL3GameEngine.h

@@ -0,0 +1,85 @@
+/*
+**	Command & Conquer Generals Zero Hour(tm)
+**	Copyright 2026 TheSuperHackers
+**
+**	This program is free software: you can redistribute it and/or modify
+**	it under the terms of the GNU General Public License as published by
+**	the Free Software Foundation, either version 3 of the License, or
+**	(at your option) any later version.
+**
+**	This program is distributed in the hope that it will be useful,
+**	but WITHOUT ANY WARRANTY; without even the implied warranty of
+**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+**	GNU General Public License for more details.
+**
+**	You should have received a copy of the GNU General Public License
+**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include "Lib/BaseType.h"
+
+#include <SDL3/SDL.h>
+
+#include "Common/GameEngine.h"
+
+// SDL3 window typically provided by WinMain integration
+extern SDL_Window* TheSDL3Window;
+
+// Forward declarations for base classes
+class AudioManager;
+class Mouse;
+class Keyboard;
+class GameWindow;
+class LocalFileSystem;
+class ArchiveFileSystem;
+class ThingFactory;
+class ModuleFactory;
+class FunctionLexicon;
+class Radar;
+class WebBrowser;
+class ParticleSystemManager;
+
+class SDL3GameEngine : public GameEngine
+{
+public:
+	SDL3GameEngine();
+	virtual ~SDL3GameEngine();
+
+	// GameEngine interface
+	virtual void init() override;
+	virtual void reset() override;
+	virtual void update() override;
+	virtual void serviceWindowsOS() override;
+	virtual Bool isActive() override;
+	virtual void setIsActive(Bool isActive) override;
+
+	// Factory methods (override GameEngine)
+	virtual LocalFileSystem* createLocalFileSystem() override;
+	virtual ArchiveFileSystem* createArchiveFileSystem() override;
+	virtual GameLogic* createGameLogic() override;
+	virtual GameClient* createGameClient() override;
+	virtual ModuleFactory* createModuleFactory() override;
+	virtual ThingFactory* createThingFactory() override;
+	virtual FunctionLexicon* createFunctionLexicon() override;
+	virtual Radar* createRadar(Bool dummy) override;
+	virtual WebBrowser* createWebBrowser() override;
+	virtual ParticleSystemManager* createParticleSystemManager(Bool dummy) override;
+	virtual AudioManager* createAudioManager(Bool dummy) override;
+
+	// SDL3 specific
+	virtual SDL_Window* getSDLWindow() const { return m_SDLWindow; }
+	virtual void forwardTextInputEvent(const char* utf8Text);
+
+protected:
+	SDL_Window* m_SDLWindow;
+	Bool m_IsInitialized;
+	Bool m_IsActive;
+	Bool m_IsTextInputActive;
+	GameWindow* m_TextInputFocusWindow;
+
+	// Event processing
+	void pollSDL3Events();
+	void updateTextInputState();
+};

Core/GameEngineDevice/Include/SDL3Device/GameClient/SDL3Cursor.h

@@ -0,0 +1,61 @@
+/*
+**	Command & Conquer Generals Zero Hour(tm)
+**	Copyright 2026 TheSuperHackers
+**
+**	This program is free software: you can redistribute it and/or modify
+**	it under the terms of the GNU General Public License as published by
+**	the Free Software Foundation, either version 3 of the License, or
+**	(at your option) any later version.
+**
+**	This program is distributed in the hope that it will be useful,
+**	but WITHOUT ANY WARRANTY; without even the implied warranty of
+**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+**	GNU General Public License for more details.
+**
+**	You should have received a copy of the GNU General Public License
+**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include "Lib/BaseType.h"
+
+#include <array>
+#include <SDL3/SDL.h>
+
+#include "GameClient/Mouse.h"
+
+struct AnimatedCursor
+{
+	SDL_Cursor* m_cursor;
+
+	AnimatedCursor()
+		: m_cursor(nullptr)
+	{}
+	~AnimatedCursor()
+	{
+		if (m_cursor)
+		{
+			SDL_DestroyCursor(m_cursor);
+			m_cursor = nullptr;
+		}
+	}
+
+	SDL_Cursor* getCursor() const { return m_cursor; }
+};
+
+class SDL3CursorManager
+{
+public:
+	static void init();
+	static void shutdown();
+
+	static SDL_Cursor* getCursor(Mouse::MouseCursor cursor, int direction);
+
+	// Internal loader used by Mouse implementation
+	static void initResources(Mouse* mouse);
+
+private:
+	static AnimatedCursor* loadANI(const char* filepath);
+	static AnimatedCursor* m_cursorResources[Mouse::NUM_MOUSE_CURSORS][MAX_2D_CURSOR_DIRECTIONS];
+};