Remove all internal global renderer imports

[obiot]

Summary

• Remove all internal imports of the global renderer from video.js
• imagelayer.js uses this.parentApp.renderer (available in container tree)
• sprite.js, TMXTileset.js, atlas.js, text.js use game.renderer
• Removed setRenderer() function — no longer needed
• video.renderer remains as a public API export for external consumers, set once in video.init()

Zero internal files now import the global renderer from video.js.

Test plan

• All 1951 tests pass
• Build clean (lint + types)
• Verify examples with rebuilt output

🤖 Generated with Claude Code

[Copilot]

Pull request overview

This PR removes internal dependencies on the global video.renderer singleton by switching engine modules to obtain the renderer via the active game instance (or via the renderable’s application context), and by removing the now-unneeded internal setRenderer() hook.

Changes:

• Removed setRenderer() from video.js and stopped calling it from Application.init().
• Updated several renderables/texture utilities to use game.renderer instead of importing renderer from video.js.
• Updated ImageLayer pattern creation to use this.parentApp.renderer.

Reviewed changes

Copilot reviewed 7 out of 7 changed files in this pull request and generated 2 comments.

Show a summary per file

File	Description
packages/melonjs/src/video/video.js	Removes setRenderer() and keeps video.renderer assignment in video.init().
packages/melonjs/src/video/texture/atlas.js	Switches texture cache/verbose/GL checks to use game.renderer.
packages/melonjs/src/renderable/text/text.js	Replaces global renderer usage with game.renderer for WebGL checks and cache/GL cleanup.
packages/melonjs/src/renderable/sprite.js	Uses game.renderer.cache for spritesheet atlas retrieval instead of video.renderer.
packages/melonjs/src/renderable/imagelayer.js	Uses parentApp.renderer to create the repeating pattern.
packages/melonjs/src/level/tiled/TMXTileset.js	Uses game.renderer.cache to create the tileset atlas texture.
packages/melonjs/src/application/application.ts	Removes the call to setRenderer() during initialization.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

ImageLayer.createPattern() now dereferences this.parentApp.renderer, but createPattern() is invoked from the repeat setter during construction (before the layer is attached to a container/world), so parentApp is still undefined and this will throw at runtime. Consider falling back to the default game renderer when parentApp is not yet available, or delay pattern creation until onActivateEvent/after attachment.

