@2112-lab/central-plant 0.3.26 → 0.3.27

package/dist/esm/src/managers/behaviors/IoAnimationManager.js

@@ -219,6 +219,26 @@ var IoAnimationManager = /*#__PURE__*/function (_BaseDisposable) {
       return dps;
     }
 
+    /**
+     * Return the Three.js mesh objects that are animated for a given attachment.
+     * Used by IoOutlineManager to include animated meshes in the outline.
+     *
+     * @param {string} parentUuid
+     * @param {string} attachmentId
+     * @returns {THREE.Object3D[]}
+     */
+  }, {
+    key: "getAnimatedMeshes",
+    value: function getAnimatedMeshes(parentUuid, attachmentId) {
+      var key = this._key(parentUuid, attachmentId);
+      var entries = this._entries.get(key);
+      if (!(entries !== null && entries !== void 0 && entries.length)) return [];
+      // Deduplicate — multiple animations can target the same mesh
+      return _toConsumableArray(new Set(entries.map(function (e) {
+        return e.mesh;
+      })));
+    }
+
     /**
      * Remove all animation entries associated with a given host component.
      * Call when a component is removed from the scene.
@@ -450,7 +470,10 @@ var IoAnimationManager = /*#__PURE__*/function (_BaseDisposable) {
     value: function _applyTranslation(mesh, origPos, transform) {
       var _transform$x, _transform$y, _transform$z;
       if (!transform) return;
-      mesh.position.set(origPos.x + ((_transform$x = transform.x) !== null && _transform$x !== void 0 ? _transform$x : 0), origPos.y + ((_transform$y = transform.y) !== null && _transform$y !== void 0 ? _transform$y : 0), origPos.z + ((_transform$z = transform.z) !== null && _transform$z !== void 0 ? _transform$z : 0));
+      // X and Y are negated to match the sign convention used in the AnimateDevicesDialog
+      // preview (_syncViewerTransform negates x and y before calling setMeshPreviewOffset).
+      // Z is added directly (no negation) — matching the dialog's z handling.
+      mesh.position.set(origPos.x - ((_transform$x = transform.x) !== null && _transform$x !== void 0 ? _transform$x : 0), origPos.y - ((_transform$y = transform.y) !== null && _transform$y !== void 0 ? _transform$y : 0), origPos.z + ((_transform$z = transform.z) !== null && _transform$z !== void 0 ? _transform$z : 0));
     }
 
     /**

package/dist/esm/src/managers/behaviors/IoOutlineManager.js

@@ -0,0 +1,234 @@
+import { inherits as _inherits, createClass as _createClass, superPropGet as _superPropGet, createForOfIteratorHelper as _createForOfIteratorHelper, classCallCheck as _classCallCheck, callSuper as _callSuper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from 'three';
+import { BaseDisposable } from '../../core/baseDisposable.js';
+
+/**
+ * Three.js layer reserved exclusively for the outline mask pass.
+ * Layer 20 is high enough to be well clear of typical app layer usage.
+ */
+var OUTLINE_LAYER = 20;
+
+// ── Shaders ──────────────────────────────────────────────────────────────────
+
+var VERT_SHADER = /* glsl */"\nvarying vec2 vUv;\nvoid main() {\n  vUv = uv;\n  gl_Position = vec4(position.xy, 0.0, 1.0);\n}\n";
+
+/**
+ * Screen-space outline shader.
+ *
+ * Samples in a circular kernel to find the nearest filled (silhouette) pixel.
+ * Applies a smooth alpha falloff at the outer edge using smoothstep so the
+ * outline fades cleanly rather than cutting off hard.
+ *
+ * RADIUS  — maximum distance in pixels from the silhouette edge to draw.
+ * SAMPLES — kernel half-extent; must be an integer ≥ ceil(RADIUS).
+ */
+var FRAG_SHADER = /* glsl */"\nuniform sampler2D tMask;\nuniform vec2 uInvSize;\nvarying vec2 vUv;\n\nconst float RADIUS  = 3.0;   // total outline width in pixels\nconst int   SAMPLES = 4;     // kernel half-extent (\u2265 ceil(RADIUS))\n\nvoid main() {\n  float center = texture2D(tMask, vUv).r;\n\n  // Pixels inside the silhouette: the main render already drew them.\n  if (center > 0.5) discard;\n\n  // Find the closest filled neighbour within the circular kernel.\n  float minDist = 99.0;\n  for (int x = -SAMPLES; x <= SAMPLES; x++) {\n    for (int y = -SAMPLES; y <= SAMPLES; y++) {\n      float dist = length(vec2(float(x), float(y)));\n      if (dist > RADIUS + 1.0) continue;   // skip corners outside circle\n      vec2 offset = vec2(float(x), float(y)) * uInvSize;\n      if (texture2D(tMask, vUv + offset).r > 0.5) {\n        minDist = min(minDist, dist);\n      }\n    }\n  }\n\n  if (minDist > RADIUS + 0.5) discard;\n\n  // Smooth alpha: full opacity near the edge, fades to 0 at RADIUS pixels out.\n  float alpha = 1.0 - smoothstep(RADIUS - 1.0, RADIUS + 0.5, minDist);\n  gl_FragColor = vec4(1.0, 1.0, 1.0, alpha);\n}\n";
+var IoOutlineManager = /*#__PURE__*/function (_BaseDisposable) {
+  function IoOutlineManager(sceneViewer) {
+    var _this;
+    _classCallCheck(this, IoOutlineManager);
+    _this = _callSuper(this, IoOutlineManager);
+    _this.sceneViewer = sceneViewer;
+    _this._maskTarget = null;
+    _this._maskMat = null;
+    _this._overlayScene = null;
+    _this._overlayCamera = null;
+    _this._overlayMat = null;
+
+    /**
+     * Meshes that have been moved onto OUTLINE_LAYER, stored with their
+     * original layers.mask so they can be restored on clearance.
+     * @type {{ mesh: THREE.Mesh, originalMask: number }[]}
+     */
+    _this._layeredMeshes = [];
+
+    /** @type {boolean} Whether an outline is currently active. */
+    _this.isActive = false;
+    return _this;
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // PUBLIC API
+  // ─────────────────────────────────────────────────────────────────────────
+
+  /**
+   * Set the objects to outline.  Pass an empty array (or call with no args)
+   * to remove the outline.
+   * @param {THREE.Object3D[]} objects
+   */
+  _inherits(IoOutlineManager, _BaseDisposable);
+  return _createClass(IoOutlineManager, [{
+    key: "setTargets",
+    value: function setTargets() {
+      var _this2 = this;
+      var objects = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      this._clearLayeredMeshes();
+      if (!objects.length) {
+        this.isActive = false;
+        return;
+      }
+      objects.forEach(function (obj) {
+        obj.traverse(function (child) {
+          if (!child.isMesh) return;
+          var originalMask = child.layers.mask;
+          child.layers.enable(OUTLINE_LAYER);
+          _this2._layeredMeshes.push({
+            mesh: child,
+            originalMask: originalMask
+          });
+        });
+      });
+      this.isActive = this._layeredMeshes.length > 0;
+    }
+
+    /**
+     * Render one frame: main scene → mask pass → outline composite.
+     * Must be called instead of renderer.render() when isActive is true.
+     */
+  }, {
+    key: "render",
+    value: function render() {
+      var sv = this.sceneViewer;
+      var renderer = sv.renderer,
+        scene = sv.scene,
+        camera = sv.camera;
+      if (!renderer || !scene || !camera) return;
+
+      // ── Step 1: Normal scene render — sky, transparency, all unaffected ──
+      renderer.render(scene, camera);
+      if (!this.isActive) return;
+      this._ensureResources();
+      if (!this._maskTarget) return;
+
+      // Stash renderer / scene / camera state we are about to mutate
+      var prevBg = scene.background;
+      var prevOverride = scene.overrideMaterial;
+      var prevLayerMask = camera.layers.mask;
+      var prevAutoClear = renderer.autoClear;
+      var prevClearClr = renderer.getClearColor(new THREE.Color());
+      var prevClearA = renderer.getClearAlpha();
+
+      // ── Step 2: Render the device silhouette into the private mask target ──
+      scene.background = null; // transparent clear
+      scene.overrideMaterial = this._maskMat; // flat white for all geometry
+      camera.layers.set(OUTLINE_LAYER); // only see the device meshes
+      renderer.setClearColor(0x000000, 0);
+      renderer.autoClear = true;
+      renderer.setRenderTarget(this._maskTarget);
+      renderer.render(scene, camera);
+      renderer.setRenderTarget(null);
+
+      // Restore mutated state
+      scene.background = prevBg;
+      scene.overrideMaterial = prevOverride;
+      camera.layers.mask = prevLayerMask;
+      renderer.setClearColor(prevClearClr, prevClearA);
+
+      // ── Step 3: Composite the outline on top without clearing the framebuffer
+      renderer.autoClear = false;
+      renderer.render(this._overlayScene, this._overlayCamera);
+      renderer.autoClear = prevAutoClear;
+    }
+
+    /**
+     * Call when the canvas is resized to keep the mask target and shader in sync.
+     * @param {number} width
+     * @param {number} height
+     */
+  }, {
+    key: "setSize",
+    value: function setSize(width, height) {
+      if (this._maskTarget) this._maskTarget.setSize(width, height);
+      if (this._overlayMat) {
+        this._overlayMat.uniforms.uInvSize.value.set(1 / width, 1 / height);
+      }
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this._clearLayeredMeshes();
+      if (this._maskTarget) {
+        this._maskTarget.dispose();
+        this._maskTarget = null;
+      }
+      if (this._maskMat) {
+        this._maskMat.dispose();
+        this._maskMat = null;
+      }
+      if (this._overlayMat) {
+        this._overlayMat.dispose();
+        this._overlayMat = null;
+      }
+      _superPropGet(IoOutlineManager, "dispose", this, 3)([]);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // PRIVATE
+    // ─────────────────────────────────────────────────────────────────────────
+
+    /** Lazy-initialise GPU resources on first use. */
+  }, {
+    key: "_ensureResources",
+    value: function _ensureResources() {
+      if (this._maskTarget) return;
+      var renderer = this.sceneViewer.renderer;
+      if (!renderer) return;
+      var size = renderer.getSize(new THREE.Vector2());
+      var w = size.x;
+      var h = size.y;
+
+      // Private render target — receives the flat white device silhouette
+      this._maskTarget = new THREE.WebGLRenderTarget(w, h);
+
+      // Flat white material used during the mask pass
+      this._maskMat = new THREE.MeshBasicMaterial({
+        color: 0xffffff
+      });
+
+      // Screen-space overlay: reads the mask and draws only the outline pixels
+      this._overlayMat = new THREE.ShaderMaterial({
+        uniforms: {
+          tMask: {
+            value: this._maskTarget.texture
+          },
+          uInvSize: {
+            value: new THREE.Vector2(1 / w, 1 / h)
+          }
+        },
+        vertexShader: VERT_SHADER,
+        fragmentShader: FRAG_SHADER,
+        transparent: true,
+        depthTest: false,
+        depthWrite: false
+      });
+      var quad = new THREE.Mesh(new THREE.PlaneGeometry(2, 2), this._overlayMat);
+      quad.frustumCulled = false;
+      this._overlayScene = new THREE.Scene();
+      this._overlayScene.add(quad);
+      this._overlayCamera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
+    }
+
+    /** Remove OUTLINE_LAYER from all tracked meshes and clear the list. */
+  }, {
+    key: "_clearLayeredMeshes",
+    value: function _clearLayeredMeshes() {
+      var _iterator = _createForOfIteratorHelper(this._layeredMeshes),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _step.value,
+            mesh = _step$value.mesh,
+            originalMask = _step$value.originalMask;
+          mesh.layers.mask = originalMask;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      this._layeredMeshes = [];
+    }
+  }]);
+}(BaseDisposable);
+
+export { IoOutlineManager };