@preference-sl/pref-viewer 2.17.0-beta.0 → 2.17.0-beta.1

package/src/babylonjs-animation-overlay-controller.js

@@ -0,0 +1,145 @@
+import { InstancedMesh, Mesh, Quaternion, UtilityLayerRenderer, Vector3 } from "@babylonjs/core";
+
+/**
+ * Owns one animated-mesh overlay group, its utility scene and transform observers.
+ * Groups retain independent caches and release only their own rendering resources.
+ * @class BabylonJSAnimationOverlayController
+ */
+export default class BabylonJSAnimationOverlayController {
+    #utilityLayer;
+    #color;
+    #baseToOverlayBase = new Map();
+    #pairs = [];
+    #observers = [];
+    #position = new Vector3();
+    #scale = new Vector3();
+    #rotation = new Quaternion();
+    #disposed = false;
+
+    /**
+     * Creates presentation meshes and follows their original world transforms.
+     * @public
+     * @param {import("@babylonjs/core").Scene} scene - Host scene used by the utility renderer.
+     * @param {Array<import("@babylonjs/core").AbstractMesh>} meshes - Original meshes to highlight.
+     * @param {import("@babylonjs/core").Color3} color - Highlight color for the group.
+     */
+    constructor(scene, meshes, color) {
+        this.#color = color;
+        this.#utilityLayer = new UtilityLayerRenderer(scene, undefined, undefined);
+        for (const mesh of meshes) {
+            this.#createOverlay(mesh);
+        }
+        for (const pair of this.#pairs) {
+            if (!pair.original.getWorldMatrix) {
+                continue;
+            }
+            pair.original.computeWorldMatrix(true);
+            this.#syncPair(pair);
+            const observer = pair.original.onAfterWorldMatrixUpdateObservable?.add(() => this.#syncPair(pair));
+            if (observer) {
+                this.#observers.push({ mesh: pair.original, observer });
+            }
+        }
+    }
+
+    /**
+     * Resolves the source geometry mesh for an instance or returns a regular mesh unchanged.
+     * @private
+     * @static
+     * @param {import("@babylonjs/core").AbstractMesh} mesh - Original mesh.
+     * @returns {import("@babylonjs/core").Mesh} Mesh supplying the overlay geometry.
+     */
+    static #getBaseMesh(mesh) {
+        return mesh instanceof InstancedMesh ? mesh.sourceMesh : mesh;
+    }
+
+    /**
+     * Creates or reuses the group's presentation base for a source mesh.
+     * @private
+     * @param {import("@babylonjs/core").Mesh} baseMesh - Source mesh to clone.
+     * @returns {import("@babylonjs/core").Mesh} Cached overlay base.
+     */
+    #ensureOverlayBase(baseMesh) {
+        let overlayBase = this.#baseToOverlayBase.get(baseMesh);
+        if (overlayBase) {
+            return overlayBase;
+        }
+        // Register the clone in its owning scene from creation; changing _scene later
+        // leaves Babylon's node and root-node registries in the original scene.
+        overlayBase = new Mesh(baseMesh.name + "_overlayBase", this.#utilityLayer.utilityLayerScene, null, baseMesh, true, false);
+        overlayBase.isPickable = false;
+        overlayBase.isVisible = false;
+        overlayBase.setEnabled(true);
+        overlayBase.renderOutline = false;
+        overlayBase.outlineColor = this.#color;
+        overlayBase.outlineWidth = 1.5;
+        overlayBase.renderOverlay = true;
+        overlayBase.overlayColor = this.#color;
+        overlayBase.overlayAlpha = 0.25;
+        overlayBase.visibility = 1;
+        overlayBase.renderingGroupId = 0;
+        this.#baseToOverlayBase.set(baseMesh, overlayBase);
+        return overlayBase;
+    }
+
+    /**
+     * Adds a presentation mesh or an instance of a cached presentation base.
+     * @private
+     * @param {import("@babylonjs/core").AbstractMesh} mesh - Original mesh to present.
+     * @returns {void}
+     */
+    #createOverlay(mesh) {
+        if (!mesh.geometry && !mesh.getChildMeshes) {
+            return;
+        }
+        const baseMesh = BabylonJSAnimationOverlayController.#getBaseMesh(mesh);
+        const overlayBase = this.#ensureOverlayBase(baseMesh);
+        const overlay = mesh instanceof InstancedMesh ? overlayBase.createInstance(mesh.name + "_overlayInst") : overlayBase;
+        if (mesh instanceof InstancedMesh) {
+            overlay.isPickable = false;
+        } else {
+            overlay.isVisible = true;
+        }
+        overlay.parent = null;
+        overlay.renderingGroupId = 0;
+        this.#pairs.push({ original: mesh, overlay });
+    }
+
+    /**
+     * Copies an original world transform to its overlay using reusable group-local scratch vectors.
+     * @private
+     * @param {{original:object,overlay:object}} pair - Original and presentation mesh pair.
+     * @returns {void}
+     */
+    #syncPair(pair) {
+        pair.original.getWorldMatrix().decompose(this.#scale, this.#rotation, this.#position);
+        pair.overlay.position.copyFrom(this.#position);
+        pair.overlay.scaling.copyFrom(this.#scale);
+        pair.overlay.rotationQuaternion = pair.overlay.rotationQuaternion || new Quaternion();
+        pair.overlay.rotationQuaternion.copyFrom(this.#rotation);
+        pair.overlay.computeWorldMatrix(true);
+    }
+
+    /**
+     * Removes transform observers and disposes each owned mesh and the utility renderer once.
+     * @public
+     * @returns {void}
+     */
+    dispose() {
+        if (this.#disposed) {
+            return;
+        }
+        this.#disposed = true;
+        for (const { mesh, observer } of this.#observers) {
+            mesh.onAfterWorldMatrixUpdateObservable?.remove(observer);
+        }
+        const overlays = new Set([...this.#pairs.map(pair => pair.overlay), ...this.#baseToOverlayBase.values()]);
+        for (const overlay of overlays) {
+            overlay.dispose();
+        }
+        this.#utilityLayer.dispose();
+        this.#observers.length = 0;
+        this.#pairs.length = 0;
+        this.#baseToOverlayBase.clear();
+    }
+}