fix: PR #1464 review round 4 — three more bugs

**Camera3d.isVisible bounding-sphere radius was inradius, not circumradius**

The frustum-sphere test used `max(width, height) * 0.5` for the
renderable's culling radius, which is the inradius of the bounds
rect — smaller than the distance from center to a corner. Sprites
near a frustum edge could be marked invisible while a corner was
still on-screen. Switched to `√(w² + h²) / 2` (the circumradius);
the sphere now always encloses every corner of the bounds rect.

**Stage.reset read `settings.cameras[0]` for sortOn, not the
camera registered as "default"**

A split-screen / minimap stage can list a non-default Camera2d
BEFORE its main Camera3d in the cameras array (e.g.
`new Stage({ cameras: [minimap2d, main3d] })`), and the previous
code would pick the minimap's Camera2d class — leaving
`world.sortOn = "z"` while the perspective view needed "depth".
Switched to `this.cameras.get("default")?.constructor`, gated on
`settings.cameras.length > 0` so the singleton fallback case
(no class declared anywhere) still leaves `world.sortOn`
untouched.

Regression test in `camera3d_integration.spec.js`.

**MaterialBatcher GPU_TEXTURE_CACHE_RESET subscription leaked
across renderer disposal**

`MaterialBatcher.destroy()` unsubscribed from `event.on(...)` but
nothing called it — neither `WebGLRenderer` nor `Application`
walked the batchers on teardown. Every discarded renderer kept
its batchers (and itself) alive via the listener, and future
cache-reset events fired into dead renderers.

Added `WebGLRenderer.destroy()` that walks `this.batchers` and
calls each one's `destroy()`. `Application.destroy()` now invokes
`this.renderer?.destroy?.()` so the chain is wired end-to-end.

3768 tests pass (+1 new regression test).

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

Author: obiot

packages/melonjs/src/application/application.ts

@@ -649,6 +649,14 @@ export default class Application {
 			this.world.destroy();
 		}
 
+		// tear down the renderer's batchers so their `event.on(...)`
+		// subscriptions (e.g. `GPU_TEXTURE_CACHE_RESET` on
+		// `MaterialBatcher`) don't leak across the disposal — every
+		// otherwise-discarded `Application` would otherwise keep the
+		// batchers (and their renderer reference) alive for the rest
+		// of the page's lifetime.
+		this.renderer?.destroy?.();
+
 		// remove the canvas from the DOM
 		if (removeCanvas && this.renderer) {
 			const canvas = this.renderer.getCanvas();

packages/melonjs/src/camera/camera3d.ts

@@ -564,7 +564,14 @@ export default class Camera3d extends Camera2d {
 		// `pos.z`) here, which silently mis-culled children of any
 		// container whose own depth was non-zero.
 		const bounds = obj.getBounds();
-		const radius = Math.max(bounds.width, bounds.height) * 0.5;
+		// Half-diagonal — the conservative bounding-sphere radius for
+		// a rectangular bounds rect. `max(w, h) * 0.5` is the
+		// inradius and can mark a renderable invisible while one of
+		// its corners is still on-screen near a frustum edge; the
+		// circumradius √(w² + h²) / 2 always encloses every corner.
+		const radius =
+			Math.sqrt(bounds.width * bounds.width + bounds.height * bounds.height) *
+			0.5;
 		const absPos = obj.getAbsolutePosition();
 		return this.frustum.intersectsSphere(absPos.x, absPos.y, absPos.z, radius);
 	}

packages/melonjs/src/state/stage.ts

@@ -209,8 +209,22 @@ export default class Stage {
 			} else if (typeof AppCameraClass === "function") {
 				chosenClass = AppCameraClass as unknown as SortAwareCameraClass;
 			} else if (this.settings.cameras.length > 0) {
-				chosenClass = this.settings.cameras[0]
-					.constructor as unknown as SortAwareCameraClass;
+				// Read the camera actually registered under the "default"
+				// key, NOT `settings.cameras[0]`. A split-screen / minimap
+				// stage can list a non-default Camera2d before its main
+				// Camera3d in the cameras array, and `[0].constructor`
+				// would pick the wrong class — leaving `world.sortOn` at
+				// "z" while the main perspective view needed "depth".
+				//
+				// Gated on `settings.cameras.length > 0` so the
+				// shared-Camera2d-singleton fallback (no cameraClass +
+				// no explicit cameras anywhere) leaves `world.sortOn`
+				// untouched, preserving pre-19.7 behavior.
+				const defaultCam = this.cameras.get("default");
+				if (defaultCam) {
+					chosenClass =
+						defaultCam.constructor as unknown as SortAwareCameraClass;
+				}
 			}
 			const defaultSortOn = chosenClass?.defaultSortOn;
 			if (defaultSortOn && app.world.sortOn !== defaultSortOn) {

packages/melonjs/src/video/webgl/webgl_renderer.js

@@ -362,6 +362,22 @@ export default class WebGLRenderer extends Renderer {
 	/**
 	 * Reset context state
 	 */
+	/**
+	 * Tear down this renderer and free GPU/event resources. Walks every
+	 * registered batcher's `destroy()` so cross-renderer subscriptions
+	 * (`GPU_TEXTURE_CACHE_RESET` on `MaterialBatcher`, etc.) don't
+	 * leak across `Application.destroy()` cycles. Safe to call multiple
+	 * times — subsequent calls are no-ops.
+	 */
+	destroy() {
+		if (this.batchers) {
+			this.batchers.forEach((batcher) => {
+				batcher.destroy?.();
+			});
+			this.batchers.clear();
+		}
+	}
+
 	reset() {
 		super.reset();
 

packages/melonjs/tests/camera3d_integration.spec.js

@@ -307,6 +307,30 @@ describe("Camera3d × Stage × Application integration", () => {
 			stage.reset(app);
 			expect(app.world.sortOn).toBe("depth");
 		});
+
+		// Regression for PR #1464 review round 3: the prior fix read
+		// `settings.cameras[0].constructor`, which picks the wrong
+		// class for a split-screen / minimap stage whose array lists
+		// a non-default Camera2d BEFORE its main Camera3d.
+		it("explicit `cameras: [...]` reads the camera registered as 'default', not [0]", () => {
+			const app = new Application(400, 300, {
+				parent: "screen",
+				renderer: video.CANVAS,
+			});
+			expect(app.world.sortOn).toBe("z");
+
+			// Non-default Camera2d minimap listed FIRST, main Camera3d
+			// listed second but explicitly named "default".
+			const minimap = new Camera2d(0, 0, 100, 100);
+			minimap.name = "minimap";
+			const main = new Camera3d(0, 0, 400, 300);
+			main.name = "default";
+
+			new Stage({ cameras: [minimap, main] }).reset(app);
+			// Reading `[0].constructor` would give Camera2d → "z";
+			// reading the "default"-named entry gives Camera3d → "depth".
+			expect(app.world.sortOn).toBe("depth");
+		});
 	});
 
 	// --- Adversarial / regression coverage --------------------------------