@codexo/exojs-tilemap 0.15.3 → 0.16.0

package/dist/esm/TileLayerNode.js

@@ -1,170 +1,228 @@
-import { Container } from '@codexo/exojs';
-import { assertPixelSnapMode } from './pixelSnap.js';
-import { TileChunkNode } from './TileChunkNode.js';
+import { TileChunkNode } from "./TileChunkNode.js";
+import { assertPixelSnapMode } from "./pixelSnap.js";
+import { aggregateChildLocalBounds } from "./nodeBounds.js";
+import { PixelSnapMode } from "@codexo/exojs/renderer-sdk";
+import { Container } from "@codexo/exojs";
 
+//#region src/TileLayerNode.ts
 /**
- * A scene node that renders one generic {@link TileLayer} as a
- * {@link Container} of per-chunk {@link TileChunkNode} drawables.
- *
- * Each non-empty loaded chunk becomes one child positioned at its pixel
- * origin, so the engine's existing per-node culling drops individual chunks and
- * the render-plan optimiser batches them by tileset texture. The layer's pixel
- * `offset` is applied to this node's transform; `visible` and `opacity` are
- * read live from the runtime layer on every frame (no rebuild required).
- *
- * The node references — but never owns — the {@link TileLayer}: destroying it
- * frees its chunk nodes and their cached geometry but leaves the layer, map,
- * and Loader-owned textures intact.
- *
- * Structural changes to the layer (tiles written into previously-empty chunks)
- * are reflected only after {@link TileLayerNode.refresh}; in-place edits to
- * existing chunks are picked up automatically via chunk revisions.
- *
- * @advanced
- */
-class TileLayerNode extends Container {
-    _layer;
-    _cullChunks;
-    _chunkNodes = [];
-    _syncedOpacity = -1;
-    _syncedTint = undefined;
-    _pixelSnapMode = 'none';
-    _baseOffsetX;
-    _baseOffsetY;
-    constructor(layer, options) {
-        super();
-        this._layer = layer;
-        this._cullChunks = options?.cullable ?? true;
-        this._baseOffsetX = layer.offsetX;
-        this._baseOffsetY = layer.offsetY;
-        this.setPosition(layer.offsetX, layer.offsetY);
-        this._buildChunkNodes();
-    }
-    /** The runtime layer this node renders. */
-    get layer() {
-        return this._layer;
-    }
-    /**
-     * Render-only pixel-snap mode applied to every chunk node in this layer (and
-     * to chunks rebuilt later by {@link refresh}). Each chunk's rendered origin is
-     * snapped to the active render target's device-pixel grid; because chunk
-     * origins are integer multiples of the integer tile pitch from the same layer
-     * origin, the whole grid stays exact and adjacent chunks cannot drift apart.
-     *
-     * Purely visual: tile data, the layer offset, chunk content revisions, and
-     * culling bounds are never changed. `'geometry'` and `'position'` both resolve
-     * to coherent origin snapping for tile chunks (chunk quads are already on the
-     * integer pixel grid by construction). Setting the current value is a no-op;
-     * an invalid value throws and leaves the prior mode unchanged.
-     *
-     * @default 'none'
-     * @stable
-     */
-    get pixelSnapMode() {
-        return this._pixelSnapMode;
-    }
-    set pixelSnapMode(mode) {
-        if (mode === this._pixelSnapMode) {
-            return;
-        }
-        assertPixelSnapMode(mode);
-        this._pixelSnapMode = mode;
-        for (const chunk of this._chunkNodes) {
-            chunk.pixelSnapMode = mode;
-        }
-    }
-    /**
-     * Rebuild the chunk-node children from the layer's current loaded chunks.
-     * Call after structural mutation that creates or empties chunks. In-place
-     * tile edits to existing chunks do not need a refresh.
-     */
-    refresh() {
-        const previous = [...this._chunkNodes];
-        this.removeChildren();
-        this._chunkNodes.length = 0;
-        for (const child of previous) {
-            child.destroy();
-        }
-        this._syncedOpacity = -1;
-        this._syncedTint = undefined;
-        this._buildChunkNodes();
-        return this;
-    }
-    /** The chunk render nodes owned by this layer node, in build order. @internal */
-    get chunkNodes() {
-        return this._chunkNodes;
-    }
-    getLocalBounds() {
-        const bounds = super.getLocalBounds();
-        bounds.set(0, 0, this._layer.pixelWidth, this._layer.pixelHeight);
-        return bounds;
-    }
-    /** @internal */
-    _collectContent(builder) {
-        if (!this._layer.visible) {
-            return;
-        }
-        this._syncTint();
-        const layer = this._layer;
-        if (layer.parallaxX !== 1 || layer.parallaxY !== 1) {
-            const camCenter = builder.view.center;
-            const prevX = this.x;
-            const prevY = this.y;
-            this.x = this._baseOffsetX + camCenter.x * (1 - layer.parallaxX);
-            this.y = this._baseOffsetY + camCenter.y * (1 - layer.parallaxY);
-            super._collectContent(builder);
-            this.x = prevX;
-            this.y = prevY;
-        }
-        else {
-            super._collectContent(builder);
-        }
-    }
-    destroy() {
-        const children = [...this._chunkNodes];
-        this._chunkNodes.length = 0;
-        super.destroy();
-        for (const child of children) {
-            child.destroy();
-        }
-    }
-    _buildChunkNodes() {
-        const layer = this._layer;
-        for (const chunk of layer.loadedChunks()) {
-            if (chunk.empty) {
-                continue;
-            }
-            const node = new TileChunkNode(chunk, layer.tilesets, layer.tileWidth, layer.tileHeight, layer.chunkWidth, layer.chunkHeight);
-            node.cullable = this._cullChunks;
-            if (this._pixelSnapMode !== 'none') {
-                node.pixelSnapMode = this._pixelSnapMode;
-            }
-            this._chunkNodes.push(node);
-            this.addChild(node);
-        }
-        this._syncTint();
-    }
-    /**
-     * Propagate the layer's live opacity and tint colour onto the chunk render
-     * tints if either changed. Opacity drives the tint alpha; `tintColor`
-     * (`0xRRGGBB`) multiplies the RGB (white = no tint).
-     */
-    _syncTint() {
-        const opacity = this._layer.opacity;
-        const tintColor = this._layer.tintColor;
-        if (opacity === this._syncedOpacity && tintColor === this._syncedTint) {
-            return;
-        }
-        const r = tintColor === null ? 255 : (tintColor >> 16) & 0xff;
-        const g = tintColor === null ? 255 : (tintColor >> 8) & 0xff;
-        const b = tintColor === null ? 255 : tintColor & 0xff;
-        for (const child of this._chunkNodes) {
-            child.tint.set(r, g, b, opacity);
-        }
-        this._syncedOpacity = opacity;
-        this._syncedTint = tintColor;
-    }
-}
+* A scene node that renders one generic {@link TileLayer} as a
+* {@link Container} of per-chunk {@link TileChunkNode} drawables.
+*
+* Each non-empty loaded chunk becomes one child positioned at its pixel
+* origin, so the engine's existing per-node culling drops individual chunks and
+* the render-plan optimiser batches them by tileset texture. The layer's pixel
+* `offset` is applied to this node's transform; `visible` and `opacity` are
+* read live from the runtime layer on every frame (no rebuild required).
+*
+* A `parallax` factor other than `1` makes this node's rendered position
+* camera-dependent, resolved per frame in {@link _collectContent} by patching
+* the node position against the camera centre, then restoring it - the cull
+* test runs before that patch, so a bounded layer with parallax would be
+* culled at its static base-offset bounds while actually rendering elsewhere.
+* Such a layer therefore opts out of view culling (`cullable = false`), same
+* as an unbounded layer (exactly like {@link import('./ImageLayerNode').ImageLayerNode}).
+*
+* The node references - but never owns - the {@link TileLayer}: destroying it
+* frees its chunk nodes and their cached geometry but leaves the layer, map,
+* and Loader-owned textures intact.
+*
+* Structural changes made via `_adoptChunk`/`_evictChunk` (chunk streaming)
+* are picked up incrementally as they happen, without a full rebuild.
+* {@link TileLayerNode.refresh} remains available for callers that mutate
+* chunk structure by other means (e.g. a bulk edit that bypasses
+* `_adoptChunk`/`_evictChunk`) and need a full resync. In-place tile edits to
+* existing chunks are picked up automatically via chunk revisions.
+*
+* @advanced
+*/
+var TileLayerNode = class extends Container {
+	_layer;
+	_cullChunks;
+	_chunkNodes = [];
+	_syncedOpacity = -1;
+	_syncedTint = void 0;
+	_pixelSnapMode = PixelSnapMode.None;
+	_baseOffsetX;
+	_baseOffsetY;
+	/**
+	* Bound once so `TileLayer._addStructuralListener`/`_removeStructuralListener`
+	* add and remove the SAME function reference. Incrementally adds/removes
+	* the `TileChunkNode` child for exactly the chunk that changed - never
+	* triggers a full {@link refresh}, so every other chunk node's
+	* revision-cached geometry survives untouched.
+	*/
+	_onStructuralChange = (event) => {
+		const existingIndex = this._chunkNodes.findIndex((n) => n.chunkX === event.cx && n.chunkY === event.cy);
+		const existing = this._chunkNodes[existingIndex];
+		if (existing) {
+			this._chunkNodes.splice(existingIndex, 1);
+			this.removeChild(existing);
+			existing.destroy();
+		}
+		if (event.chunk === null || event.chunk.empty) return;
+		const node = this._createChunkNode(event.chunk);
+		this._chunkNodes.push(node);
+		this.addChild(node);
+		this._applyTint(node);
+	};
+	constructor(layer, options) {
+		super();
+		this._layer = layer;
+		this._cullChunks = options?.cullable ?? true;
+		this._baseOffsetX = layer.offsetX;
+		this._baseOffsetY = layer.offsetY;
+		this.setPosition(layer.offsetX, layer.offsetY);
+		this._buildChunkNodes();
+		if (!this._layer.bounded || layer.parallaxX !== 1 || layer.parallaxY !== 1 || layer.parallaxScale !== 1) this.cullable = false;
+		this._layer._addStructuralListener(this._onStructuralChange);
+	}
+	/** The runtime layer this node renders. */
+	get layer() {
+		return this._layer;
+	}
+	/**
+	* Render-only pixel-snap mode applied to every chunk node in this layer (and
+	* to chunks rebuilt later by {@link refresh}). Each chunk's rendered origin is
+	* snapped to the active render target's device-pixel grid; because chunk
+	* origins are integer multiples of the integer tile pitch from the same layer
+	* origin, the whole grid stays exact and adjacent chunks cannot drift apart.
+	*
+	* Purely visual: tile data, the layer offset, chunk content revisions, and
+	* culling bounds are never changed. `PixelSnapMode.Geometry` and `PixelSnapMode.Position` both resolve
+	* to coherent origin snapping for tile chunks (chunk quads are already on the
+	* integer pixel grid by construction). Setting the current value is a no-op;
+	* an invalid value throws and leaves the prior mode unchanged.
+	*
+	* @default PixelSnapMode.None
+	* @stable
+	*/
+	get pixelSnapMode() {
+		return this._pixelSnapMode;
+	}
+	set pixelSnapMode(mode) {
+		if (mode === this._pixelSnapMode) return;
+		assertPixelSnapMode(mode);
+		this._pixelSnapMode = mode;
+		for (const chunk of this._chunkNodes) chunk.pixelSnapMode = mode;
+	}
+	/**
+	* Rebuild the chunk-node children from the layer's current loaded chunks.
+	* Call after structural mutation that creates or empties chunks. In-place
+	* tile edits to existing chunks do not need a refresh.
+	*/
+	refresh() {
+		const previous = [...this._chunkNodes];
+		this.removeChildren();
+		this._chunkNodes.length = 0;
+		for (const child of previous) child.destroy();
+		this._syncedOpacity = -1;
+		this._syncedTint = void 0;
+		this._buildChunkNodes();
+		return this;
+	}
+	/** The chunk render nodes owned by this layer node, in build order. @internal */
+	get chunkNodes() {
+		return this._chunkNodes;
+	}
+	/**
+	* Recomputed lazily on read, so it writes `_localBounds` directly rather than
+	* going through `_setLocalBounds`: an invalidating write inside a getter
+	* would re-dirty the node on every read.
+	*/
+	getLocalBounds() {
+		const bounds = this._localBounds;
+		const { pixelHeight, pixelWidth } = this._layer;
+		if (pixelWidth !== void 0 && pixelHeight !== void 0) bounds.set(0, 0, pixelWidth, pixelHeight);
+		else if (this._chunkNodes.length > 0) aggregateChildLocalBounds(this._chunkNodes, bounds);
+		return bounds;
+	}
+	/** @internal */
+	_collectContent(builder) {
+		if (!this._layer.visible) return;
+		this._syncTint();
+		const layer = this._layer;
+		const patchesPosition = layer.parallaxX !== 1 || layer.parallaxY !== 1;
+		const patchesScale = layer.parallaxScale !== 1;
+		if (patchesPosition || patchesScale) {
+			const camCenter = builder.view.center;
+			const prevX = this.x;
+			const prevY = this.y;
+			const prevScaleX = this.scale.x;
+			const prevScaleY = this.scale.y;
+			if (patchesPosition) {
+				this.x = this._baseOffsetX + camCenter.x * (1 - layer.parallaxX);
+				this.y = this._baseOffsetY + camCenter.y * (1 - layer.parallaxY);
+			}
+			if (patchesScale) this.setScale(prevScaleX * layer.parallaxScale, prevScaleY * layer.parallaxScale);
+			try {
+				super._collectContent(builder);
+			} finally {
+				if (patchesPosition) this.setPosition(prevX, prevY);
+				if (patchesScale) this.setScale(prevScaleX, prevScaleY);
+			}
+		} else super._collectContent(builder);
+	}
+	destroy() {
+		this._layer._removeStructuralListener(this._onStructuralChange);
+		const children = [...this._chunkNodes];
+		this._chunkNodes.length = 0;
+		super.destroy();
+		for (const child of children) child.destroy();
+	}
+	_buildChunkNodes() {
+		const layer = this._layer;
+		for (const chunk of layer.loadedChunks()) {
+			if (chunk.empty) continue;
+			const node = this._createChunkNode(chunk);
+			this._chunkNodes.push(node);
+			this.addChild(node);
+		}
+		this._syncTint();
+	}
+	/**
+	* Construct one configured {@link TileChunkNode} for `chunk` - shared by
+	* the initial bulk build ({@link _buildChunkNodes}) and the incremental
+	* structural-listener handler, so a future constructor argument or
+	* per-node setting only needs to be added in one place.
+	*/
+	_createChunkNode(chunk) {
+		const layer = this._layer;
+		const node = new TileChunkNode(chunk, layer.tilesets, layer.tileWidth, layer.tileHeight, layer.chunkWidth, layer.chunkHeight);
+		node.cullable = this._cullChunks;
+		if (this._pixelSnapMode !== PixelSnapMode.None) node.pixelSnapMode = this._pixelSnapMode;
+		return node;
+	}
+	/**
+	* Compute and apply this layer's live tint (opacity as alpha, `tintColor`
+	* as RGB multiply) to a single chunk node. Used both by {@link _syncTint}'s
+	* bulk pass and by the structural-listener handler for a freshly-added
+	* node - a node added between two "nothing changed" full syncs must still
+	* receive the current tint, which a change-detection-guarded bulk pass
+	* alone would skip.
+	*/
+	_applyTint(node) {
+		const tintColor = this._layer.tintColor;
+		const r = tintColor === null ? 255 : tintColor >> 16 & 255;
+		const g = tintColor === null ? 255 : tintColor >> 8 & 255;
+		const b = tintColor === null ? 255 : tintColor & 255;
+		node.tint.set(r, g, b, this._layer.opacity);
+	}
+	/**
+	* Propagate the layer's live opacity and tint colour onto every chunk
+	* render tint if either changed since the last call. Opacity drives the
+	* tint alpha; `tintColor` (`0xRRGGBB`) multiplies the RGB (white = no tint).
+	*/
+	_syncTint() {
+		const opacity = this._layer.opacity;
+		const tintColor = this._layer.tintColor;
+		if (opacity === this._syncedOpacity && tintColor === this._syncedTint) return;
+		for (const child of this._chunkNodes) this._applyTint(child);
+		this._syncedOpacity = opacity;
+		this._syncedTint = tintColor;
+	}
+};
 
