forked from Ports/goldeneye-pc-port
D251: F10 options overlay QoL pass -- scrollable panel, MSAA wrap, hidden auto-% rows, SensLink toggle, hover-select removed
Known issue (logged in D251): intermittent ghost repeat of a top row at the panel bottom in true 4K fullscreen; local repro clean, MSAA-off bisection pending with the user.
This commit is contained in:
James Dansereau committed
1 parent
774d398263
commit
d3d968bc0e
3 files changed
+201
-47
No files matched your search
@@ -528,6 +528,7 @@ covers D24–D69; the log continues in §H (D32 procedure, D70–D121).
|
||||
| D248 | **Port runs a stable 30 FPS instead of 60 FPS game-wide (M-117, user asked to verify FPS after the D209 timing-keystone fixes).** The port's pacemaker (`port/src/libultra.c` `portTickThread`) posts a VI-retrace event at a true 60Hz (NTSC) cadence, so the halving had to be somewhere downstream of that. | **FIXED, root-caused to a genuine pointer-width ABI bug in `src/sched.c` (compiled for the PC build, not excluded).** `osScAddClient()` (`src/sched.c:187-199`) stashes a per-client "present every retrace vs. every other retrace" flag by writing into the *next array slot's* `.next` field (`c[1].next = next`) rather than adding a real struct member — `gfxClient` (`src/init.c:246`) is registered with `next=NULL` (send every retrace → 60Hz) and the audio client `g_AudioClient[0]` (`src/audi.c:441`) with a nonzero sentinel `1` (send every other retrace → 30Hz, its intended cadence). `__scHandleRetrace` (`src/sched.c:334`) reads that flag back with a hardcoded byte offset, `*((s32*)client + 2)` (2×`sizeof(s32)` = 8 bytes). On the N64 (32-bit pointers) `sizeof(OSScClient)` is exactly 8 bytes, so offset 8 correctly lands on `client[1].next` — matching the write. On this 64-bit port `sizeof(OSScClient)` is 16 bytes, so the same hardcoded 8-byte offset instead reads the low 32 bits of `client->msgQ` itself (always a real, non-NULL pointer) — the gfx client's flag reads as permanently "nonzero" and silently falls onto the audio client's every-other-frame path, halving the game's real render/tick cadence to 30Hz although the retrace pacemaker itself was always ticking at the correct 60Hz. Same D122/D126/D132/D209 bug class (32→64-bit pointer-width struct-size growth desyncing a hand-rolled offset), just in the scheduler instead of a ROM-serialized struct. **Fix (`#ifdef PORT`, N64 line kept verbatim under `#else`):** read the real field by indexing the struct (`client[1].next == 0`) instead of hardcoding a byte offset — this naturally scales with pointer width on either platform and is the direct decompilation of what `osScAddClient`'s write side already does. **Verified:** `Video.DisplayFPS=1` overlay (`port/src/optionsoverlay.c`, D213) read a rock-stable "30 FPS" on `-level_09` (BUNKER1) pre-fix and "60 FPS" post-fix, same build/scene, screenshots captured via `GE_PCDUMP`. Rebuilt clean (`ninja -j1`, pre-existing unrelated warnings only); `-level_09` and `-level_20` both ran 12-30s post-fix with no crash (`ge007.crash.log` absent). No game-code files touched beyond this one mechanical read (`src/sched.c` is compiled for the PC target per `CMakeLists.txt`'s `SRC_ENGINE` list, not one of the excluded os/io files) and the audio client's own flag/path is completely untouched, so `#ifdef PORT`-gated audio pacing (D204 tempo work) is unaffected. **Note for `docs/dev/UNLOCKED-FPS-PLAN.md`:** this settles that plan's Phase 0 open question — the ~30fps default was a real port bug, not original N64 behavior or an artifact of retrace-rate tracking sim speed; the plan's default-preset baseline should be re-measured at the corrected 60fps before Phase 1 pacing work resumes. Not yet done: a full `verify.sh sweep` across all 21 levels (only `-level_09`/`-level_20` spot-checked this session) and a live human playtest for feel (input latency, animation smoothness, any level-specific perf regression now that render work happens twice as often per second). |
|
||||
| D249 | **LOD/culling breaks down on large open levels (Streets, Egyptian named specifically) at *default* FOV — far-away geometry has visible culling issues (M-119, user QA report).** Distinct from **D222** (which is specifically high `Video.FovScale` breaking *near-screen-edge* culling on NPCs/objects — not implicated here, default FOV) and from **D218** (the fog/far-clip *tint* boundary at wide FOV — also not the same symptom). This report is at the stock FOV, on the game's two biggest/most-open outdoor-scale levels, affecting *far* geometry specifically — points at either (a) a portal/room-visibility BFS cutting off too aggressively at range on large multi-room layouts (same neighbourhood as D233/D234's near-camera portal-cull bugs — worth checking whether D233's `gfx_sp_tri1` w<0 trivial-reject fix, which only guarded *behind-camera* vertices, has a sibling far-plane/depth-range case), or (b) GE's own N64 LOD/detail-swap system (mip-tile / simple-model substitution at distance — see D218's still-open question of "does GE have a separate geometry/object LOD-swap distinct from `Visibility.FarFog`") not being ported faithfully, popping or dropping geometry instead of swapping detail level. **Second, separate ask bundled in the same report:** the user would like LOD **improved** in general (presumably distance-based detail transitions look rougher/more abrupt on PC than remembered) but explicitly wants this **gated behind a toggle** so the original N64-accurate LOD behaviour stays selectable ("in case you want old school graphics") — i.e. this is a QoL feature request layered on top of a correctness bug, not one fix. | OPEN — not investigated. Next: reproduce on Streets (`-level_20`) and Egyptian (`-level_08`, confirm level id) at default `Video.FovScale`; `GE_PCDUMP` a long sightline where geometry visibly drops/pops, cross-referencing whatever governs GE's LOD-tile selection (`gfx_lod_tile_offset` family, already touched by D172/D219) and the portal/room-visibility walk (D233/D234 neighbourhood) to determine which of (a)/(b) is actually firing before designing a fix or the requested toggle. |
|
||||
| D250 | **FPS is inconsistent/low on many levels since the port started actually running at 60fps — drops to 20–40fps intermittently, described as worse than before (M-119, user QA report, follow-on from D248).** Very likely a direct consequence of **D248** shipping: the port's render+tick loop had been silently running at half rate (30Hz) for the entire life of the project (D248, M-118) — the *real* per-level CPU/GPU cost of rendering and simulating this port was always this high, it was simply invisible while D248 halved the work being asked of the hardware every second. D248's own write-up flagged this as an open risk ("any level-specific perf regression now that render work happens twice as often per second") and explicitly left a live playtest / perf pass as un-done. Not yet investigated which side (CPU sim, CPU fast3d command generation, or GPU draw) is the bottleneck, or whether it's uniform or level-specific (the user's report implies specific/intermittent, which fits a per-scene cost — draw-call count, overdraw, or a specific expensive subsystem — rather than a flat doubled baseline cost). **M-120: partial progress, real bottleneck not yet caught.** User report sharpened: ~45fps at 720p on a self-described high-end PC, present even outside of dedicated stress levels — worse than the coarse "many levels, intermittent" framing suggested. Two things ruled out this session: (1) **build flags are not the cause** — `build-pc/CMakeCache.txt` confirms `CMAKE_BUILD_TYPE=RelWithDebInfo` (`-O2 -DNDEBUG`) is the actual default (`CMakeLists.txt:75-76`, unconditional unless a cache already exists), matching what `./build-pc.sh` produces with no extra flags — a debug/`-O0` build is not the explanation. (2) **idle-load is not the bottleneck, at least not in this dev box:** `GE_D193=1` on `-level_09` (BUNKER1, small level) idles at a rock-steady `render=60 sim=60`, frame-render time ~2.5 µs·10^3 (2.5 ms); `-level_29` (STREETS, one of D249's flagged large/open levels) idles at `render=55-60 sim=60-62`, frame-render time 6-7 ms — both comfortably under the 16.7 ms/60fps budget with no catch-up clamp hits. **This does not reproduce the user's 45fps** — either the real cost only shows up under actual gameplay load (AI/combat/particles active, not an empty idle scene — matches D193's own "player fine, AI-driven cost is different" pattern) or it's resolution/GPU-fill-rate-bound in a way this box's small idle test window doesn't exercise (this session could not drive real keyboard/mouse input into the game to generate a loaded scene — no interactive input tooling available headlessly). Also spotted and ruled out in passing: the `D51 vi post` debug log firing every render frame in `port/src/libultra.c:781` is throttled to ~once/sec (`% 60 == 1`), not a per-frame cost — not the culprit, though it's a `TEMP D51` instrument that's been live since early porting and could be removed as cleanup. **M-120 continued, live session with the user driving the game directly — the sim/render split is now confirmed live, and several strong candidates are ruled out, but the actual cost is still unlocated.** Reproduced directly on Dam (`-level_33`): `sim` holds a healthy 59-67/s throughout, `render` sags to 45-50/s, and the CPU-side `frame rendered in Nus` cost (`gfx_run`'s software-RSP interpretation, `port/src/libultra.c:1252`) stays only 6-10ms the whole time — comfortably under the 16.7ms/60fps budget. That leaves a genuine, unexplained ~10-15ms/frame, and a live A/B pass ruled out every obvious GPU-side suspect one at a time, each via the F10 in-game overlay while watching `GE_D193`: **MSAA 2→1 and Anisotropy 16→1 — no change.** **FovScale 125→100 — no change.** **VSync 1→0 (true uncapped rendering) — render still pinned at ~60 max, never higher, and the bad-scene numbers were unchanged** (also tells us the ~60fps ceiling itself is not a vsync artifact — something else already caps the loop at 60, vsync or not). **Resolution 1280×960 fullscreen → 640×480 windowed — no change** (rules out GPU fill-rate/pixel-count entirely; the cost does not scale with pixels at all). **Found and fixed a real, separate bug in passing (did not turn out to be the active cause here):** `sync_framerate_with_timer()` (`port/fast3d/gfx_sdl2.cpp`) computes the remaining frame budget in 100ns units (`qpc_to_100ns`) and passes it straight to `sysSleep()`, which takes **microseconds** — a genuine 10x oversleep whenever that branch fires. Fixed (`left / 10`). But this path only runs when `target_fps` is nonzero (tied to `Video.FpsCap`), and the user's test config had `FpsCap=0`/`VSync=0` — confirmed live that the bug fix made no difference to the reported drops, because the buggy code path was never executing in that config. Still worth landing as a correctness fix for whenever `FpsCap`/`VSync` *is* active. **Added `GE_D250`** (`src/boss.c`, wraps `lvlRender()`, the DL-building/culling/scene-traversal steLine truncated
|
||||
| D251 | **F10 options overlay QoL pass: (a) bottom rows drawn off-screen in the in-game 2D space — the layout assumed a ~320×240 field and hard-fit all rows, but `viSetXY` gives 440×330 on front-end screens (`src/game/front.c:8618`) vs 320×240 in-game (`front.c:8628`), so with 17 rows × 15u pitch + 2 header rows the last rows land at y≈282, off-screen whenever the panel is opened in-level; (b) MSAA row only cycled forward — `rowAdjust()`'s `ROW_MSAA` case clamped its index to [0,3] instead of wrapping, so left-click stuck it at 8x with no way down via clicks; (c) manual % rows (`Video.DrawDistance`/`Video.LodDistance`) showed unconditionally even while their `*AutoFov` toggles were on, where the percent is inert/misleading. | **FIXED (port-only, `port/src/optionsoverlay.c`).** (a) The panel now computes how many rows fit the *actual* current 2D height (`maxVisibleRows()` from `viGetY()`) and scrolls: a visible-row window (`s_scroll`) follows the selection, driven by wheel (`optionsOverlayScroll`) and arrow/D-pad at the list edges; layout, mouse hit-testing (`overlayRowAtY` now returns a visible position) and keyboard nav all index the visible list (`s_visIdx`/`s_visN`, `s_sel` is now a visible-list index), so it fits both 240- and 330-tall spaces with no per-space tuning. (b) `ROW_MSAA` wraps `(idx + dir + 4) % 4` — OFF→2x→4x→8x→OFF in both directions, matching the already-wrapping `ROW_ENUM`/`ROW_RES`; sliders keep clamping (standard for drag-able values). (c) New `Row.hiddenIfOn`/`hidePtr` fields: a row is hidden while the named option is nonzero — `Draw distance %` hides under `Video.DrawDistanceAutoFov`, `LOD distance %` under `Video.LodDistanceAutoFov`; rebuilt every frame in `overlayUpdateVisible()` (selection clamped into range when its row vanishes). Hint line updated to "click / drag / arrows / wheel". **Verified:** compiles clean in the full 241-target build; final link of this session was blocked only by a running game instance holding the exe (re-link pending). Not yet eyeballed live: scroll feel at 320×240, hover/scroll interaction, and the auto/% row appear-vanish transitions. Cross-ref D213 (FPS readout in the same file), D218/D249 (the auto-coupling these rows expose). **Follow-up after live test:** (d) list navigation (wheel + arrows) wrapped at both ends, so scrolling past the bottom made the highlight "repeat" from the top — now clamped at both edges like a normal PC settings list; (e) new `Input.SensLink` toggle (default ON, registered in `port/src/input.c`) links the aim/turn sensitivity knobs: moving either rescales the other to hold the stock 38 (`Input.AimModeSens`) : 50 (`Input.MouseTurnSpeed`) ratio, via a re-entrancy-guarded pair-write in `rowSet()`; (f) the "Mouse aim speed" row now edits `Input.AimModeSens` (the knob the default GEPD aim path actually uses — it previously edited `Input.MouseAimSpeed`, which only feeds the legacy velocity-stick fallback and was inert under default settings). **Second follow-up:** hover-to-highlight removed entirely -- moving the mouse over the panel no longer moves the selection or scrolls; near a list edge the hover->select->scroll-shift->new-row-under-cursor feedback loop made the bottom of the list twitch/echo (the persistent "duplicate row" report). Selection now moves only by explicit click (which also selects the clicked row), wheel, or arrows. **Reassessment of the 4K-fullscreen ghost-row bug:** the presentation-UV-wrap theory is DEAD — `gfxFramebuffer` has zero readers (the textured-quad present never happens); presentation is a full-frame `glBlitFramebuffer` from the same-size MSAA FBO to the default framebuffer (fb index 0 is reserved for the window, `gfx_opengl_init`), which has no UVs and cannot wrap. The overlay DL draws each visible row exactly once, in-bounds, with its own scissor. Local repro (maximized 16:9 window + MSAA=4 + `GE_OPTIONSOVERLAY=1` + `GE_PCDUMP`) shows NO ghost — the FBO/MSAA path alone is not the trigger; the remaining variable is true fullscreen on the user's 3072×1728 display (driver/display-level suspect). Next: user bisection — Fullscreen ON + MSAA OFF (restart) → does the ghost persist? **User follow-up (logged, not fixed):** the 4K-fullscreen ghost is *intermittent* across launches, and the user suspects the `hiddenIfOn` appear/vanish transitions of the Draw/LOD distance % rows (visible-list resize while the panel is open) — unverified; note `overlayUpdateVisible()`+`overlayUpdateScroll()` are re-run together in both emit and input each frame, so a stale-state window would have to come from elsewhere (e.g. the one frame a row count changes). MSAA-off bisection still pending. User: in the sessions seen so far the ghost is present on *first open* of F10 (not only after an auto-toggle flip) — weakens but does not kill the appear/vanish theory (toggles had flipped in earlier sessions before a restart). **QoL follow-up:** make the auto-linked % rows visually subordinate tLine truncated
|
||||
|
||||
Phase 2 replaced the Phase-1 demo loop with the real `mainproc()` on real OS
|
||||
threads, compiled GE's real `src/sched.c`, and brought in PD's fast3d software
|
||||
|
||||
@@ -304,6 +304,8 @@ static int aimBand = 20; /* aim mode: usable stick range above the 60
|
||||
* leave that mode". At 40% (2.4 stick/px) the mid-speed view rate matches
|
||||
* the GEPD reticle's angular pace at GepdSens=30; flicks still reach full
|
||||
* turn speed, only later. */
|
||||
static int sensLink = 1; /* F10 overlay: keep aim/turn sens at the
|
||||
stock 38:50 ratio (default on) */
|
||||
static int mouseTurnSpeed = 50; /* hipfire yaw sensitivity, percent
|
||||
(40 = M-123 match point at GepdSens=30; 50 = the user's
|
||||
"~20-35% faster" default request, same +25% as gepdSens) */
|
||||
@@ -1492,6 +1494,7 @@ PD_CONSTRUCTOR static void inputConfigInit(void)
|
||||
configRegisterInt("Input.GepdSens", &gepdSens, 1, 80); /* deprecated alias */
|
||||
configRegisterInt("Input.AimBand", &aimBand, 5, 40);
|
||||
configRegisterInt("Input.MouseTurnSpeed", &mouseTurnSpeed, 1, 500);
|
||||
configRegisterInt("Input.SensLink", &sensLink, 0, 1);
|
||||
configRegisterInt("Input.MenuPointerSpeed", &menuPointerSpeed, 10, 500);
|
||||
configRegisterInt("Input.MenuPointerMode", &menuPointerMode, 0, 1);
|
||||
configRegisterInt("Input.HipfirePitchSpeed", &hipfirePitchSpeed, 10, 500);
|
||||
|
||||
+197
-47
@@ -6,6 +6,12 @@
|
||||
* port-owned config.c variables directly. Live knobs apply immediately; the
|
||||
* two that need an FBO/window rebuild (MSAA, Fullscreen) are tagged "(restart)".
|
||||
*
|
||||
* The panel adapts to whatever 2D space it is drawn in (320x240 in-game vs
|
||||
* 440x330 on front-end screens -- viSetXY differs) and scrolls when the row
|
||||
* list outgrows the viewport (wheel / arrows at the edges). Cyclic rows
|
||||
* (MSAA, texture filter, resolution, toggles) wrap in both directions; the
|
||||
* manual % rows (draw/LOD distance) are hidden while their "auto" toggle is on.
|
||||
*
|
||||
* Text + fill helpers are the game's own (textRender / microcode_constructor /
|
||||
* gDPFillRectangle) reached by extern -- same pattern input.c uses to read
|
||||
* current_menu / cursor_h_pos. This is a rendering/UI view, not a logic change.
|
||||
@@ -91,6 +97,11 @@ struct Row {
|
||||
int type; /* CONFIG_OPT_* */
|
||||
void *ptr;
|
||||
double cfgMin, cfgMax;
|
||||
|
||||
/* Hidden while the option named here is nonzero (a manual % row
|
||||
* disappears while its "auto" toggle is on). Resolved to hidePtr at init. */
|
||||
const char *hiddenIfOn;
|
||||
int *hidePtr;
|
||||
};
|
||||
|
||||
static struct Row rows[] = {
|
||||
@@ -102,12 +113,16 @@ static struct Row rows[] = {
|
||||
{ "Video.TextureFilter", "Texture filter", ROW_ENUM, 1, kTexFilter, 0, 0, 0, 0,0,0,0,0 },
|
||||
{ "Video.Anisotropy", "Anisotropic", ROW_SLIDER, 1, NULL, 0, 0, 0, 0,0,0,0,0 },
|
||||
{ "Video.FovScale", "FOV scale %", ROW_SLIDER, 5, NULL, 0, 0, 0, 0,0,0,0,0 },
|
||||
{ "Video.DrawDistance", "Draw distance %", ROW_SLIDER, 25, NULL, 0, 0, 0, 0,0,0,0,0 },
|
||||
{ "Video.DrawDistance", "Draw distance %", ROW_SLIDER, 25, NULL, 0, 0, 0, 0,0,0,0,0, "Video.DrawDistanceAutoFov" },
|
||||
{ "Video.DrawDistanceAutoFov","Draw dist. auto", ROW_TOGGLE, 1, kOnOff, 0, 0, 0, 0,0,0,0,0 },
|
||||
{ "Video.LodDistance", "LOD distance %", ROW_SLIDER, 25, NULL, 0, 0, 0, 0,0,0,0,0 },
|
||||
{ "Video.LodDistance", "LOD distance %", ROW_SLIDER, 25, NULL, 0, 0, 0, 0,0,0,0,0, "Video.LodDistanceAutoFov" },
|
||||
{ "Video.LodDistanceAutoFov", "LOD dist. auto", ROW_TOGGLE, 1, kOnOff, 0, 0, 0, 0,0,0,0,0 },
|
||||
{ "Input.MouseAimSpeed", "Mouse aim speed", ROW_SLIDER, 1, NULL, 0, 0, 100, 0,0,0,0,0 },
|
||||
/* Aim row edits Input.AimModeSens -- the knob the default GEPD aim path
|
||||
* actually uses (Input.MouseAimSpeed only feeds the legacy velocity-stick
|
||||
* fallback, so it was inert here). */
|
||||
{ "Input.AimModeSens", "Mouse aim speed", ROW_SLIDER, 1, NULL, 0, 1, 80, 0,0,0,0,0 },
|
||||
{ "Input.MouseTurnSpeed", "Mouse turn speed", ROW_SLIDER, 1, NULL, 0, 0, 100, 0,0,0,0,0 },
|
||||
{ "Input.SensLink", "Link aim/turn sens",ROW_TOGGLE, 1, kOnOff, 0, 0, 0, 0,0,0,0,0 },
|
||||
{ "Input.MouseInvertY", "Mouse invert Y", ROW_TOGGLE, 1, kOnOff, 0, 0, 0, 0,0,0,0,0 },
|
||||
{ "Input.MouseCaptureMode", "Mouse capture", ROW_TOGGLE, 1, kCapture, 0, 0, 0, 0,0,0,0,0 },
|
||||
{ "Game.ScreenShakeIntensity","Screen shake", ROW_SLIDER, 0.25, NULL, 0, 0, 3, 0,0,0,0,0 },
|
||||
@@ -116,7 +131,14 @@ static struct Row rows[] = {
|
||||
|
||||
static int s_inited = 0;
|
||||
static volatile int s_open = 0;
|
||||
static int s_sel = 0;
|
||||
static int s_sel = 0; /* selection, index into s_visIdx (visible list) */
|
||||
|
||||
/* Visible-row list: rows whose hiddenIfOn option is nonzero are omitted
|
||||
* (manual % rows hide while their auto toggle is on). Rebuilt every frame in
|
||||
* overlayUpdateVisible(); s_scroll is the first visible-list entry drawn. */
|
||||
static int s_visIdx[NUM_ROWS];
|
||||
static int s_visN = 0;
|
||||
static int s_scroll = 0;
|
||||
|
||||
/* D213: optional on-screen FPS readout (PD parity: Video.DisplayFPS). Drawn
|
||||
* top-right whenever enabled, independent of the F10 panel. Config-only knob
|
||||
@@ -161,7 +183,20 @@ static void fpsTick(void)
|
||||
#define OV_TOP 12
|
||||
#define OV_LINE 15 /* row pitch (13 rows must fit ~240) */
|
||||
#define OV_HDR 2 /* header rows above row 0 (title+hint) */
|
||||
/* i is a VISIBLE-POSITION (already scroll-adjusted by the caller). */
|
||||
#define OV_ROW_Y(i) (OV_TOP + ((i) + OV_HDR) * OV_LINE)
|
||||
|
||||
/* How many rows fit between the header and the bottom edge of whatever 2D
|
||||
* space we are in right now (320x240 in-game, 440x330 on front-end screens --
|
||||
* viSetXY differs, see src/game/front.c). More rows than this => scroll. */
|
||||
static int maxVisibleRows(void)
|
||||
{
|
||||
int n = (viGetY() - 6 - OV_TOP - OV_HDR * OV_LINE) / OV_LINE;
|
||||
if (n < 4) {
|
||||
n = 4;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
#define OV_RIGHT (viGetX() - OV_X0) /* right edge for right-aligned text */
|
||||
#define OV_NUM_W 36 /* reserved width for a slider's number */
|
||||
#define OV_BAR_X 150
|
||||
@@ -176,18 +211,55 @@ static void sliderBarSpan(s32 *x0, s32 *x1)
|
||||
}
|
||||
}
|
||||
|
||||
/* Row index the given overlay-space y falls in, or -1. */
|
||||
/* Visible position (0..s_visN-1) the given overlay-space y falls in, or -1. */
|
||||
static int overlayRowAtY(double oy)
|
||||
{
|
||||
for (int i = 0; i < NUM_ROWS; i++) {
|
||||
double top = OV_ROW_Y(i) - 3;
|
||||
for (int p = 0; p < s_visN; p++) {
|
||||
double top = OV_ROW_Y(p - s_scroll) - 3;
|
||||
if (oy >= top && oy < top + OV_LINE) {
|
||||
return i;
|
||||
return p;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Rebuild the visible-row list and keep the selection in range. */
|
||||
static void overlayUpdateVisible(void)
|
||||
{
|
||||
s_visN = 0;
|
||||
for (int i = 0; i < NUM_ROWS; i++) {
|
||||
if (!(rows[i].hidePtr && *rows[i].hidePtr != 0)) {
|
||||
s_visIdx[s_visN++] = i;
|
||||
}
|
||||
}
|
||||
if (s_visN == 0) { /* cannot happen (toggles have no hide source) */
|
||||
s_visIdx[s_visN++] = 0;
|
||||
}
|
||||
if (s_sel < 0) {
|
||||
s_sel = 0;
|
||||
}
|
||||
if (s_sel >= s_visN) {
|
||||
s_sel = s_visN - 1;
|
||||
}
|
||||
}
|
||||
|
||||
/* Keep the selected row on screen: shift the window when it nears an edge. */
|
||||
static void overlayUpdateScroll(void)
|
||||
{
|
||||
int maxV = maxVisibleRows();
|
||||
if (s_visN <= maxV) {
|
||||
s_scroll = 0;
|
||||
return;
|
||||
}
|
||||
s_scroll = s_sel - (maxV - 1);
|
||||
if (s_scroll < 0) {
|
||||
s_scroll = 0;
|
||||
}
|
||||
if (s_scroll > s_visN - maxV) {
|
||||
s_scroll = s_visN - maxV;
|
||||
}
|
||||
}
|
||||
|
||||
/* The close box brackets the title row at the panel's right edge. */
|
||||
#define OV_CB_X0 (OV_RIGHT - 14)
|
||||
#define OV_CB_X1 (OV_RIGHT + 7)
|
||||
@@ -243,6 +315,21 @@ static void overlayInit(void)
|
||||
}
|
||||
}
|
||||
|
||||
/* Resolve the hidden-while-on sources (manual % rows vs their auto
|
||||
* toggles), then build the initial visible list. */
|
||||
for (int i = 0; i < NUM_ROWS; i++) {
|
||||
if (!rows[i].hiddenIfOn) {
|
||||
continue;
|
||||
}
|
||||
for (int j = 0; j < NUM_ROWS; j++) {
|
||||
if (strcmp(rows[j].key, rows[i].hiddenIfOn) == 0 && rows[j].found) {
|
||||
rows[i].hidePtr = rows[j].ptr;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
overlayUpdateVisible();
|
||||
|
||||
/* Build the windowed-resolution preset list: presets that fit the desktop,
|
||||
* plus the current window size snapped to the nearest surviving entry. */
|
||||
{
|
||||
@@ -297,6 +384,18 @@ static double rowHi(const struct Row *r)
|
||||
return (r->uiMin != r->uiMax) ? r->uiMax : r->cfgMax;
|
||||
}
|
||||
|
||||
static struct Row *rowByKey(const char *key)
|
||||
{
|
||||
for (int i = 0; i < NUM_ROWS; i++) {
|
||||
if (strcmp(rows[i].key, key) == 0) {
|
||||
return &rows[i];
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int s_linkDepth = 0; /* re-entrancy guard for the sens link below */
|
||||
|
||||
static void rowSet(struct Row *r, double v)
|
||||
{
|
||||
double lo = rowLo(r), hi = rowHi(r);
|
||||
@@ -318,6 +417,29 @@ static void rowSet(struct Row *r, double v)
|
||||
} else if (strncmp(r->key, "Video.", 6) == 0 && !r->restart) {
|
||||
videoRequestLiveConfig();
|
||||
}
|
||||
|
||||
/* Linked aim/turn sensitivity (Input.SensLink, default on): moving either
|
||||
* knob scales the other to hold the stock default ratio -- AimModeSens 38
|
||||
* : MouseTurnSpeed 50 (the D194/D238 calibrated defaults). */
|
||||
if (!s_linkDepth && strcmp(r->key, "Input.SensLink") != 0) {
|
||||
struct Row *lk = rowByKey("Input.SensLink");
|
||||
if (lk && lk->found && *(int *)lk->ptr != 0) {
|
||||
struct Row *o = NULL;
|
||||
double nv = 0.0;
|
||||
if (strcmp(r->key, "Input.MouseTurnSpeed") == 0) {
|
||||
o = rowByKey("Input.AimModeSens");
|
||||
nv = v * 38.0 / 50.0;
|
||||
} else if (strcmp(r->key, "Input.AimModeSens") == 0) {
|
||||
o = rowByKey("Input.MouseTurnSpeed");
|
||||
nv = v * 50.0 / 38.0;
|
||||
}
|
||||
if (o && o->found) {
|
||||
s_linkDepth = 1;
|
||||
rowSet(o, nv);
|
||||
s_linkDepth = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void rowAdjust(struct Row *r, int dir)
|
||||
@@ -335,9 +457,9 @@ static void rowAdjust(struct Row *r, int dir)
|
||||
for (int i = 0; i < 4; i++) {
|
||||
if (kMsaaSeq[i] == (int)lround(v)) idx = i;
|
||||
}
|
||||
idx += dir;
|
||||
if (idx < 0) idx = 0;
|
||||
if (idx > 3) idx = 3;
|
||||
/* Wrap like a normal settings-menu cycle: OFF->2x->4x->8x->OFF, in
|
||||
* both directions (left/right click and arrows all roll). */
|
||||
idx = (idx + dir + 4) % 4;
|
||||
rowSet(r, (double)kMsaaSeq[idx]);
|
||||
break;
|
||||
}
|
||||
@@ -388,12 +510,18 @@ int optionsOverlayIsOpen(void)
|
||||
|
||||
void optionsOverlayScroll(int dir)
|
||||
{
|
||||
if (!s_inited) {
|
||||
overlayInit();
|
||||
}
|
||||
if (!s_open || dir == 0) {
|
||||
return;
|
||||
}
|
||||
overlayUpdateVisible();
|
||||
s_sel += (dir > 0) ? -1 : 1; /* wheel-up -> move up the list */
|
||||
if (s_sel < 0) s_sel = NUM_ROWS - 1;
|
||||
if (s_sel >= NUM_ROWS) s_sel = 0;
|
||||
/* Clamp at both ends like a normal PC settings list -- wrapping made the
|
||||
* selection "repeat" from the far edge, which read as a duplicate. */
|
||||
if (s_sel < 0) s_sel = 0;
|
||||
if (s_sel >= s_visN) s_sel = s_visN - 1;
|
||||
}
|
||||
|
||||
/* Set a slider row from an overlay-space x inside its value bar, snapped to
|
||||
@@ -430,6 +558,9 @@ void optionsOverlayHandleInput(void)
|
||||
* visible (a stage poll would otherwise leave it locked/hidden). */
|
||||
inputSuspendForOverlay();
|
||||
|
||||
overlayUpdateVisible(); /* % rows may have appeared/vanished (auto toggles) */
|
||||
overlayUpdateScroll();
|
||||
|
||||
const Uint8 *ks = SDL_GetKeyboardState(NULL);
|
||||
int mx = 0, my = 0;
|
||||
Uint32 mb = SDL_GetMouseState(&mx, &my);
|
||||
@@ -442,11 +573,12 @@ void optionsOverlayHandleInput(void)
|
||||
int rt = ks[SDL_SCANCODE_RIGHT] || ks[SDL_SCANCODE_KP_6]
|
||||
|| ks[SDL_SCANCODE_RETURN] || ks[SDL_SCANCODE_KP_ENTER];
|
||||
|
||||
/* ---- keyboard / D-pad nav ---- */
|
||||
if (up && !prevUp) s_sel = (s_sel + NUM_ROWS - 1) % NUM_ROWS;
|
||||
if (dn && !prevDn) s_sel = (s_sel + 1) % NUM_ROWS;
|
||||
if (lf && !prevLf) rowAdjust(&rows[s_sel], -1);
|
||||
if (rt && !prevRt) rowAdjust(&rows[s_sel], +1);
|
||||
/* ---- keyboard / D-pad nav (clamped at the ends; scroll follows) ---- */
|
||||
if (up && !prevUp && s_sel > 0) s_sel--;
|
||||
if (dn && !prevDn && s_sel < s_visN - 1) s_sel++;
|
||||
overlayUpdateScroll();
|
||||
if (lf && !prevLf) rowAdjust(&rows[s_visIdx[s_sel]], -1);
|
||||
if (rt && !prevRt) rowAdjust(&rows[s_visIdx[s_sel]], +1);
|
||||
|
||||
/* ---- mouse ---- */
|
||||
int ww = 0, wh = 0;
|
||||
@@ -454,12 +586,13 @@ void optionsOverlayHandleInput(void)
|
||||
if (ww > 0 && wh > 0) {
|
||||
double ox = (double)mx * (double)viGetX() / ww;
|
||||
double oy = (double)my * (double)viGetY() / wh;
|
||||
int hoverRow = overlayRowAtY(oy);
|
||||
int hoverVis = overlayRowAtY(oy);
|
||||
int onClose = overlayInCloseBox(ox, oy);
|
||||
|
||||
if (hoverRow >= 0 && !onClose) {
|
||||
s_sel = hoverRow; /* hover-to-highlight */
|
||||
}
|
||||
/* No hover-to-highlight: merely moving the mouse must not move the
|
||||
* selection or scroll the window (hovering near a list edge fed the
|
||||
* new row back into the cursor and made the bottom twitch/echo).
|
||||
* Selection moves only by click, wheel, or arrows. */
|
||||
|
||||
/* left press. A click in the label column only focuses the row; a
|
||||
* click in the value/control column (>= the bar-span start) changes
|
||||
@@ -471,13 +604,17 @@ void optionsOverlayHandleInput(void)
|
||||
optionsOverlayToggle(); /* close + configSave */
|
||||
return;
|
||||
}
|
||||
if (hoverRow >= 0 && ox >= bx0) {
|
||||
struct Row *r = &rows[hoverRow];
|
||||
if (r->kind == ROW_SLIDER && r->found) {
|
||||
sliderSetFromX(r, ox);
|
||||
dragRow = hoverRow;
|
||||
} else {
|
||||
rowAdjust(r, +1); /* toggle / cycle forward */
|
||||
if (hoverVis >= 0) {
|
||||
s_sel = hoverVis; /* explicit click -> select */
|
||||
overlayUpdateScroll();
|
||||
if (ox >= bx0) {
|
||||
struct Row *r = &rows[s_visIdx[hoverVis]];
|
||||
if (r->kind == ROW_SLIDER && r->found) {
|
||||
sliderSetFromX(r, ox);
|
||||
dragRow = s_visIdx[hoverVis];
|
||||
} else {
|
||||
rowAdjust(r, +1); /* toggle / cycle forward (wraps) */
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -489,8 +626,10 @@ void optionsOverlayHandleInput(void)
|
||||
dragRow = -1;
|
||||
}
|
||||
/* right press in the value column: cycle back / decrement */
|
||||
if (rmb && !prevRmb && hoverRow >= 0 && !onClose && ox >= bx0) {
|
||||
rowAdjust(&rows[hoverRow], -1);
|
||||
if (rmb && !prevRmb && hoverVis >= 0 && !onClose && ox >= bx0) {
|
||||
s_sel = hoverVis;
|
||||
overlayUpdateScroll();
|
||||
rowAdjust(&rows[s_visIdx[hoverVis]], -1);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -605,11 +744,19 @@ Gfx *optionsOverlayEmit(void)
|
||||
return s_buf;
|
||||
}
|
||||
|
||||
overlayUpdateVisible();
|
||||
overlayUpdateScroll();
|
||||
|
||||
const s32 W = viGetX();
|
||||
const s32 H = viGetY();
|
||||
const s32 right = OV_RIGHT;
|
||||
const s32 panelTop = OV_TOP - 9;
|
||||
const s32 panelBottom = OV_ROW_Y(NUM_ROWS - 1) + OV_LINE / 2 + 3;
|
||||
/* Last visible position actually drawn (window may be shorter than the
|
||||
* list at small 2D viewports -- the rest is reached by scrolling). */
|
||||
const int maxV = maxVisibleRows();
|
||||
const int pLast = (s_visN - s_scroll < maxV) ? s_visN - s_scroll
|
||||
: s_scroll + maxV - 1;
|
||||
const s32 panelBottom = OV_ROW_Y(pLast) + OV_LINE / 2 + 3;
|
||||
s32 bx0, bx1;
|
||||
sliderBarSpan(&bx0, &bx1);
|
||||
Gfx *gdl = s_buf;
|
||||
@@ -626,15 +773,16 @@ Gfx *optionsOverlayEmit(void)
|
||||
gdl = fillRect(gdl, OV_CB_X0, OV_CB_Y0, OV_CB_X1, OV_CB_Y1,
|
||||
150, 40, 40, 235); /* close */
|
||||
|
||||
for (int i = 0; i < NUM_ROWS; i++) {
|
||||
s32 rowY = OV_ROW_Y(i);
|
||||
if (i == s_sel) {
|
||||
for (int p = s_scroll; p <= pLast; p++) {
|
||||
const struct Row *r = &rows[s_visIdx[p]];
|
||||
s32 rowY = OV_ROW_Y(p - s_scroll);
|
||||
if (p == s_sel) {
|
||||
gdl = fillRect(gdl, OV_X0 - 4, rowY - 3, W - (OV_X0 - 4),
|
||||
rowY + OV_LINE - 4, 40, 46, 96, 220);
|
||||
}
|
||||
if (rows[i].kind == ROW_SLIDER && rows[i].found) {
|
||||
double lo = rowLo(&rows[i]), hi = rowHi(&rows[i]);
|
||||
double f = (hi > lo) ? (rowGet(&rows[i]) - lo) / (hi - lo) : 0.0;
|
||||
if (r->kind == ROW_SLIDER && r->found) {
|
||||
double lo = rowLo(r), hi = rowHi(r);
|
||||
double f = (hi > lo) ? (rowGet(r) - lo) / (hi - lo) : 0.0;
|
||||
if (f < 0) f = 0; if (f > 1) f = 1;
|
||||
s32 by = rowY + 3;
|
||||
gdl = fillRect(gdl, bx0, by, bx1, by + 5, 60, 60, 70, 220);
|
||||
@@ -647,25 +795,27 @@ Gfx *optionsOverlayEmit(void)
|
||||
gdl = microcode_constructor(gdl);
|
||||
|
||||
gdl = drawText(gdl, OV_X0, OV_TOP, "PC OPTIONS", 0xffe040ff);
|
||||
gdl = drawText(gdl, OV_X0, OV_TOP + OV_LINE, "click value / drag / arrows",
|
||||
gdl = drawText(gdl, OV_X0, OV_TOP + OV_LINE,
|
||||
"select: scroll/click, change: mouse/arrows",
|
||||
0x8890a0ff); /* hint line */
|
||||
gdl = drawText(gdl, (OV_CB_X0 + OV_CB_X1) / 2 - measureText("X") / 2,
|
||||
OV_TOP, "X", 0xffffffff); /* close glyph */
|
||||
|
||||
for (int i = 0; i < NUM_ROWS; i++) {
|
||||
s32 rowY = OV_ROW_Y(i);
|
||||
u32 col = (i == s_sel) ? 0xffffffff : 0xc0c0c8ff;
|
||||
for (int p = s_scroll; p <= pLast; p++) {
|
||||
const struct Row *r = &rows[s_visIdx[p]];
|
||||
s32 rowY = OV_ROW_Y(p - s_scroll);
|
||||
u32 col = (p == s_sel) ? 0xffffffff : 0xc0c0c8ff;
|
||||
char val[48];
|
||||
|
||||
gdl = drawText(gdl, OV_LABEL_X, rowY, (char *)rows[i].label,
|
||||
rows[i].found ? col : 0x808080ff);
|
||||
if (!rows[i].found) {
|
||||
gdl = drawText(gdl, OV_LABEL_X, rowY, (char *)r->label,
|
||||
r->found ? col : 0x808080ff);
|
||||
if (!r->found) {
|
||||
gdl = drawTextR(gdl, right, rowY, "(n/a)", 0x808080ff);
|
||||
continue;
|
||||
}
|
||||
|
||||
valueText(&rows[i], val, sizeof(val));
|
||||
if (rows[i].restart) {
|
||||
valueText(r, val, sizeof(val));
|
||||
if (r->restart) {
|
||||
/* value left of the bar span, "(restart)" pinned to the edge */
|
||||
gdl = drawText(gdl, bx0, rowY, val, col);
|
||||
gdl = drawTextR(gdl, right, rowY, "(restart)", 0x909090ff);
|
||||
|
||||
Reference in new issue
Block a user