Fix HiDPI half-size regression: default 2d projection is logical points

[pusewicz]

3f5a828 wired cf_draw_on_app_canvas_resized to the canvas's pixel dimensions. The default canvas is window_points * pixel_scale, so on a 2x display the projection extent doubled and everything drawn in point space rendered at half size — from the second frame on, since the hook never refreshed mvp and reset_cam only latches it at end of frame. At 1x displays points and pixels coincide, which is why CI never saw it, and why it's invisible on most dev machines too.

s_canvas now hands the hook window points, and the hook refreshes mvp (mirroring cf_draw_projection) and the AA factor. When a refresh lands mid draw-list-recording or inside a push/pop pair it parks in pending_projection and reset_cam applies it at the frame boundary — applying immediately would bake the ortho into recorded draw lists (doubled again at replay) or be clobbered by the pop.

DPI bugs were untestable on 1x machines, so cf_app_force_pixel_scale (internal) pins pixel_scale through the real recreation path: the new test_hidpi suite readback-verifies the projection contract, the resize frame, one-shot cf_app_set_canvas_size behavior, and draw-list recording across a resize, at a forced 2x on any machine.

On this Retina Mac, master currently fails 20 test_draw_tiled cases; this branch is 346/346.

First of a 3-PR series (viewport/scissor scaling and 3d stroke thickness build on this one's test infra) — holding the rest until this lands so each diff stays reviewable on its own.

[Copilot]

Pull request overview

Fixes a HiDPI regression where the default 2D projection was refreshed using app-canvas pixel dimensions instead of window logical-point dimensions (causing point-space content to render at half size on 2x displays after the first frame). Adds deterministic HiDPI test coverage by introducing an internal pixel-scale override hook used by a new test_hidpi suite.

Changes:

• Make default-projection refresh use window logical size (points), and refresh mvp + AA factor on canvas recreation (with safe deferral during draw-list recording / push-pop).
• Add cf_app_force_pixel_scale (internal/test hook) and integrate it with the pixel-density refresh path.
• Add a new test_hidpi suite and wire it into the test build and runner; update cf_app_set_size docs to clarify logical-point units.

Reviewed changes

Copilot reviewed 10 out of 10 changed files in this pull request and generated 1 comment.

Show a summary per file

File	Description
test/test_hidpi.cpp	New suite that forces 2x pixel scale and readback-verifies projection/resize/draw-list behavior.
test/test_app_shared.cpp	Sweeps any leaked forced pixel scale when reusing a test app instance.
test/main.cpp	Registers and runs the new test_hidpi suite.
test/CMakeLists.txt	Adds test_hidpi.cpp to the tests target sources.
src/internal/cute_draw_internal.h	Adds pending-projection state and clarifies resized-hook contract (logical units).
src/internal/cute_app_internal.h	Declares cf_app_force_pixel_scale and tracks pixel_scale_override in CF_App.
src/cute_input.cpp	Skips real pixel-scale refresh while an override is active.
src/cute_draw.cpp	Updates resized-hook behavior: logical extents, mid-frame safety, refresh mvp/AA, deferred apply.
src/cute_app.cpp	Passes logical window size to draw resized hook; clamps recreated canvas pixel size; implements force-scale hook.
include/cute_app.h	Updates cf_app_set_size docs to specify logical points and mention pixel-density behavior.

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

[pusewicz]

Fixed in ecca88b: clamps only the value fed to ortho_2d (via a local ortho_w/ortho_h), so w/h still report the real logical size to callers and CF_ASSERT(w == app->w && h == app->h) is untouched.

[bullno1]

cf_draw_projection is exposed to the user but it conflicts with the automagic behaviour. And the automagic way also forces one to provide an override for testing on non-HiDPI monitor.

I think there should be no automagic behaviour at all:

• Expose dpi scale: cf_app_get_dpi_scale
• Expose dpi change event: cf_app_dpi_scale_was_changed
• Have cf_app_{get,set}_pixel_scale. This is now a user controlled value just like window and canvas size. Text and shapes can reference this.
• Depending on the creation bit, create the canvas, set pixel scale and projection only once. Maybe even get rid of the bit and just be aware by default. Most of the time, the window is not resizable and DPI does not change. To handle it, copy from the sample or doc.

Then we can update the dpi sample and document on how to handle the events (resize, dpi change...) and how to resize the canvas and recalculate projection. The sample can also force pixel scale to facilitate testing on non-HiDPI screen. There is no more "override" since pixel scale is a user controlled variable, just that it has an initial default.

The sample can switch between:

• Scale = forced 1x
• Scale = natural (reported by SDL)
• Scale = forced 2x, forced 4x...

This means handling dpi change is done the same way as resize: on the event, make the calls to the appropriate functions. Just copy and paste from samples or doc if needed.

Basically:

• To be unaware: set pixel scale to 1, don't react to dpi event, only to resize event. Update canvas and projection accordingly.
• To be aware, set pixel scale to dpi scale, also react to dpi change event.

The one thing I haven't looked at is how window size and mouse position is reported. IIRC, SDL reports raw values from the OS which is weird. The OSX way makes the most sense. Windows is weird. Linux depends on whether it's Xorg (Windows way) or Wayland (OSX way). That part should be normalized.

[bullno1]

When would this happen? The event loop drains all event before user code can run so a resize event can't happen during draw.

[bullno1]

This is probably correct most of the time but it overrides what was set by cf_draw_projection which was supposed to be sticky.

[bullno1]

Hmm, the two cases (aware vs unaware) are similar enough that maybe a single: void cf_app_update_display_metrics(width, height, pixel_scale) helper can work. It will do all: projection, canvas, pixel scale.

The user is responsible for calling it at the correct time. pixel_scale can be an arbitrary value for testing or just pass cf_app_get_dpi_scale through.