The render target is the size that was asked for

A crosshair off-centre on the second race, and underneath it every race
after the first was a different race.

Windowed, BackBufferWidth/Height were left at zero, so D3D sized the back
buffer to the device window's client area at the moment the device was
created. Everything downstream is built from the size we ASKED for
instead - the projection matrix takes its aspect from it, the reticle is
centred on it - so a window that was not exactly that size rendered at
the wrong shape and got rescaled on the way to the viewscreen pane.

-fit decided which window that was, and it decided differently for the
first mission than for the rest. Its borderless full-monitor placement
lived only in SVGA16's cockpit build, which does not run until a mission
starts - just after that mission has built its device. So race one was
set up against a still-bordered client and every race after it against
the borderless monitor. On a 3440x1440 panel that is a 1.778 image drawn
across a 2.389 target, against 1.816 the first time.

That is not a cosmetic difference. The simulation advances on wall-clock
deltas, so frame cost is physics: two render targets that size and scale
differently are two different races from one lobby and one set of
settings. A racing sim does not get to do that.

So: the back buffer is the requested size windowed as well as
full-screen, and -fit takes its shape at startup rather than four
screens later. SVGA16 still applies the same rect when it builds the
cockpit - that call is now a no-op instead of a change, which is the
point. The first lobby also stops being the only one with a title bar.

The reticle keeps its own share of the blame and is fixed on its own
terms, so it cannot drift again if a target ever does move:

- It is measured against the viewport at draw time and rebuilt when that
  changes, rather than baked once in the constructor from the renderer's
  requested size. One GetViewport a frame, no rewrite until it moves.
- The arms are quads, not lines. D3D9 line rasterisation follows the
  diamond-exit rule and is free to differ between drivers on a segment
  running along a pixel boundary, which is how a crosshair loses one
  pair of arms and keeps the other - and full-screen, where both
  dimensions are usually even and both pairs sit on boundaries, how it
  can lose the lot.
- Arm thickness follows the target rather than being one pixel whatever
  the resolution. One pixel is a width the presentation can throw away
  in a downscale, and it was a hairline at 1440 next to the pod's line
  at 480.

The log names the viewport, the requested size and where the crosshair
landed, and says TARGET DISAGREES with both aspects when the first two
do not match - so the next report of this arrives with its own diagnosis.

Window creation cleaned up while in there: it computed a style and then
handed CreateWindowEx a literal WS_OVERLAPPEDWINDOW regardless, so the
full-screen path never got the WS_POPUP it thought it was asking for.
Borderless modes are now born borderless instead of being restyled a
moment after. The requested size also goes through AdjustWindowRect,
because -res is a render size and was being used as the OUTER rectangle
with the chrome taken out of the middle - which is how -res 640 480 came
to present into a 624x441 client and started all of this.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

MUNGA_L4/L4VIDEO.cpp

@@ -1695,11 +1695,28 @@ DPLRenderer::DPLRenderer(
 	mPresentParams.EnableAutoDepthStencil = TRUE;
 	mPresentParams.AutoDepthStencilFormat = D3DFMT_D24X8;
 	mPresentParams.Windowed = !fullscreen;
-	if (fullscreen)
-	{
-		mPresentParams.BackBufferWidth = screenWidth;
-		mPresentParams.BackBufferHeight = screenHeight;
-	}
+	//
+	// The render size is asked for, not suggested - windowed as well as
+	// full-screen. Left at zero, D3D sizes the back buffer to the device
+	// window's client area AT THIS MOMENT, and everything downstream is
+	// built from the size we asked for instead: the projection matrix
+	// takes its aspect from it, and the reticle is centred on it. A
+	// window that is not exactly that size therefore renders at the
+	// wrong shape and gets rescaled on the way to the viewscreen pane.
+	//
+	// It only showed up on a SECOND race. A fresh renderer is built per
+	// mission while the window carries its cockpit placement across, so
+	// the first race creates its device against a still-bordered window
+	// - near enough the asked-for size to pass - and the next one
+	// against the borderless full-monitor client, which on a 3440x1440
+	// panel meant a 1.778 image drawn across a 2.389 target.
+	//
+	// -fit picks a render size to land on the viewscreen 1:1, so honour
+	// it: the back buffer is that size, and Present scales it to the
+	// pane in one uniform step.
+	//
+	mPresentParams.BackBufferWidth = screenWidth;
+	mPresentParams.BackBufferHeight = screenHeight;
 
 	HRESULT hr;