Suggested change

	this._pattern = this.parentApp.renderer.createPattern(
	const renderer = this.parentApp ? this.parentApp.renderer : game.renderer;
	this._pattern = renderer.createPattern(

[Copilot]

video.renderer is documented as “a reference to the active … renderer”, but after removing setRenderer() it’s only assigned inside video.init(). If a consumer initializes via new Application().init() (which emits VIDEO_INIT) without calling video.init(), video.renderer will remain null, which is a public-API behavior change and makes the JSDoc misleading. Either keep video.renderer synchronized when VIDEO_INIT fires (e.g., via an event listener) or update the documentation to clearly state when it is populated.

[Copilot]

Pull request overview

Copilot reviewed 8 out of 8 changed files in this pull request and generated 2 comments.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

video.renderer is now only assigned here in video.init(). Creating a standalone new Application(...) (supported entry point) instantiates a renderer without updating this exported API, so video.renderer can remain null/stale even though a renderer exists. Either update the docs to reflect this constraint, or keep video.renderer in sync without internal imports (e.g., update it in response to the existing VIDEO_INIT event emitted by Application.init).

[Copilot]

This block re-calls boot()/video.init() even though the default game instance is already initialized earlier in this file. video.init() unconditionally appends a new canvas and registers global window listeners, so re-initializing here can leak DOM nodes and duplicate handlers. Prefer reusing the existing initialized game (or guard the init with if (!game.isInitialized) / consolidate to a single beforeAll).

Suggested change

	boot();
	video.init(800, 600, {
	parent: "screen",
	scale: "auto",
	renderer: video.AUTO,
	});
	if (!initialized) {
	boot();
	video.init(800, 600, {
	parent: "screen",
	scale: "auto",
	renderer: video.AUTO,
	});
	}

[Copilot]

Pull request overview

Copilot reviewed 8 out of 8 changed files in this pull request and generated 3 comments.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

destroy() assumes const renderer = this.parentApp?.renderer ?? game.renderer is always defined, but it can be undefined/null for detached renderables or during teardown. Accessing renderer.gl / renderer.cache will then throw. Please guard against a missing renderer (e.g., if (renderer && typeof renderer.gl !== "undefined") ... and only delete from renderer.cache when renderer is present), or ensure a renderer is always available for Text instances before calling these methods.

[Copilot]

createPattern() now silently skips pattern creation when no renderer is available, leaving this._pattern undefined. draw() unconditionally calls renderer.drawPattern(this._pattern, ...), which will throw (Canvas sets fillStyle = undefined, WebGL calls pattern.getUVs). Either ensure createPattern() is (re)called once a renderer is available (e.g., from onActivateEvent()), or make draw() handle a missing pattern (lazy-create or early-return) so this can't crash at render time.

[Copilot]

Pull request overview

Copilot reviewed 12 out of 12 changed files in this pull request and generated 5 comments.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

CanvasRenderTarget.destroy(renderer) can throw in WebGL when this.glTextureUnit was never set (e.g. no invalidate() call): getTexture2D(undefined) returns undefined and deleteTexture2D(undefined) ends up calling gl.deleteTexture(undefined). Guard for an undefined texture unit/texture before deleting, or delete via the cached TextureAtlas (if present) instead of relying on glTextureUnit.

Suggested change

	if (renderer && typeof renderer.gl !== "undefined") {
	renderer.setBatcher("quad");
	renderer.currentBatcher.deleteTexture2D(
	renderer.currentBatcher.getTexture2D(this.glTextureUnit),
	);
	if (
	renderer &&
	typeof renderer.gl !== "undefined" &&
	typeof this.glTextureUnit !== "undefined"
	) {
	renderer.setBatcher("quad");
	const texture = renderer.currentBatcher.getTexture2D(this.glTextureUnit);
	if (texture) {
	renderer.currentBatcher.deleteTexture2D(texture);
	}

[Copilot]

CanvasRenderTarget.destroy only cleans up the GPU texture/cache when a renderer is explicitly passed. There are existing call sites that call .destroy() without arguments (e.g. particle emitter default texture), which will continue to leak cached texture units / WebGL textures. Consider either storing the owning renderer on the CanvasRenderTarget at creation time, or ensuring all internal destroy call sites pass the correct renderer consistently.

Suggested change

	if (renderer && typeof renderer.gl !== "undefined") {
	renderer.setBatcher("quad");
	renderer.currentBatcher.deleteTexture2D(
	renderer.currentBatcher.getTexture2D(this.glTextureUnit),
	);
	this.glTextureUnit = undefined;
	}
	if (renderer) {
	renderer.cache.delete(this.canvas);
	const targetRenderer = renderer || this.renderer;
	if (targetRenderer && typeof targetRenderer.gl !== "undefined") {
	targetRenderer.setBatcher("quad");
	targetRenderer.currentBatcher.deleteTexture2D(
	targetRenderer.currentBatcher.getTexture2D(this.glTextureUnit),
	);
	this.glTextureUnit = undefined;
	}
	if (targetRenderer) {
	targetRenderer.cache.delete(this.canvas);

[Copilot]

pool is now imported but no longer used after delegating cleanup to canvasTexture.destroy(renderer). This will trip linting/unused-import checks and makes the file harder to maintain; remove the import or reintroduce pooling where intended.

[Copilot]

Light2d.destroy() now calls this.texture.destroy(renderer) but CanvasRenderTarget.destroy currently assumes glTextureUnit is set when renderer.gl exists. Light2d never calls texture.invalidate(renderer), so glTextureUnit is likely undefined and this path can crash in WebGL. Either ensure Light2d tracks/invalidates its CanvasRenderTarget before it’s used as a WebGL texture, or make CanvasRenderTarget.destroy resilient when glTextureUnit is undefined.

Suggested change

	this.texture.destroy(renderer);
	this.texture = undefined;
	if (this.texture !== undefined && this.texture !== null) {
	// Ensure the CanvasRenderTarget is invalidated before destruction,
	// so any WebGL-related state (e.g. glTextureUnit) is correctly handled.
	if (renderer && typeof this.texture.invalidate === "function") {
	this.texture.invalidate(renderer);
	}
	this.texture.destroy(renderer);
	this.texture = undefined;
	}

[Copilot]

Light2d.destroy() no longer returns the CanvasRenderTarget to legacy_pool (pool.push(this.texture) was removed), and as a result the existing pool import is now unused. Either remove the unused pool import, or keep the pooling behavior if reusing render targets is still desired.

[Copilot]

Pull request overview

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

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

pool is now imported but never used in this module. Please remove the unused import to avoid dead code and keep linting/treeshaking clean.

[Copilot]

Pull request overview

Copilot reviewed 13 out of 13 changed files in this pull request and generated 3 comments.

Comments suppressed due to low confidence (1)

packages/melonjs/src/video/texture/atlas.js:402

• TextureAtlas.addUVs now always adds an extra key into the atlas dictionary (atlas[key] = atlas[name]). Because getAnimationSettings() iterates all keys when names is undefined, these internal UV cache keys get treated as frames and inflate/alter the returned atlas/indices. To keep the public atlas entries stable, consider storing UV lookup caching separately from the atlas dictionary or filtering out cache keys when enumerating frames.

		atlas[name].uvs = new Float32Array([
			s.x / w, // u0 (left)
			s.y / h, // v0 (top)
			(s.x + sw) / w, // u1 (right)
			(s.y + sh) / h, // v1 (bottom)
		]);
		// Cache source coordinates
		// see https://github.com/melonjs/melonJS/issues/1281
		const key = `${s.x},${s.y},${w},${h}`;
		atlas[key] = atlas[name];

		return atlas[name].uvs;
	}

	/**
	 * Create a sprite object using the first region found using the specified name

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

Pull request overview

Copilot reviewed 14 out of 14 changed files in this pull request and generated 4 comments.

Comments suppressed due to low confidence (1)

packages/melonjs/src/renderable/text/text.js:298

• setText() now always rounds the offscreen canvas to the next power-of-two, even for Canvas and WebGL2 where POT textures aren’t required. This can significantly inflate memory/CPU for large text (e.g. 1025px → 2048px). Suggest restoring the conditional (only POT for WebGL1) using the local renderer you already compute (e.g. renderer.WebGLVersion === 1).

		// round the offscreen canvas size to the next power of two
		// (required for WebGL1, harmless for WebGL2/Canvas)
		const width = nextPowerOfTwo(this.metrics.width);
		const height = nextPowerOfTwo(this.metrics.height);

		// invalidate the texture
		const renderer = this.parentApp?.renderer ?? game.renderer;
		this.canvasTexture.invalidate(renderer);

		// resize the cache canvas if necessary
		if (
			this.canvasTexture.width < width ||
			this.canvasTexture.height < height
		) {
			this.canvasTexture.resize(width, height);

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.