erik/acdream
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 3

fix #376+#388: real fullscreen mode switching, state-aware display apply

Browse source 
Slice 5+6 of the display block, one coherent unit (they share the state
machine the goal's dual review covers).

GlfwDisplayModeSwitcher (#376) ports retail's fullscreen semantics -
Device::ForceDisplayResolution @gmClient::Init 0x004047af is a REAL
video-mode change - through native glfwSetWindowMonitor on the same
IWindow.Native.Glfw handle path #348's cursor cache proved. Primary
monitor (retail's primary display device); refresh = the monitor's
highest for the picked WxH; the windowed placement is remembered for the
exit path; every failure is a no-throw (bool, reason) result.

SilkRuntimeDisplayWindowTarget.Apply (#388) becomes the state-aware
machine: fullscreen target = validated native mode switch (mode must be
in #391's DisplayModeCatalog - an offered mode is supported by
construction, making the "Graphics mode not supported" crash class
unreachable from the dropdown); windowed target while fullscreen = the
native exit (which sets the client size itself); plain windowed pick =
the proven #387 size write. A raw Size write NEVER happens against a
fullscreen window - on GLFW that is a video-mode request, and an
unsupported one was the exact unhandled-GlfwException that killed the
user's 2026-08-13 session. The old Silk borderless WindowState path is
deleted from the apply. New IWindowedSizeSurface narrows the window
dependency so the machine is unit-testable (FakePacingSurface idiom).

Live-verified on this machine (goal-sanctioned automated run):
display: fullscreen mode switch 1920x1080@300 -> framebuffer resize
event 1920x1080 -> vulkan: swapchain recreated 1920x1080 ok=True ->
graceful close, desktop mode restored.

Tests: 5 state-machine facts (validated switch/never-size-write,
unoffered refusal, failed-switch usability, native exit, plain windowed
write). App suite 4,972/3 skips. Gate script sections D4-D6 written
(black-screen-risk steps flagged). Dual Opus review of the pair follows
as its own round.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Erik 2026-08-13 17:49:17 +02:00
parent 2153bee247
commit e56aa5115c
5 changed files with 451 additions and 27 deletions
Download patch file Download diff file Expand all files Collapse all files

163
src/AcDream.App/Settings/DisplayModeSwitching.cs Normal file
View file

@ -0,0 +1,163 @@
using System;
using Silk.NET.GLFW;
using Silk.NET.Windowing;
namespace AcDream.App.Settings;
/// <summary>
/// #376/#388: the fullscreen display-mode seam. Retail's fullscreen
/// resolution switch is a REAL video-mode change
/// (<c>Device::ForceDisplayResolution</c>, <c>gmClient::Init @0x004047af</c>);
/// Silk's abstract fullscreen is desktop-mode borderless and its
/// <c>VideoMode</c> is read-only, so entering/leaving a mode goes through
/// native <c>glfwSetWindowMonitor</c>. The interface exists so the
/// state-aware apply in <see cref="SilkRuntimeDisplayWindowTarget"/> is
/// unit-testable with a fake.
/// </summary>
internal interface IDisplayModeSwitcher
{
/// <summary>True while the window is a native fullscreen window (has a
/// monitor attached).</summary>
bool IsFullscreen { get; }
/// <summary>Switches the window to exclusive fullscreen at the given
/// mode. False (with a reason) instead of throwing on any failure —
/// a settings apply must never crash the client (#388).</summary>
bool TryEnterFullscreen(int width, int height, out string? error);
/// <summary>Returns to a windowed window at the given client size.
/// False (with a reason) instead of throwing.</summary>
bool TryLeaveFullscreen(int width, int height, out string? error);
}
/// <summary>
/// The native GLFW implementation. Uses the SAME handle path the #348
/// cursor cache proved (<c>IWindow.Native.Glfw</c>) and the primary
/// monitor — retail's <c>ForceDisplayResolution</c> likewise drove the
/// primary display device. The refresh rate for a mode is the highest the
/// monitor reports for that WxH (retail passed the device's mode as-is).
/// Callers validate the requested WxH against <c>DisplayModeCatalog</c>
/// BEFORE calling — an offered mode is supported by construction, which is
/// what makes the old "Graphics mode not supported" crash class
/// unreachable from the dropdown.
/// </summary>
internal sealed unsafe class GlfwDisplayModeSwitcher : IDisplayModeSwitcher
{
private readonly IWindow _window;
private (int X, int Y) _windowedPosition = (60, 60);
public GlfwDisplayModeSwitcher(IWindow window)
{
_window = window ?? throw new ArgumentNullException(nameof(window));
}
public bool IsFullscreen
{
get
{
WindowHandle* handle = Handle();
if (handle is null) return false;
return Glfw.GetApi().GetWindowMonitor(handle) is not null;
}
}
public bool TryEnterFullscreen(int width, int height, out string? error)
{
error = null;
WindowHandle* handle = Handle();
if (handle is null)
{
error = "no native GLFW window handle";
return false;
}
try
{
Glfw glfw = Glfw.GetApi();
Silk.NET.GLFW.Monitor* monitor = glfw.GetPrimaryMonitor();
if (monitor is null)
{
error = "no primary monitor";
return false;
}
if (!TryFindRefreshRate(glfw, monitor, width, height, out int refresh))
{
error = $"mode {width}x{height} is not in the monitor's mode list";
return false;
}
if (glfw.GetWindowMonitor(handle) is null)
{
// Remember the windowed placement so leaving fullscreen can
// restore it (GLFW does not remember it for us).
glfw.GetWindowPos(handle, out int x, out int y);
_windowedPosition = (x, y);
}
glfw.SetWindowMonitor(handle, monitor, 0, 0, width, height, refresh);
Console.WriteLine(
$"display: fullscreen mode switch {width}x{height}@{refresh}");
return true;
}
catch (GlfwException ex)
{
// #388: a failed switch is a logged failure the caller reverts
// from, never a crash. Validation makes this path exceptional.
error = ex.Message;
return false;
}
}
public bool TryLeaveFullscreen(int width, int height, out string? error)
{
error = null;
WindowHandle* handle = Handle();
if (handle is null)
{
error = "no native GLFW window handle";
return false;
}
try
{
Glfw glfw = Glfw.GetApi();
if (glfw.GetWindowMonitor(handle) is null)
return true; // already windowed
glfw.SetWindowMonitor(
handle, null,
_windowedPosition.X, _windowedPosition.Y,
width, height, 0);
Console.WriteLine(
$"display: left fullscreen to windowed {width}x{height}");
return true;
}
catch (GlfwException ex)
{
error = ex.Message;
return false;
}
}
/// <summary>The monitor's highest refresh rate for an exact WxH, or
/// false when the monitor does not report the mode at all.</summary>
private static bool TryFindRefreshRate(
Glfw glfw, Silk.NET.GLFW.Monitor* monitor, int width, int height, out int refresh)
{
refresh = 0;
Silk.NET.GLFW.VideoMode* modes = glfw.GetVideoModes(monitor, out int count);
if (modes is null) return false;
for (int i = 0; i < count; i++)
{
if (modes[i].Width == width && modes[i].Height == height)
refresh = Math.Max(refresh, modes[i].RefreshRate);
}
return refresh > 0;
}
private WindowHandle* Handle()
{
nint native = _window.Native?.Glfw ?? 0;
return native == 0 ? null : (WindowHandle*)native;
}
}

106
src/AcDream.App/Settings/RuntimeSettingsTargets.cs
View file

@ -1,3 +1,4 @@
using System.Linq;
using AcDream.App.Audio;
using AcDream.App.Net;
using AcDream.App.Rendering;
@ -44,20 +45,105 @@ internal interface IRuntimeChatOpacityTarget
void Apply(float defaultOpacity, float activeOpacity);
}
/// <summary>The one window property the display apply touches — a narrow
/// seam so the #388 state machine is testable without faking all of
/// <see cref="IWindow"/> (same idiom as <c>FakePacingSurface</c>'s
/// surface).</summary>
internal interface IWindowedSizeSurface
{
Vector2D<int> Size { get; set; }
}
internal sealed class SilkWindowSizeSurface(IWindow window) : IWindowedSizeSurface
{
private readonly IWindow _window = window
?? throw new ArgumentNullException(nameof(window));
public Vector2D<int> Size
{
get => _window.Size;
set => _window.Size = value;
}
}
internal sealed class SilkRuntimeDisplayWindowTarget : IRuntimeDisplayWindowTarget
{
private readonly IWindow _window;
private readonly IWindowedSizeSurface _window;
private readonly IDisplayModeSwitcher _modeSwitcher;
private readonly Func<string, bool> _isOfferedMode;
public SilkRuntimeDisplayWindowTarget(IWindow window)
: this(
new SilkWindowSizeSurface(window),
new GlfwDisplayModeSwitcher(window),
// #391's catalog is the validation source: an offered mode is
// supported by construction. With no catalog installed
// (fixture/uninitialised hosts) nothing is "offered", so
// fullscreen entry is refused rather than guessed.
spec => Rendering.DisplayModeCatalog.Resolutions?.Contains(spec) == true)
{
_window = window ?? throw new ArgumentNullException(nameof(window));
}
internal SilkRuntimeDisplayWindowTarget(
IWindowedSizeSurface window,
IDisplayModeSwitcher modeSwitcher,
Func<string, bool> isOfferedMode)
{
_window = window ?? throw new ArgumentNullException(nameof(window));
_modeSwitcher = modeSwitcher
?? throw new ArgumentNullException(nameof(modeSwitcher));
_isOfferedMode = isOfferedMode
?? throw new ArgumentNullException(nameof(isOfferedMode));
}
/// <summary>
/// #388: the state-aware display apply. Windowed target = a window
/// resize (the proven #387 chain); fullscreen target = a validated
/// native display-mode switch (#376, retail's
/// <c>Device::ForceDisplayResolution</c> semantics via
/// <c>glfwSetWindowMonitor</c>). A raw <c>Size</c> write NEVER happens
/// against a fullscreen window — on GLFW that is a video-mode request
/// and an unsupported one killed the client mid-session (the 2026-08-13
/// gate crash). Every failure path logs and leaves the window in a
/// usable state instead of throwing.
/// </summary>
public void Apply(DisplaySettings display)
{
ArgumentNullException.ThrowIfNull(display);
bool haveResolution =
TryParseResolution(display.Resolution, out int width, out int height);
if (display.Fullscreen)
{
if (!haveResolution)
return;
if (!_isOfferedMode.Invoke($"{width}x{height}"))
{
Console.WriteLine(
$"display: fullscreen {width}x{height} refused — not an offered mode");
return;
}
if (!_modeSwitcher.TryEnterFullscreen(width, height, out string? error))
Console.WriteLine(
$"display: fullscreen {width}x{height} failed ({error}) — staying windowed");
return;
}
// Windowed target: leave fullscreen first if needed (the native exit
// sets the client size itself), otherwise plain window resize.
if (_modeSwitcher.IsFullscreen)
{
if (!haveResolution)
{
width = _window.Size.X;
height = _window.Size.Y;
}
if (!_modeSwitcher.TryLeaveFullscreen(width, height, out string? error))
Console.WriteLine(
$"display: leaving fullscreen failed ({error})");
return;
}
if (haveResolution && (_window.Size.X != width || _window.Size.Y != height))
{
// #387 evidence line (permanent): the resolution-pick write path.
@ -66,22 +152,6 @@ internal sealed class SilkRuntimeDisplayWindowTarget : IRuntimeDisplayWindowTarg
$"(window was {_window.Size.X}x{_window.Size.Y})");
_window.Size = new Vector2D<int>(width, height);
}
WindowState desired = display.Fullscreen
? WindowState.Fullscreen
: WindowState.Normal;
// #374 investigation note: while FULLSCREEN, the visible resolution
// is the display's video mode, and Silk's abstract windowing API
// cannot change it (IViewProperties.VideoMode is read-only; Silk
// fullscreen is desktop-mode borderless). The Size write above is
// therefore only visible in windowed mode — a resolution pick while
// fullscreen changes what a later return to windowed restores, not
// the fullscreen mode itself. Retail's own fullscreen resolution
// switch (Device::ForceDisplayResolution) needs a native
// glfwSetWindowMonitor port — issue #376.
if (_window.WindowState != desired)
_window.WindowState = desired;
}
internal static bool TryParseResolution(