+//#endregion
 export { TileLayerNode };
-//# sourceMappingURL=TileLayerNode.js.map
+//# sourceMappingURL=TileLayerNode.js.map

package/dist/esm/TileLayerNode.js.map

@@ -1 +1 @@
-{"version":3,"file":"TileLayerNode.js","sources":["../../../src/TileLayerNode.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"TileLayerNode.js","names":[],"sources":["../../src/TileLayerNode.ts"],"sourcesContent":["import type { ReadonlyRectangle } from '@codexo/exojs';\nimport { Container } from '@codexo/exojs';\nimport { PixelSnapMode, type RenderPlanBuilder } from '@codexo/exojs/renderer-sdk';\n\nimport { aggregateChildLocalBounds } from './nodeBounds';\nimport { assertPixelSnapMode } from './pixelSnap';\nimport type { ReadonlyTileChunk } from './TileChunk';\nimport { TileChunkNode } from './TileChunkNode';\nimport type { ChunkStructuralEvent, TileLayer } from './TileLayer';\n\n/**\n * Options for a {@link TileLayerNode}. All optional; reserved for forward\n * compatibility.\n * @advanced\n */\nexport interface TileLayerNodeOptions {\n  /**\n   * Whether the layer's chunk nodes participate in per-chunk view culling.\n   * Defaults to `true`. Disable only for tiny, always-on-screen layers where\n   * the per-chunk bounds test is pure overhead.\n   */\n  readonly cullable?: boolean;\n}\n\n/**\n * A scene node that renders one generic {@link TileLayer} as a\n * {@link Container} of per-chunk {@link TileChunkNode} drawables.\n *\n * Each non-empty loaded chunk becomes one child positioned at its pixel\n * origin, so the engine's existing per-node culling drops individual chunks and\n * the render-plan optimiser batches them by tileset texture. The layer's pixel\n * `offset` is applied to this node's transform; `visible` and `opacity` are\n * read live from the runtime layer on every frame (no rebuild required).\n *\n * A `parallax` factor other than `1` makes this node's rendered position\n * camera-dependent, resolved per frame in {@link _collectContent} by patching\n * the node position against the camera centre, then restoring it - the cull\n * test runs before that patch, so a bounded layer with parallax would be\n * culled at its static base-offset bounds while actually rendering elsewhere.\n * Such a layer therefore opts out of view culling (`cullable = false`), same\n * as an unbounded layer (exactly like {@link import('./ImageLayerNode').ImageLayerNode}).\n *\n * The node references - but never owns - the {@link TileLayer}: destroying it\n * frees its chunk nodes and their cached geometry but leaves the layer, map,\n * and Loader-owned textures intact.\n *\n * Structural changes made via `_adoptChunk`/`_evictChunk` (chunk streaming)\n * are picked up incrementally as they happen, without a full rebuild.\n * {@link TileLayerNode.refresh} remains available for callers that mutate\n * chunk structure by other means (e.g. a bulk edit that bypasses\n * `_adoptChunk`/`_evictChunk`) and need a full resync. In-place tile edits to\n * existing chunks are picked up automatically via chunk revisions.\n *\n * @advanced\n */\nexport class TileLayerNode extends Container {\n  private readonly _layer: TileLayer;\n  private readonly _cullChunks: boolean;\n  private readonly _chunkNodes: TileChunkNode[] = [];\n  private _syncedOpacity = -1;\n  private _syncedTint: number | null | undefined = undefined;\n  private _pixelSnapMode: PixelSnapMode = PixelSnapMode.None;\n  private readonly _baseOffsetX: number;\n  private readonly _baseOffsetY: number;\n\n  /**\n   * Bound once so `TileLayer._addStructuralListener`/`_removeStructuralListener`\n   * add and remove the SAME function reference. Incrementally adds/removes\n   * the `TileChunkNode` child for exactly the chunk that changed - never\n   * triggers a full {@link refresh}, so every other chunk node's\n   * revision-cached geometry survives untouched.\n   */\n  private readonly _onStructuralChange = (event: ChunkStructuralEvent): void => {\n    const existingIndex = this._chunkNodes.findIndex(n => n.chunkX === event.cx && n.chunkY === event.cy);\n\n    const existing = this._chunkNodes[existingIndex];\n\n    if (existing) {\n      this._chunkNodes.splice(existingIndex, 1);\n      this.removeChild(existing);\n      existing.destroy();\n    }\n\n    if (event.chunk === null || event.chunk.empty) {\n      return;\n    }\n\n    const node = this._createChunkNode(event.chunk);\n\n    this._chunkNodes.push(node);\n    this.addChild(node);\n    this._applyTint(node);\n  };\n\n  public constructor(layer: TileLayer, options?: TileLayerNodeOptions) {\n    super();\n\n    this._layer = layer;\n    this._cullChunks = options?.cullable ?? true;\n    this._baseOffsetX = layer.offsetX;\n    this._baseOffsetY = layer.offsetY;\n\n    this.setPosition(layer.offsetX, layer.offsetY);\n    this._buildChunkNodes();\n\n    if (!this._layer.bounded || layer.parallaxX !== 1 || layer.parallaxY !== 1 || layer.parallaxScale !== 1) {\n      this.cullable = false;\n    }\n\n    this._layer._addStructuralListener(this._onStructuralChange);\n  }\n\n  /** The runtime layer this node renders. */\n  public get layer(): TileLayer {\n    return this._layer;\n  }\n\n  /**\n   * Render-only pixel-snap mode applied to every chunk node in this layer (and\n   * to chunks rebuilt later by {@link refresh}). Each chunk's rendered origin is\n   * snapped to the active render target's device-pixel grid; because chunk\n   * origins are integer multiples of the integer tile pitch from the same layer\n   * origin, the whole grid stays exact and adjacent chunks cannot drift apart.\n   *\n   * Purely visual: tile data, the layer offset, chunk content revisions, and\n   * culling bounds are never changed. `PixelSnapMode.Geometry` and `PixelSnapMode.Position` both resolve\n   * to coherent origin snapping for tile chunks (chunk quads are already on the\n   * integer pixel grid by construction). Setting the current value is a no-op;\n   * an invalid value throws and leaves the prior mode unchanged.\n   *\n   * @default PixelSnapMode.None\n   * @stable\n   */\n  public get pixelSnapMode(): PixelSnapMode {\n    return this._pixelSnapMode;\n  }\n\n  public set pixelSnapMode(mode: PixelSnapMode) {\n    if (mode === this._pixelSnapMode) {\n      return;\n    }\n\n    assertPixelSnapMode(mode);\n    this._pixelSnapMode = mode;\n\n    for (const chunk of this._chunkNodes) {\n      chunk.pixelSnapMode = mode;\n    }\n  }\n\n  /**\n   * Rebuild the chunk-node children from the layer's current loaded chunks.\n   * Call after structural mutation that creates or empties chunks. In-place\n   * tile edits to existing chunks do not need a refresh.\n   */\n  public refresh(): this {\n    const previous = [...this._chunkNodes];\n\n    this.removeChildren();\n    this._chunkNodes.length = 0;\n\n    for (const child of previous) {\n      child.destroy();\n    }\n\n    this._syncedOpacity = -1;\n    this._syncedTint = undefined;\n    this._buildChunkNodes();\n\n    return this;\n  }\n\n  /** The chunk render nodes owned by this layer node, in build order. @internal */\n  public get chunkNodes(): readonly TileChunkNode[] {\n    return this._chunkNodes;\n  }\n\n  /**\n   * Recomputed lazily on read, so it writes `_localBounds` directly rather than\n   * going through `_setLocalBounds`: an invalidating write inside a getter\n   * would re-dirty the node on every read.\n   */\n  public override getLocalBounds(): ReadonlyRectangle {\n    const bounds = this._localBounds;\n\n    // Reading the pixel extents directly (rather than gating on `bounded`)\n    // is what narrows them to numbers - `bounded` is a plain boolean getter.\n    const { pixelHeight, pixelWidth } = this._layer;\n\n    if (pixelWidth !== undefined && pixelHeight !== undefined) {\n      bounds.set(0, 0, pixelWidth, pixelHeight);\n    } else if (this._chunkNodes.length > 0) {\n      aggregateChildLocalBounds(this._chunkNodes, bounds);\n    }\n\n    return bounds;\n  }\n\n  /** @internal */\n  protected override _collectContent(builder: RenderPlanBuilder): void {\n    if (!this._layer.visible) {\n      return;\n    }\n\n    this._syncTint();\n\n    const layer = this._layer;\n\n    const patchesPosition = layer.parallaxX !== 1 || layer.parallaxY !== 1;\n    const patchesScale = layer.parallaxScale !== 1;\n\n    if (patchesPosition || patchesScale) {\n      const camCenter = builder.view.center;\n      const prevX = this.x;\n      const prevY = this.y;\n      const prevScaleX = this.scale.x;\n      const prevScaleY = this.scale.y;\n\n      if (patchesPosition) {\n        this.x = this._baseOffsetX + camCenter.x * (1 - layer.parallaxX);\n        this.y = this._baseOffsetY + camCenter.y * (1 - layer.parallaxY);\n      }\n\n      if (patchesScale) {\n        this.setScale(prevScaleX * layer.parallaxScale, prevScaleY * layer.parallaxScale);\n      }\n\n      try {\n        super._collectContent(builder);\n      } finally {\n        if (patchesPosition) {\n          this.setPosition(prevX, prevY);\n        }\n\n        if (patchesScale) {\n          this.setScale(prevScaleX, prevScaleY);\n        }\n      }\n    } else {\n      super._collectContent(builder);\n    }\n  }\n\n  public override destroy(): void {\n    this._layer._removeStructuralListener(this._onStructuralChange);\n\n    const children = [...this._chunkNodes];\n\n    this._chunkNodes.length = 0;\n\n    super.destroy();\n\n    for (const child of children) {\n      child.destroy();\n    }\n  }\n\n  private _buildChunkNodes(): void {\n    const layer = this._layer;\n\n    for (const chunk of layer.loadedChunks()) {\n      if (chunk.empty) {\n        continue;\n      }\n\n      const node = this._createChunkNode(chunk);\n\n      this._chunkNodes.push(node);\n      this.addChild(node);\n    }\n\n    this._syncTint();\n  }\n\n  /**\n   * Construct one configured {@link TileChunkNode} for `chunk` - shared by\n   * the initial bulk build ({@link _buildChunkNodes}) and the incremental\n   * structural-listener handler, so a future constructor argument or\n   * per-node setting only needs to be added in one place.\n   */\n  private _createChunkNode(chunk: ReadonlyTileChunk): TileChunkNode {\n    const layer = this._layer;\n    const node = new TileChunkNode(chunk, layer.tilesets, layer.tileWidth, layer.tileHeight, layer.chunkWidth, layer.chunkHeight);\n\n    node.cullable = this._cullChunks;\n\n    if (this._pixelSnapMode !== PixelSnapMode.None) {\n      node.pixelSnapMode = this._pixelSnapMode;\n    }\n\n    return node;\n  }\n\n  /**\n   * Compute and apply this layer's live tint (opacity as alpha, `tintColor`\n   * as RGB multiply) to a single chunk node. Used both by {@link _syncTint}'s\n   * bulk pass and by the structural-listener handler for a freshly-added\n   * node - a node added between two \"nothing changed\" full syncs must still\n   * receive the current tint, which a change-detection-guarded bulk pass\n   * alone would skip.\n   */\n  private _applyTint(node: TileChunkNode): void {\n    const tintColor = this._layer.tintColor;\n    const r = tintColor === null ? 255 : (tintColor >> 16) & 0xff;\n    const g = tintColor === null ? 255 : (tintColor >> 8) & 0xff;\n    const b = tintColor === null ? 255 : tintColor & 0xff;\n    node.tint.set(r, g, b, this._layer.opacity);\n  }\n\n  /**\n   * Propagate the layer's live opacity and tint colour onto every chunk\n   * render tint if either changed since the last call. Opacity drives the\n   * tint alpha; `tintColor` (`0xRRGGBB`) multiplies the RGB (white = no tint).\n   */\n  private _syncTint(): void {\n    const opacity = this._layer.opacity;\n    const tintColor = this._layer.tintColor;\n\n    if (opacity === this._syncedOpacity && tintColor === this._syncedTint) {\n      return;\n    }\n\n    for (const child of this._chunkNodes) {\n      this._applyTint(child);\n    }\n\n    this._syncedOpacity = opacity;\n    this._syncedTint = tintColor;\n  }\n}\n"],"mappings":"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"}