Rmlui integration

.gitignore

@@ -65,6 +65,7 @@ progress.make
 /_ReSharper.Caches
 .vs/
 .vscode
+/.idea
 
 # Windows libraries used by spring when compiling with MinGW
 # recommended: place the dir somewhere else, and specify with
@@ -74,6 +75,7 @@ progress.make
 
 # Windows libraries used by spring when compiling with Visual Studio
 /vclibs
+/vclibs64
 
 # Installer files
 /external

.gitmodules

@@ -30,3 +30,9 @@
 [submodule "rts/lib/cereal"]
 	path = rts/lib/cereal
 	url = https://github.com/USCiLab/cereal.git
+[submodule "rts/lib/RmlUi"]
+	path = rts/lib/RmlUi
+	url = https://github.com/mikke89/RmlUi.git
+[submodule "rts/lib/lunasvg"]
+	path = rts/lib/lunasvg
+	url = https://github.com/sammycage/lunasvg.git

CMakeLists.txt

@@ -70,6 +70,9 @@ else()
 	set(JAVA_COMPILE_FLAG_CONDITIONAL "-g:lines,source")
 endif()
 
+# By default, the libraries that don't explicily specify SHARED/STATIC are build statically.
+# See https://cmake.org/cmake/help/latest/variable/BUILD_SHARED_LIBS.html
+option(BUILD_SHARED_LIBS "Build shared (dynamic) libraries" OFF)
 
 # Tell windows to pass arguments around in @response files
 # (32k arg limit workaround)

rts/CMakeLists.txt

@@ -133,6 +133,7 @@ add_subdirectory(Lua)
 add_subdirectory(ExternalAI)
 add_subdirectory(Rendering)
 add_subdirectory(aGui)
+add_subdirectory(Rml)
 add_subdirectory(Menu)
 add_subdirectory(Map)
 add_subdirectory(Net)
@@ -146,6 +147,7 @@ make_global_var(engineSources
 		${sources_engine_Map}
 		${sources_engine_Rendering}
 		${sources_engine_aGui}
+		${sources_engine_Rml}
 		${sources_engine_Menu}
 		${sources_engine_System}
 		${sources_engine_ExternalAI}

rts/Game/Game.cpp

@@ -2,6 +2,7 @@
 
 #include "Rendering/GL/myGL.h"
 
+#include <Rml/Backends/RmlUi_Backend.h>
 #include "Game.h"
 #include "Camera.h"
 #include "CameraHandler.h"
@@ -127,6 +128,8 @@
 #include "System/TimeProfiler.h"
 #include "System/LoadLock.h"
 
+#include <RmlUi/Core.h>
+
 
 #undef CreateDirectory
 
@@ -292,6 +295,7 @@ CGame::~CGame()
 	ENTER_SYNCED_CODE();
 	LOG("[Game::%s][1]", __func__);
 
+	RmlGui::Shutdown();
 	helper->Kill();
 	KillLua(true);
 	KillMisc();
@@ -800,6 +804,7 @@ void CGame::LoadInterface()
 		GameSetupDrawer::Disable();
 		GameSetupDrawer::Enable();
 	}
+	RmlGui::Initialize(globalRendering->GetWindow(), globalRendering->GetContext(), globalRendering->winSizeX, globalRendering->winSizeY);
 }
 
 void CGame::LoadLua(bool dryRun, bool onlyUnsynced)
@@ -1068,6 +1073,9 @@ int CGame::KeyPressed(int keyCode, int scanCode, bool isRepeat)
 
 	lastActionList = keyBindings.GetActionList(curKeyCodeChain, curScanCodeChain);
 
+	if (RmlGui::ProcessKeyPressed(keyCode, scanCode, isRepeat))
+		return 0;
+
 	if (gameTextInput.ConsumePressedKey(keyCode, scanCode, lastActionList))
 		return 0;
 
