Guide 04

Screen settings

Game Options › Screen: window or fullscreen, a render resolution, and a 60 / 120 fps limit, saved to config.ini. Also: how to patch THUG2's menus at all.

GoalPick a mode and resolution in a menu that looks like THUG2 made it, hit Apply, and have it stick.

Game Options: Screen, Graphics, Keyboard and Gamepad added after Load Game. — Game Options, from the wheel: Screen, Graphics, Keyboard and Gamepad after Load Game.

Game Options &rsaquo; Screen: check marks show the current choice, with THUG2's sign on the right. — Screen: check marks show the current choice; Apply is at the bottom of the list.

1Read config.ini before the window exists

diffWn32/Code/Plat/Gfx/nx/nx_init.cpp · THUG1 port

@@ -48,6 +49,14 @@ void WaitForNextFrame(void)
 void InitialiseEngine( void )
 {
+	// Read the screen settings from config.ini
+	LoadDisplaySettings();
+
+#ifdef __APPLE__
+	// Fullscreen as a borderless window covering the screen, instead of a separate Space with a transition animation
+	SDL_SetHint(SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES, "0");
+#endif
@@ -73,13 +82,13 @@ void InitialiseEngine( void )
-	// Create window
-	int width = 720 * 16 / 9;
-	int height = 720;
+	// Create window (in window mode it's sized to the render resolution)
+	int width = GetDisplaySettings().width;
+	int height = GetDisplaySettings().height;

-	Uint32 window_flags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
+	Uint32 window_flags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | GetDisplayWindowFlags();

No Spaces, no swoosh animation. Fullscreen is just a borderless window that happens to be very large.

2Render at the chosen size, letterbox the rest

The render resolution no longer follows the window. The present pass fits the backbuffer into the drawable, keeping its aspect ratio, and clears the bars to black.

diffWn32/Code/Plat/Gfx/p_nx.cpp · THUG1 port

@@ -68,20 +69,6 @@ namespace Nx
-				case SDL_WINDOWEVENT:
-					switch (event.window.event)
-					{
-						case SDL_WINDOWEVENT_SIZE_CHANGED:
-						{
-							// Set viewport (use drawable size, which differs from window size on HiDPI displays)
-							...
-							NxWn32::set_dimensions(width, height);
@@ -127,19 +114,22 @@ namespace Nx
-		glClear(GL_DEPTH_BUFFER_BIT);
+		glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

-		// Draw backbuffer quad
+		// Draw backbuffer quad, scaled to fit the window
+		NxWn32::SetPresentViewport();
 		NxWn32::EngineGlobals.fullscreen_quad->Bind();
 		glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, nullptr);
+		glViewport(0, 0, NxWn32::EngineGlobals.backbuffer_width, NxWn32::EngineGlobals.backbuffer_height);

new fileWn32/Code/Plat/Gfx/nx/display.cpp

void SetPresentViewport()
{
	int drawable_w, drawable_h;
	SDL_GL_GetDrawableSize(EngineGlobals.window, &drawable_w, &drawable_h);

	float scale_x = (float)drawable_w / (float)EngineGlobals.backbuffer_width;
	float scale_y = (float)drawable_h / (float)EngineGlobals.backbuffer_height;
	float scale = std::min(scale_x, scale_y);

	int width = (int)((float)EngineGlobals.backbuffer_width * scale + 0.5f);
	int height = (int)((float)EngineGlobals.backbuffer_height * scale + 0.5f);

	glViewport((drawable_w - width) / 2, (drawable_h - height) / 2, width, height);
}

3Patch the retail scripts (the trick behind every menu here)

THUG2's scripts come compiled and packed in pre/qb_scripts.prx, and the port never edits them. Instead, after any .qb loads, a matching scripts/patches/<path> is parsed on top. Its symbols are registered under the original file name, so level unloads take the patch with them and reloads re-apply it.

diffCode/Gel/Scripting/file.cpp · THUG1 port

@@ -98,6 +99,30 @@ void LoadQBFromMemory(const char* p_fileName, uint8* p_qb, EBoolAssertIfDuplicat
+bool LoadQBPatch(const char *p_fileName)
+{
+	char p_patch_name[256];
+	snprintf(p_patch_name, sizeof(p_patch_name), "scripts\\patches\\%s", p_fileName);
+	if (!File::Exist(p_patch_name))
+	{
+		return false;
+	}
+
+	uint8 *p_qb = (uint8*)Pip::Load(p_patch_name);
+	ParseQB(p_fileName,p_qb,NO_ASSERT_IF_DUPLICATE_SYMBOLS,false);
+	Pip::Unload(p_patch_name);
+
+	restart_dirty_scripts();
+	return true;
+}

diffCode/Sk/Scripting/gs_file.cpp · THUG1 port

@@ -223,6 +223,10 @@ void LoadQB(const char *p_fileName, EBoolAssertIfDuplic
 	RemoveChecksumNameLookupHashTable();
+
+	// Apply the PC port's changes to this qb, if any (done last, since it replaces the checksum
+	// name lookup table that the node array processing above uses)
+	Script::LoadQBPatch(p_fileName);
 }

The patches are QScript source in Scripts/patches/, compiled for THUG2 by qb when the game is built (see Scripts):

excerptstage_data.sh

compile_script_patches() {
	local qb out="$ROOT/Game/Data/scripts/patches"
	qb="$(find_qb)"
	log "Compiling the script patches (Scripts/patches) with $qb"
	rm -rf "$out"
	mkdir -p "$out"
	"$qb" compile -input "$ROOT/Scripts/patches" -output "$out" -target thug2 >/dev/null || die "the script patches didn't compile"
}

4Expose C++ to the menu

Three script functions: read the settings, list resolutions that fit the screen, apply. Registered in ftables.cpp like the retail ones.

diffCode/Sk/Scripting/cfuncs.cpp · THUG1 port

+// @script | ApplyScreenSettings | Switches window / fullscreen mode, resolution and frame rate limit, and saves them to config.ini
+bool ScriptApplyScreenSettings(Script::CStruct *pParams, Script::CScript *pScript)
+{
+	NxWn32::sDisplaySettings settings = NxWn32::GetDisplaySettings();
+
+	int fullscreen = settings.fullscreen ? 1 : 0;
+	pParams->GetInteger("fullscreen", &fullscreen);
+	pParams->GetInteger("width", &settings.width);
+	pParams->GetInteger("height", &settings.height);
+	pParams->GetInteger("max_fps", &settings.max_fps);
+	settings.fullscreen = (fullscreen != 0);
+
+	NxWn32::ApplyDisplaySettings(settings);
+	return true;
+}

diffCode/Sk/Scripting/ftables.cpp · THUG1 port

+	{ "GetScreenSettings", CFuncs::ScriptGetScreenSettings },
+	{ "GetScreenResolutions", CFuncs::ScriptGetScreenResolutions },
+	{ "ApplyScreenSettings", CFuncs::ScriptApplyScreenSettings },

5Build the menu in QScript

Two patches. levels/mainmenu/mainmenu_options.q rewrites the wheel's Game Options to add Screen, Graphics, Keyboard and Gamepad after Load Game; scripts/game/menu/gamemenu_options.q does the same for the pause menu's Options and holds the menus themselves, built from THUG2's own menu pieces (the round bars, the road sign on the right). Chapter 4 has the story.

excerptScripts/patches/scripts/game/menu/gamemenu_options.q

SCRIPT create_screen_options_menu 
	GetScreenSettings 
	Change screen_menu_fullscreen = <screen_fullscreen> 
	Change screen_menu_width = <screen_width> 
	Change screen_menu_height = <screen_height> 
	Change screen_menu_max_fps = <screen_max_fps> 
	options_submenu_make title = "SCREEN" focus_index = 0 
	screen_options_add_check_item text = "Window" id = screen_options_window pad_choose_params = { fullscreen = 0 } 
	screen_options_add_check_item text = "Fullscreen" id = screen_options_fullscreen pad_choose_params = { fullscreen = 1 } 
	theme_menu_add_item text = "Frame Rate" not_focusable centered no_bg 
	screen_options_add_check_item text = "60 FPS" id = screen_options_fps_60 pad_choose_params = { max_fps = 60 } 
	screen_options_add_check_item text = "120 FPS" id = screen_options_fps_120 pad_choose_params = { max_fps = 120 } 
⋯
	options_submenu_finish icon = screen_icon 
ENDSCRIPT

fullscreen = screen_menu_fullscreen passes a global by name, and CStruct::GetInteger quietly resolves it. QScript is weird. QScript is wonderful.

660 or 120 fps without breaking the physics

The limiter uses the high-resolution counter, sleeps while there's time and spins for the last 2 ms. Game logic already scales by frame time, except for two spots that assumed 60.

diffWn32/Code/Plat/Gfx/nx/nx_init.cpp · THUG1 port

@@ -25,25 +25,33 @@ sEngineGlobals	EngineGlobals;
-static constexpr double c_frame_time = 1000.0 / 60.0;
 void WaitForNextFrame(void)
 {
+	// Frame rate limit from the screen settings (60 or 120 fps)
+	const double frame_time = 1000.0 / (double)GetDisplaySettings().max_fps;
+
 	while (1)
 	{
-		double now = (double)SDL_GetTicks64();
+		double now = GetTimeMs();
 		if (now >= s_next_frame)
 		{
-			s_next_frame += c_frame_time;
+			// Fell behind (or the limit was raised): start counting from now, instead of rushing to catch up
+			if (now >= s_next_frame + (frame_time * 5.0))
+				s_next_frame = now;
+			s_next_frame += frame_time;
 			break;
 		}
-		SDL_Delay(1);
+
+		// Sleep while there's time to spare (SDL_Delay can oversleep a bit), then spin for the rest
+		if (s_next_frame - now > 2.0)
+			SDL_Delay(1);
 	}
 }

diffCode/Sk/Objects/manual.cpp · THUG1 port

@@ -514,7 +514,8 @@ void CManual::DoManualPhysics()
 			// always add some randomness to it, to make sure we don't ever get stuck
-			mManualLeanDir += (Mth::Rnd(50))/100.0f * Mth::Sgn(mManualLeanDir);
+			// (scaled with the frame length, so the drift doesn't speed up above 60 fps)
+			mManualLeanDir += scale_with_frame_length(frame_length, (Mth::Rnd(50))/100.0f) * Mth::Sgn(mManualLeanDir);

diffWn32/Code/Plat/Gfx/p_nx.cpp · THUG1 port

@@ -93,8 +93,13 @@ namespace Nx
-				// Get alpha to blur at
-				glUniform4f(glGetUniformLocation(shader->program, "u_col"), 1.0f, 1.0f, 1.0f, NxWn32::EngineGlobals.screen_blur);
+				// Get alpha to blur at (the amount is per 60th of a second, so above 60 fps less of the
+				// previous frame is kept per frame, to make the trail fade at the same speed)
+				float blur_alpha = NxWn32::EngineGlobals.screen_blur;
+				int max_fps = NxWn32::GetDisplaySettings().max_fps;
+				if (max_fps > 60)
+					blur_alpha = 1.0f - powf(1.0f - blur_alpha, 60.0f / (float)max_fps);

At 120 fps the manual balance drifted twice as fast. The skater was fine. My thumbs were not.

7The result

configGame/config.ini

[Screen]
Fullscreen=0
Width=1280
Height=720
MaxFPS=60

FOR EDUCATION PURPOSES ONLY. Screenshots are captured from the port running the reader's own copy of the game. The diffs are trimmed to the interesting lines (unchanged context is cut, marked ⋯); the repository has the full changes. Paths are relative to the THUG2/ folder.