@@ -1107,6 +1115,9 @@ int CGame::KeyPressed(int keyCode, int scanCode, bool isRepeat)
 
 int CGame::KeyReleased(int keyCode, int scanCode)
 {
+	if (RmlGui::ProcessKeyReleased(keyCode, scanCode))
+		return 0;
+
 	if (gameTextInput.ConsumeReleasedKey(keyCode, scanCode))
 		return 0;
 
@@ -1140,6 +1151,9 @@ int CGame::KeyMapChanged()
 
 int CGame::TextInput(const std::string& utf8Text)
 {
+	if (RmlGui::ProcessTextInput(utf8Text))
+		return 0;
+
 	if (eventHandler.TextInput(utf8Text))
 		return 0;
 
@@ -1259,7 +1273,7 @@ bool CGame::UpdateUnsynced(const spring_time currentTime)
 	globalRendering->lastFrameStart = currentTime;
 	// Update the interpolation coefficient (globalRendering->timeOffset)
 	if (!gs->paused && !IsSimLagging() && !gs->PreSimFrame() && !videoCapturing->AllowRecord()) {
-		globalRendering->weightedSpeedFactor = 0.001f * gu->simFPS; 
+		globalRendering->weightedSpeedFactor = 0.001f * gu->simFPS;
 		globalRendering->lastTimeOffset = globalRendering->timeOffset;
 		globalRendering->timeOffset = (currentTime - lastFrameTime).toMilliSecsf() * globalRendering->weightedSpeedFactor;
 
@@ -1279,36 +1293,36 @@ bool CGame::UpdateUnsynced(const spring_time currentTime)
 		float CTO = globalRendering->timeOffset;
 
 		// This mode forces a strict time step of 0.5 simframes per draw frames. Only useful for testing @ 60hz
-		if (SmoothTimeOffset == -1) { 
+		if (SmoothTimeOffset == -1) {
 			if (newSimFrame) {
-				if (LTO > (1.0f - drawsimratio * strictness)) 
+				if (LTO > (1.0f - drawsimratio * strictness))
 					globalRendering->timeOffset = drawsimratio;
-				else 
+				else
 					globalRendering->timeOffset = 0.0f;
 			} else {
-				if (LTO > drawsimratio * strictness) 
+				if (LTO > drawsimratio * strictness)
 					globalRendering->timeOffset = std::fmin(LTO + drawsimratio * strictness, 1.0f);
 				else
 					globalRendering->timeOffset = std::fmin(drawsimratio * strictness, 1.0f);
 			}
 		}
 
-		// This mode tries to correct for the wrongly calculated timeOffset adaptively, 
-		// while trying to maintain a smooth interpolation rate 
+		// This mode tries to correct for the wrongly calculated timeOffset adaptively,
+		// while trying to maintain a smooth interpolation rate
 		// As frame rates dip below 45fps, this method is only marginally better than old method
 		// But that is heavily dependent on wether the load is sim or draw based.
 		// TODO: the camera smoothing still seems to take sim load into account heavily. So large sim loads jitter the camera quite a bit when moving
 		if (SmoothTimeOffset > 0){
 
-			// if we have a new sim frame, then check when the time and CTO of the previous draw frame was. 
+			// if we have a new sim frame, then check when the time and CTO of the previous draw frame was.
 			drawsimratio = std::fmin(drawsimratio, 1.0);  // Clamp it otherwise we will accumulate delay when < 30 FPS
 			float oldCTO = globalRendering->timeOffset;
 			float newCTO = globalRendering->timeOffset;
 
-			if (newSimFrame) { 
-				// newsimframe is a special case, as our new time offset is kind of wrong. 
+			if (newSimFrame) {
+				// newsimframe is a special case, as our new time offset is kind of wrong.
 				// What we want to know is when the last draw happened, and at what offset.
-				// There are two special cases here, if the last draw happened "on time", then we want to 'pull in' CTO to 0, 
+				// There are two special cases here, if the last draw happened "on time", then we want to 'pull in' CTO to 0,
 				// irrespective of the time spent in sim.
 				// If the last draw frame didnt happend on time, and had a large CTO, then we need to 'carry over' some time offset
 
@@ -1319,7 +1333,7 @@ bool CGame::UpdateUnsynced(const spring_time currentTime)
 				}
 			}
 			else {
-				// On draw frames that dont have a preceding sim frame, we want to 'smooth' the CTO out a bit. 
+				// On draw frames that dont have a preceding sim frame, we want to 'smooth' the CTO out a bit.
 				// Otherwise, the sim frame is also calculated into the offset, making things jittery
 				if ((CTO - LTO < (drawsimratio) * strictness)) {
 					newCTO = std::fmin(LTO + drawsimratio * strictness, 1.3f);
@@ -1431,6 +1445,7 @@ bool CGame::Draw() {
 	if (UpdateUnsynced(currentTimePreUpdate))
 		return false;
 
+	RmlGui::Update();
 	const spring_time currentTimePreDraw = spring_gettime();
 
 	SCOPED_SPECIAL_TIMER("Draw");
@@ -1518,6 +1533,7 @@ bool CGame::Draw() {
 		DrawInputReceivers();
 		DrawInputText();
 		DrawInterfaceWidgets();
+		RmlGui::RenderFrame();
 		mouse->DrawCursor();
 
 		eventHandler.DrawScreenPost();
@@ -1674,7 +1690,7 @@ void CGame::SimFrame() {
 
 	// note: starts at -1, first actual frame is 0
 	gs->frameNum += 1;
-	lastFrameTime = spring_gettime(); 
+	lastFrameTime = spring_gettime();
 	// This is not very ideal, as the timeoffset of each new draw frame is also calculated from this
 	// with a strange side effect: if the timeOffset was a high number, like 0.9, then this will force the next draw frame to have an offset of 0.0x
 	// What this means, is that in the case where we have frames to spare, and and over rendering, then the following can happen at 60hz:
@@ -1684,7 +1700,7 @@ void CGame::SimFrame() {
 	// drawframe timeoffset ~ 1.0 (1 extra draw!)
 	// simframe
 	// drawframe timeoffset ~ 0.0 // THIS is the problematic case, as visually, this frame is 'near identical' to the previously drawn one!
-	// simframe 
+	// simframe
 	// drawframe timeoffset ~ 0.0
 	// drawframe timeoffset ~ 0.5
 	// simframe

rts/Game/UI/GuiHandler.cpp

@@ -2,6 +2,7 @@
 
 #include "GuiHandler.h"
 
+#include <Rml/Backends/RmlUi_Backend.h>
 #include "CommandColors.h"
 #include "KeyBindings.h"
 #include "KeyCodes.h"
@@ -168,6 +169,7 @@ bool CGuiHandler::EnableLuaUI(bool enableCommand)
 		}
 	}
 
+	RmlGui::Reload();
 	CLuaUI::ReloadHandler();
 
 	if (luaUI != nullptr) {

rts/Game/UI/InputReceiver.cpp

@@ -4,6 +4,7 @@
 #include "InputReceiver.h"
 #include "Lua/LuaInputReceiver.h"
 #include "Rendering/GL/myGL.h"
+#include "Rml/Backends/RmlUi_Backend.h"
 #include "System/Rectangle.h"
 
 
@@ -68,7 +69,11 @@ void CInputReceiver::DrawReceivers()
 
 CInputReceiver* CInputReceiver::GetReceiverAt(int x, int y)
 {
-	// always ask Lua first
+	// check RmlUI first
+	if (RmlGui::IsMouseInteractingWith())
+		return RmlGui::GetInputReceiver();
+
+	// check lua second
 	if (luaInputReceiver != nullptr && luaInputReceiver->IsAbove(x, y))
 		return luaInputReceiver;
 

rts/Game/UI/MouseHandler.cpp

@@ -39,6 +39,7 @@
 #include "System/StringUtil.h"
 #include "System/Input/KeyInput.h"
 #include "System/Input/MouseInput.h"
+#include "Rml/Backends/RmlUi_Backend.h"
 
 #include <algorithm>
 
@@ -272,6 +273,12 @@ void CMouseHandler::MouseMove(int x, int y, int dx, int dy)
 	if (game != nullptr && !game->IsGameOver())
 		playerHandler.Player(gu->myPlayerNum)->currentStats.mousePixels += movedPixels;
 
+	/* Only want to give a mouse event to RmlUI if the mouse isn't currently performing a drag.
+	 * Otherwise box selections get stuck when the mouse goes over an Rml element. */
+	if (!ButtonPressed() && RmlGui::ProcessMouseMove(x, lasty, dx, dy, activeButtonIdx)) {
+		return;
+	}
+
 	if (activeReceiver != nullptr)
 		activeReceiver->MouseMove(x, lasty, dx, dy, activeButtonIdx);
 
@@ -297,7 +304,12 @@ void CMouseHandler::MousePress(int x, int y, int button)
 	if (game != nullptr && !game->IsGameOver())
 		playerHandler.Player(gu->myPlayerNum)->currentStats.mouseClicks++;
 
-	ButtonPressEvt& bp = buttons[activeButtonIdx = button];
+	if (RmlGui::ProcessMousePress(x, y, button)) {
+		return;
+	}
+
+	activeButtonIdx = button;
+	ButtonPressEvt& bp = buttons[activeButtonIdx];
 	bp.chorded  = (buttons[SDL_BUTTON_LEFT].pressed || buttons[SDL_BUTTON_RIGHT].pressed);
 	bp.pressed  = true;
 	bp.time     = gu->gameTime;
@@ -307,6 +319,8 @@ void CMouseHandler::MousePress(int x, int y, int button)
 	bp.dir      = (dir = GetCursorCameraDir(x, y));
 	bp.movement = 0;
 
+	pressedBitMask |= 1 << button;
+
 	if (activeReceiver != nullptr && activeReceiver->MousePress(x, y, button))
 		return;
 
@@ -366,6 +380,10 @@ bool CMouseHandler::GetSelectionBoxVertices(float3& bl, float3& br, float3& tl,
 	if (activeReceiver != nullptr)
 		return false;
 
+	if (RmlGui::IsMouseInteractingWith()) {
+		return false;
+	}
+
 	if (gu->fpsMode)
 		return false;
 
@@ -463,12 +481,17 @@ void CMouseHandler::MouseRelease(int x, int y, int button)
 	dir = GetCursorCameraDir(x, y);
 
 	buttons[button].pressed = false;
+	pressedBitMask &= ~(1 << button);
 
 	if (inMapDrawer != nullptr && inMapDrawer->IsDrawMode()) {
 		inMapDrawer->MouseRelease(x, y, button);
 		return;
 	}
 
+	if (RmlGui::ProcessMouseRelease(x, y, button)) {
+		return;
+	}
+
 	if (activeReceiver != nullptr) {
 		activeReceiver->MouseRelease(x, y, button);
 
@@ -543,9 +566,17 @@ void CMouseHandler::MouseRelease(int x, int y, int button)
 	}
 }
 
+bool CMouseHandler::ButtonPressed()
+{
+	return pressedBitMask > 0;
+}
 
 void CMouseHandler::MouseWheel(float delta)
 {
+	if (RmlGui::ProcessMouseWheel(delta)) {
+		return;
+	}
+
 	if (eventHandler.MouseWheel(delta > 0.0f, delta))
 		return;
 
@@ -674,6 +705,13 @@ std::string CMouseHandler::GetCurrentTooltip() const
 
 void CMouseHandler::Update()
 {
+	// Rml is very polite about asking for changes to the cursor
+	// so let's make sure it's not ignored!
+	if (RmlGui::IsMouseInteractingWith())
+		// if the cursor string is empty, then Rml is cedeing control of it
+		if (auto& rmlCursor = RmlGui::GetMouseCursor(); !rmlCursor.empty())
+			queuedCursorName = rmlCursor;
+
 	SetCursor(queuedCursorName);
 
 	if (!hideCursor) {

rts/Game/UI/MouseHandler.h

@@ -87,6 +87,8 @@ class CMouseHandler
 
 	bool GetSelectionBoxVertices(float3& bl, float3& br, float3& tl, float3& tr) const;
 
+	bool ButtonPressed();
+
 private:
 	int2 GetViewMouseCenter() const;
 	void SetCursor(const std::string& cmdName, const bool forceRebind = false);
@@ -116,6 +118,7 @@ class CMouseHandler
 	bool wasLocked = false;
 	bool offscreen = false;
 	bool mmbScroll = false;
+	uint32_t pressedBitMask = 0;
 
 private:
 	bool hideCursor = true;