@smarterplan/ngx-smarterplan-core 1.2.0 → 1.2.1

package/esm2020/lib/matterport-extensions/nest-thermostat/CanvasImage.mjs

@@ -0,0 +1,51 @@
+import { SceneComponent } from './../scene-component/SceneComponent';
+export class CanvasImage extends SceneComponent {
+    constructor() {
+        super(...arguments);
+        this.image = null;
+        this.inputs = {
+            src: null,
+            srcPosition: { x: 0, y: 0 },
+            srcSize: { w: 64, h: 64 },
+            destPosition: { x: 0, y: 0 },
+            destSize: { w: 64, h: 64 },
+        };
+        this.outputs = {
+            painter: null,
+        };
+    }
+    onInit() {
+        this.outputs.painter = this;
+        this.maybeLoadImage();
+    }
+    onInputsUpdated() {
+        this.maybeLoadImage();
+    }
+    paint(context2d, size) {
+        if (!this.image) {
+            return;
+        }
+        context2d.clearRect(0, 0, this.inputs.destSize.w, this.inputs.destSize.h);
+        if (this.image.width > 0) {
+            context2d.drawImage(this.image, this.inputs.srcPosition.x, this.inputs.srcPosition.y, this.inputs.srcSize.w, this.inputs.srcSize.h, this.inputs.destPosition.x, this.inputs.destPosition.y, this.inputs.destSize.w, this.inputs.destSize.h);
+        }
+    }
+    maybeLoadImage() {
+        this.image = null;
+        if (this.inputs.src !== null && this.inputs.src !== '') {
+            const that = this;
+            this.image = new Image();
+            this.image.crossOrigin = 'anonymous';
+            this.image.src = this.inputs.src;
+            this.image.onload = function (event) {
+                // that.notify('paint.ready');
+            };
+        }
+        // this.notify('paint.ready');
+    }
+}
+export const canvasImageType = 'mp.canvasImage';
+export function makeCanvasImage() {
+    return new CanvasImage();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/matterport-extensions/nest-thermostat/CanvasRenderer.mjs

@@ -0,0 +1,62 @@
+import { SceneComponent } from '../scene-component/SceneComponent';
+import { CanvasTexture } from 'three';
+export class CanvasRenderer extends SceneComponent {
+    constructor() {
+        super(...arguments);
+        this.inputs = {
+            painter: null,
+            textureRes: { w: 1024, h: 1024 }, // dim for thermostat
+        };
+        this.outputs = {
+            texture: null,
+        };
+        this.events = {
+            repaint: true,
+        };
+    }
+    onInit(ci) {
+        // set up canvas 2d context
+        this.canvas = document.createElement('canvas');
+        this.renderContext2D = this.canvas.getContext('2d');
+        this.outputs.texture = new CanvasTexture(this.canvas);
+        // this.inputs.painter = ci; // FOR TV ONLY
+        this.resize(this.inputs.textureRes);
+        this.repaint();
+    }
+    setCanvasNestThermostatPainter(sc) {
+        this.inputs.painter = sc;
+    }
+    onInputsUpdated(oldInputs) {
+        if (oldInputs.textureRes.w !== this.inputs.textureRes.w ||
+            oldInputs.textureRes.h !== this.inputs.textureRes.h) {
+            this.resize(this.inputs.textureRes);
+        }
+        if (oldInputs.painter !== this.inputs.painter) {
+            this.repaint();
+        }
+    }
+    onEvent(eventType, _eventData) {
+        if (eventType === 'repaint') {
+            this.repaint();
+        }
+    }
+    onDestroy() {
+        this.outputs.texture.dispose();
+        this.outputs.texture = null;
+    }
+    resize(size) {
+        this.canvas.width = size.w;
+        this.canvas.height = size.h;
+    }
+    repaint() {
+        if (this.inputs.painter) {
+            this.inputs.painter.paint(this.renderContext2D, this.inputs.textureRes);
+            this.outputs.texture.needsUpdate = true;
+        }
+    }
+}
+export const canvasRendererType = 'mp.canvasRenderer';
+export function makeCanvasRenderer() {
+    return new CanvasRenderer();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/matterport-extensions/nest-thermostat/NestThermostat.mjs

@@ -0,0 +1,158 @@
+import { SceneComponent } from '../scene-component/SceneComponent';
+import { AnimationMixer, LoopOnce, AnimationClip, VectorKeyframeTrack, InterpolateSmooth, MeshBasicMaterial } from 'three';
+const HoverEvent = 'hover';
+const UnhoverEvent = 'unhover';
+const RepaintEvent = 'repaint';
+export class NestThermostat extends SceneComponent {
+    constructor() {
+        super(...arguments);
+        this.cv = null;
+        this.planeRenderer = null;
+        this.rootScene = null;
+        this.mixer = null;
+        this.onEnterClip = null;
+        this.mesh = null;
+        this.currentTime = 0;
+        this.nextUpdate = 0;
+        this.temperature = 0;
+        this.tempChangeRange = 5;
+        this.inputs = {
+            loadingState: 'Idle',
+            texture: null,
+            updateInterval: 1000,
+        };
+        this.outputs = {
+            painter: null,
+            visible: false,
+        };
+        this.events = {
+            [HoverEvent]: true,
+            [UnhoverEvent]: true,
+        };
+    }
+    onInit(modelNode, plane, inputTexture) {
+        if (!this.context) {
+            this.context = {
+                root: modelNode
+            };
+        }
+        this.inputs.texture = inputTexture;
+        const root = this.context.root;
+        const THREE = this.context.three;
+        this.planeRenderer = plane;
+        this.planeRenderer.outputs.objectRoot.translateZ(0.05);
+        this.planeRenderer.outputs.objectRoot.translateY(0.4);
+        this.planeRenderer.outputs.objectRoot.scale.set(0.5, 0.5, 0.5);
+        // planeRenderer.inputs.localPosition.z = 0.05;
+        // planeRenderer.inputs.localPosition.y = 0.4;
+        // planeRenderer.inputs.localScale = {x: 0.5, y: 0.5, z: 0.5};
+        this.outputs.painter = this;
+        this.mixer = new AnimationMixer(this.planeRenderer.outputs.objectRoot);
+        const tm = 0.2;
+        const positionTrack = new VectorKeyframeTrack('.scale', [0, tm], [
+            0, 0, 0,
+            0.5, 0.5, 0.5
+        ], InterpolateSmooth);
+        this.onEnterClip = new AnimationClip(null, tm, [positionTrack]);
+    }
+    onInputsUpdated() {
+        if (this.inputs.loadingState === 'Loaded') {
+            const lines = [];
+            //@ts-ignore
+            this.context.root.obj3D.traverse((obj) => {
+                // we dont want line segments, track them and remove them.
+                if (obj.type === 'LineSegments') {
+                    lines.push(obj);
+                }
+                else if (obj.type === 'Mesh') {
+                    this.mesh = obj;
+                    const materials = this.mesh.material;
+                    materials.forEach((m, idx) => {
+                        if (m && m.map.source.data.outerHTML.indexOf('_5b76dbe388862300126c1e14') !== -1) {
+                            const newMaterial = new MeshBasicMaterial({ map: this.inputs.texture });
+                            this.mesh.material[idx] = newMaterial;
+                        }
+                    });
+                }
+            });
+            // remove the line segments.
+            lines.forEach((line) => {
+                line.parent.remove(line);
+            });
+        }
+    }
+    onEvent(eventType, eventData) {
+        if (eventType === HoverEvent) {
+            const data = eventData;
+            if (data.hover) {
+                this.outputs.visible = true;
+                const onEnterAction = this.mixer.clipAction(this.onEnterClip);
+                onEnterAction.stop();
+                onEnterAction.loop = LoopOnce;
+                onEnterAction.clampWhenFinished = true;
+                onEnterAction.play();
+            }
+            else {
+                this.outputs.visible = false;
+            }
+        }
+    }
+    paint(context2d, size) {
+        const x = 490;
+        const y = 490;
+        context2d.fillStyle = 'black';
+        context2d.beginPath();
+        context2d.arc(x, y, 400, 0, Math.PI * 2);
+        context2d.fill();
+        context2d.fillStyle = '#CF5300';
+        context2d.beginPath();
+        context2d.arc(x, y, 300, 0, Math.PI * 2);
+        context2d.fill();
+        context2d.beginPath();
+        context2d.strokeStyle = 'orange';
+        context2d.arc(x, y, 240, 0.75 * Math.PI, 0.25 * Math.PI);
+        context2d.lineCap = 'butt';
+        context2d.lineWidth = 80;
+        context2d.stroke();
+        context2d.fillStyle = 'white';
+        context2d.font = '220px Arial';
+        context2d.fillText(`${this.temperature}`, x - 115, y + 75);
+        this.outputs.visible = true;
+    }
+    onTick(delta) {
+        this.currentTime += delta;
+        if (this.mixer) {
+            this.mixer.update(delta / 1000);
+        }
+        if (this.currentTime > this.nextUpdate) {
+            this.nextUpdate += this.inputs.updateInterval;
+            this.temperature += (Math.random() * this.tempChangeRange);
+            this.temperature = Math.trunc(this.temperature);
+            if (this.temperature > 99) {
+                this.temperature = 99;
+                this.tempChangeRange = -this.tempChangeRange;
+            }
+            if (this.temperature < 10) {
+                this.temperature = 10;
+                this.tempChangeRange = -this.tempChangeRange;
+            }
+            this.component.notify(RepaintEvent);
+            this.cv.repaint();
+        }
+    }
+    setComponent(component, plane, cv) {
+        component.onTick = this.onTick.bind(this);
+        // plane.onTick = this.onTick.bind(this);
+        this.cv = cv;
+        this.component = component;
+        this.context = component.context;
+    }
+    setRootScene(rootScene) {
+        this.rootScene = rootScene;
+    }
+}
+export const nestThermostatType = 'mp.nestThermostat';
+export const makeNestThermostat = function () {
+    return new NestThermostat();
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NestThermostat.js","sourceRoot":"","sources":["../../../../../../projects/ngx-smarterplan-core/src/lib/matterport-extensions/nest-thermostat/NestThermostat.ts"],"names":[],"mappings":"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","sourcesContent":["import {SceneComponent, ComponentOutput, ComponentContext} from '../scene-component/SceneComponent';\nimport {\n  Object3D,\n  AnimationMixer,\n  AnimationAction,\n  LoopOnce,\n  AnimationClip,\n  Mesh,\n  Texture,\n  MeshLambertMaterial,\n  VectorKeyframeTrack,\n  InterpolateSmooth,\n  MeshBasicMaterial,\n  LineSegments\n} from 'three';\nimport {CanvasRenderer, IPainter2d} from './CanvasRenderer';\nimport {PlaneRenderer, Size} from './PlaneRenderer';\n\nconst HoverEvent = 'hover';\nconst UnhoverEvent = 'unhover';\nconst RepaintEvent = 'repaint';\n\ntype Inputs = {\n  loadingState: string;\n  texture: Texture | null;\n  updateInterval: number;\n}\n\ntype Outputs = {\n  painter: IPainter2d | null;\n  visible: boolean;\n} & ComponentOutput;\n\n\nexport class NestThermostat extends SceneComponent implements IPainter2d {\n  private cv: CanvasRenderer | null = null;\n  private planeRenderer: PlaneRenderer | null = null;\n  private rootScene: Object3D | null = null;\n  private mixer: AnimationMixer | null = null;\n  private onEnterClip: AnimationClip | null = null;\n  private mesh: Mesh | null = null;\n  private currentTime: number = 0;\n  private nextUpdate: number = 0;\n  private temperature: number = 0;\n  private tempChangeRange: number = 5;\n  private component: SceneComponent;\n\n\n  override inputs: Inputs = {\n    loadingState: 'Idle',\n    texture: null,\n    updateInterval: 1000,\n  }\n\n  override outputs = {\n    painter: null,\n    visible: false,\n  } as Outputs;\n\n  override events = {\n    [HoverEvent]: true,\n    [UnhoverEvent]: true,\n  };\n\n  override onInit(modelNode?: any, plane?: PlaneRenderer, inputTexture?: any) {\n    if (!this.context) {\n      this.context = {\n        root: modelNode\n      } as ComponentContext;\n    }\n    this.inputs.texture = inputTexture;\n    const root = this.context.root;\n    const THREE = this.context.three;\n\n    this.planeRenderer = plane;\n    this.planeRenderer.outputs.objectRoot.translateZ(0.05);\n    this.planeRenderer.outputs.objectRoot.translateY(0.4);\n    this.planeRenderer.outputs.objectRoot.scale.set(0.5, 0.5, 0.5);\n    // planeRenderer.inputs.localPosition.z = 0.05;\n    // planeRenderer.inputs.localPosition.y = 0.4;\n    // planeRenderer.inputs.localScale = {x: 0.5, y: 0.5, z: 0.5};\n\n    this.outputs.painter = this;\n\n    this.mixer = new AnimationMixer(this.planeRenderer.outputs.objectRoot);\n\n    const tm = 0.2;\n    const positionTrack = new VectorKeyframeTrack('.scale', [0, tm], [\n      0, 0, 0,\n      0.5, 0.5, 0.5\n    ], InterpolateSmooth);\n    this.onEnterClip = new AnimationClip(null, tm, [positionTrack]);\n  }\n\n  override onInputsUpdated() {\n    if (this.inputs.loadingState === 'Loaded') {\n      const lines: LineSegments[] = [];\n\n      //@ts-ignore\n      this.context.root.obj3D.traverse((obj: Object3D) => {\n        // we dont want line segments, track them and remove them.\n        if (obj.type === 'LineSegments') {\n          lines.push(obj as LineSegments);\n        } else if (obj.type === 'Mesh') {\n          this.mesh = obj as Mesh;\n\n          const materials = this.mesh.material as MeshLambertMaterial;\n          materials.forEach((m, idx) => {\n            if (m && m.map.source.data.outerHTML.indexOf('_5b76dbe388862300126c1e14') !== -1) {\n              const newMaterial = new MeshBasicMaterial({map: this.inputs.texture});\n              this.mesh.material[idx] = newMaterial;\n            }\n          })\n\n        }\n      });\n\n      // remove the line segments.\n      lines.forEach((line: LineSegments) => {\n        line.parent.remove(line);\n      });\n    }\n  }\n\n  override onEvent(eventType: string, eventData: unknown): void {\n    if (eventType === HoverEvent) {\n      const data: any = eventData;\n      if (data.hover) {\n        this.outputs.visible = true;\n        const onEnterAction: AnimationAction = this.mixer.clipAction(this.onEnterClip);\n        onEnterAction.stop();\n        onEnterAction.loop = LoopOnce;\n        onEnterAction.clampWhenFinished = true;\n        onEnterAction.play();\n      } else {\n        this.outputs.visible = false;\n      }\n    }\n  }\n\n  paint(context2d: CanvasRenderingContext2D, size: Size): void {\n    const x = 490;\n    const y = 490;\n\n    context2d.fillStyle = 'black';\n    context2d.beginPath();\n    context2d.arc(x, y, 400, 0, Math.PI * 2);\n    context2d.fill();\n\n    context2d.fillStyle = '#CF5300';\n    context2d.beginPath();\n    context2d.arc(x, y, 300, 0, Math.PI * 2);\n    context2d.fill();\n\n    context2d.beginPath();\n    context2d.strokeStyle = 'orange';\n    context2d.arc(x, y, 240, 0.75 * Math.PI, 0.25 * Math.PI);\n    context2d.lineCap = 'butt';\n    context2d.lineWidth = 80;\n    context2d.stroke();\n\n    context2d.fillStyle = 'white';\n    context2d.font = '220px Arial';\n    context2d.fillText(`${this.temperature}`, x - 115, y + 75);\n    this.outputs.visible = true;\n  }\n\n  override onTick(delta: number) {\n    this.currentTime += delta;\n\n    if (this.mixer) {\n      this.mixer.update(delta / 1000);\n    }\n\n    if (this.currentTime > this.nextUpdate) {\n      this.nextUpdate += this.inputs.updateInterval;\n\n      this.temperature += (Math.random() * this.tempChangeRange);\n      this.temperature = Math.trunc(this.temperature);\n\n      if (this.temperature > 99) {\n        this.temperature = 99;\n        this.tempChangeRange = -this.tempChangeRange;\n      }\n      if (this.temperature < 10) {\n        this.temperature = 10;\n        this.tempChangeRange = -this.tempChangeRange;\n      }\n\n      this.component.notify(RepaintEvent);\n      this.cv.repaint()\n    }\n  }\n\n  setComponent(component: SceneComponent, plane: PlaneRenderer, cv: CanvasRenderer) {\n    component.onTick = this.onTick.bind(this);\n    // plane.onTick = this.onTick.bind(this);\n    this.cv = cv;\n    this.component = component;\n    this.context = component.context;\n  }\n\n  setRootScene(rootScene: Object3D) {\n    this.rootScene = rootScene;\n  }\n}\n\nexport const nestThermostatType = 'mp.nestThermostat';\nexport const makeNestThermostat = function () {\n  return new NestThermostat();\n}\n"]}

package/esm2020/lib/matterport-extensions/nest-thermostat/PlaneRenderer.mjs

@@ -0,0 +1,85 @@
+import { SceneComponent, ComponentInteractionType, } from '../scene-component/SceneComponent';
+import { Mesh, MeshBasicMaterial, Group, PlaneBufferGeometry } from 'three';
+export class PlaneRenderer extends SceneComponent {
+    constructor() {
+        super(...arguments);
+        this.rootScene = null;
+        this.inputs = {
+            texture: null,
+            aspect: 1,
+            transparent: true,
+            visible: true,
+            opacity: 1,
+            polygonOffset: false,
+            polygonOffsetFactor: 0,
+            polygonOffsetUnits: 0,
+            localScale: { x: 1, y: 1, z: 1 },
+            localPosition: { x: 0, y: 0, z: 0 },
+        };
+        this.events = {
+            [ComponentInteractionType.CLICK]: true,
+        };
+    }
+    onInit(modelNode, inputTexture) {
+        this.inputs.texture = inputTexture;
+        if (!this.context) {
+            this.context = {
+                root: modelNode
+            };
+        }
+        this.pivotNode = new Group();
+        this.mesh = new Mesh(new PlaneBufferGeometry(1.0, 1.0), new MeshBasicMaterial({
+            transparent: this.inputs.transparent,
+            map: this.inputs.texture,
+            opacity: this.inputs.opacity,
+            polygonOffset: this.inputs.polygonOffset,
+            polygonOffsetFactor: this.inputs.polygonOffsetFactor,
+            polygonOffsetUnits: this.inputs.polygonOffsetUnits,
+        }));
+        this.mesh.scale.set(this.inputs.localScale.x, this.inputs.localScale.y / this.inputs.aspect, this.inputs.localScale.z);
+        this.mesh.position.set(this.inputs.localPosition.x, this.inputs.localPosition.y, this.inputs.localPosition.z);
+        this.mesh.updateMatrixWorld();
+        this.pivotNode.add(this.mesh);
+        this.outputs.objectRoot = this.pivotNode;
+        this.outputs.collider = this.pivotNode;
+        this.mesh.visible = this.inputs.visible;
+    }
+    onEvent(eventType, eventData) {
+        this.notify(eventType, eventData);
+    }
+    onInputsUpdated(oldInputs) {
+        if (oldInputs.transparent !== this.inputs.transparent) {
+            this.mesh.material.transparent = this.inputs.transparent;
+        }
+        if (oldInputs.texture !== this.inputs.texture) {
+            const material = this.mesh.material;
+            material.map = this.inputs.texture;
+            material.needsUpdate = true;
+        }
+        if (oldInputs.visible !== this.inputs.visible) {
+            this.mesh.visible = this.inputs.visible;
+        }
+        if (oldInputs.polygonOffset !== this.inputs.polygonOffset) {
+            const material = this.mesh.material;
+            material.polygonOffset = this.inputs.polygonOffset;
+            material.polygonOffsetFactor = this.inputs.polygonOffsetFactor;
+            material.polygonOffsetUnits = this.inputs.polygonOffsetUnits;
+        }
+        this.mesh.scale.set(this.inputs.localScale.x, this.inputs.localScale.y / this.inputs.aspect, this.inputs.localScale.z);
+        this.mesh.position.set(this.inputs.localPosition.x, this.inputs.localPosition.y, this.inputs.localPosition.z);
+    }
+    onDestroy() {
+        this.outputs.collider = null;
+        this.outputs.objectRoot = null;
+        this.mesh.material.dispose();
+        this.mesh.geometry.dispose();
+    }
+    setRootScene(rootScene) {
+        this.rootScene = rootScene;
+    }
+}
+export const planeRendererType = 'mp.planeRenderer';
+export function makePlaneRenderer() {
+    return new PlaneRenderer();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PlaneRenderer.js","sourceRoot":"","sources":["../../../../../../projects/ngx-smarterplan-core/src/lib/matterport-extensions/nest-thermostat/PlaneRenderer.ts"],"names":[],"mappings":"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","sourcesContent":["import {SceneComponent, ComponentInteractionType, ComponentContext,} from '../scene-component/SceneComponent';\nimport {\n  Texture,\n  Mesh,\n  MeshBasicMaterial,\n  Object3D,\n  Group,\n  PlaneBufferGeometry\n} from 'three';\n\nexport type Size = { w: number; h: number; };\n\ntype Inputs = {\n  texture: Texture | null;\n  aspect: number;\n  transparent: boolean;\n  visible: boolean;\n  opacity: number;\n  polygonOffset: boolean;\n  polygonOffsetFactor: number;\n  polygonOffsetUnits: number;\n  localScale: { x: number; y: number; z: number; };\n  localPosition: { x: number; y: number; z: number; };\n}\n\nexport class PlaneRenderer extends SceneComponent implements IPlaneRenderer {\n  private rootScene: Object3D | null = null;\n  private mesh: Mesh;\n  private pivotNode: Object3D;\n\n  override inputs: Inputs = {\n    texture: null,\n    aspect: 1,\n    transparent: true,\n    visible: true,\n    opacity: 1,\n    polygonOffset: false,\n    polygonOffsetFactor: 0,\n    polygonOffsetUnits: 0,\n    localScale: {x: 1, y: 1, z: 1},\n    localPosition: {x: 0, y: 0, z: 0},\n  }\n\n  override events = {\n    [ComponentInteractionType.CLICK]: true,\n  };\n\n  override onInit(modelNode?: any, inputTexture?: any) {\n    this.inputs.texture = inputTexture;\n    if (!this.context) {\n      this.context = {\n        root: modelNode\n      } as ComponentContext;\n    }\n\n    this.pivotNode = new Group();\n\n    this.mesh = new Mesh(\n      new PlaneBufferGeometry(1.0, 1.0),\n      new MeshBasicMaterial({\n        transparent: this.inputs.transparent,\n        map: this.inputs.texture,\n        opacity: this.inputs.opacity,\n        polygonOffset: this.inputs.polygonOffset,\n        polygonOffsetFactor: this.inputs.polygonOffsetFactor,\n        polygonOffsetUnits: this.inputs.polygonOffsetUnits,\n      }));\n    this.mesh.scale.set(this.inputs.localScale.x, this.inputs.localScale.y / this.inputs.aspect, this.inputs.localScale.z);\n    this.mesh.position.set(this.inputs.localPosition.x, this.inputs.localPosition.y, this.inputs.localPosition.z);\n    this.mesh.updateMatrixWorld();\n    this.pivotNode.add(this.mesh);\n\n    this.outputs.objectRoot = this.pivotNode;\n    this.outputs.collider = this.pivotNode;\n    this.mesh.visible = this.inputs.visible;\n  }\n\n  override onEvent(eventType: string, eventData: unknown) {\n    this.notify(eventType, eventData);\n  }\n\n  override onInputsUpdated(oldInputs: Inputs) {\n    if (oldInputs.transparent !== this.inputs.transparent) {\n      (this.mesh.material as MeshBasicMaterial).transparent = this.inputs.transparent;\n    }\n\n    if (oldInputs.texture !== this.inputs.texture) {\n      const material = this.mesh.material as MeshBasicMaterial;\n      material.map = this.inputs.texture;\n      material.needsUpdate = true;\n    }\n\n    if (oldInputs.visible !== this.inputs.visible) {\n      this.mesh.visible = this.inputs.visible;\n    }\n\n    if (oldInputs.polygonOffset !== this.inputs.polygonOffset) {\n      const material = this.mesh.material as MeshBasicMaterial;\n      material.polygonOffset = this.inputs.polygonOffset;\n      material.polygonOffsetFactor = this.inputs.polygonOffsetFactor;\n      material.polygonOffsetUnits = this.inputs.polygonOffsetUnits;\n    }\n\n    this.mesh.scale.set(this.inputs.localScale.x, this.inputs.localScale.y / this.inputs.aspect, this.inputs.localScale.z);\n    this.mesh.position.set(this.inputs.localPosition.x, this.inputs.localPosition.y, this.inputs.localPosition.z);\n  }\n\n  override onDestroy() {\n    this.outputs.collider = null;\n    this.outputs.objectRoot = null;\n\n    (this.mesh.material as MeshBasicMaterial).dispose();\n    this.mesh.geometry.dispose();\n  }\n\n  setRootScene(rootScene: Object3D) {\n    this.rootScene = rootScene;\n  }\n\n}\n\nexport interface IPlaneRenderer extends SceneComponent {\n  inputs: Inputs;\n}\n\nexport const planeRendererType = 'mp.planeRenderer';\n\nexport function makePlaneRenderer() {\n  return new PlaneRenderer();\n}\n"]}

package/esm2020/lib/matterport-extensions/scene-component/SceneComponent.mjs

@@ -125,4 +125,4 @@ export var Keys;
     Keys[Keys["ALT"] = 18] = "ALT";
     Keys[Keys["CONTROL"] = 17] = "CONTROL";
 })(Keys || (Keys = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SceneComponent.js","sourceRoot":"","sources":["../../../../../../projects/ngx-smarterplan-core/src/lib/matterport-extensions/scene-component/SceneComponent.ts"],"names":[],"mappings":"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","sourcesContent":["import THREE, { Scene } from 'three';\r\nimport Dict = NodeJS.Dict;\r\n\r\n/**\r\n * The base of all `SceneComponent` created with the sdk.\r\n * All properties of this class are always available to all components generated through the sdk.\r\n * These properties should all be considered reserved and should not be overwritten by the subclass.\r\n */\r\nabstract class SceneComponentPrivate {\r\n  /**\r\n   * @reserved\r\n   * The name registered to the factory used to generate this component.\r\n   */\r\n  declare readonly componentType: string;\r\n\r\n  /**\r\n   * @reserved\r\n   * A dictionary of properties that this component computes. Every component is guaranteed to have `outputs.collider` and `outputs.objectRoot`.\r\n   * This dictionary is observable and can be the source of a bind target.\r\n   *\r\n   */\r\n  declare outputs: ComponentOutput;\r\n\r\n  /**\r\n   * @reserved\r\n   * A dictionary of events that will be handled by this component's `onEvent`. Every component is guaranteed to have all of the `InteractionSelection` keys:\r\n   *  `events[InteractionSelection.CLICK]`, `events[InteractionSelection.HOVER]`, `events[InteractionSelection.DRAG]`\r\n   * Note: registering to receive `InteractionSelection.HOVER` will produce both `InteractionType.HOVER` and `InteractionType.UNHOVER` in `onEvent`.\r\n   */\r\n  declare events: Dict<boolean>;\r\n\r\n  /**\r\n   * @reserved\r\n   * The context provides access to the underlying framework, e.g. THREE.js.\r\n   */\r\n  declare context: ComponentContext;\r\n\r\n  /**\r\n   * @reserved\r\n   * Binds `this[prop]` to the output of `src[srcProp]`.\r\n   * When the value of `src[srcProp]` changes, the value is propagated and sets `this[prop]` to the same value automatically.\r\n   */\r\n  declare bind: (prop: string, src: SceneComponent['outputs' | 'inputs'], srcProp: keyof SceneComponent['outputs' | 'inputs']) => void;\r\n\r\n  /**\r\n   * @reserved\r\n   * Notifies this component of an `eventType` when the `src` Component calls `notify` with a `srcEventType` event\r\n   */\r\n  declare bindEvent: (eventType: string, src: SceneComponent, srcEventType: string) => void;\r\n\r\n  /**\r\n   * @reserved\r\n   * Notifies any event bindings of an event with `eventType` and data `eventData`\r\n   */\r\n  declare notify: (eventType: string, eventData?: unknown) => void;\r\n\r\n  /**\r\n   * @reserved\r\n   * Spy on a component's notify from outside of the component system\r\n   */\r\n  declare spyOnEvent: (spy: IComponentEventSpy) => ISubscription;\r\n}\r\n\r\nexport abstract class SceneComponent extends SceneComponentPrivate {\r\n  /**\r\n   * An optional dictionary of properties that affects the behavior of the component.\r\n   * The properties can be changed by an external source at any time. It is up to the component to respond appropriately to the changes.\r\n   * The input properties can also be bind targets to another observable source, e.g. the output property of another component.\r\n   */\r\n  inputs?: Dict<any>;\r\n\r\n  /**\r\n   * This event is called once after the scene node its attached to has started.\r\n   */\r\n  onInit?(): void;\r\n\r\n  /**\r\n   * This event is called at most once per frame when there are events on this component.\r\n   * Any of the interaction types specified in `this.interactions` or a call to notify for a bound event will trigger this event.\r\n   * @property {string | ComponentInteractionType} eventType The event type\r\n   * @property {unknown} eventData The data payload of the event\r\n   */\r\n  onEvent?(eventType: string, eventData: unknown): void;\r\n\r\n  /**\r\n   * This event is called after an input property has changed.\r\n   * It will be called at most once a frame.\r\n   */\r\n  onInputsUpdated?(previousInputs: this['inputs']): void;\r\n\r\n  /**\r\n   * This event is called once a frame after input changes have been detected.\r\n   */\r\n  onTick?(tickDelta: number): void;\r\n\r\n  /**\r\n   * @reserved\r\n   * A dictionary of events that will be handled by this component's `onEvent`. Every component is guaranteed to have all of the `InteractionSelection` keys:\r\n   *  `events[InteractionSelection.CLICK]`, `events[InteractionSelection.HOVER]`, `events[InteractionSelection.DRAG]`\r\n   * Note: registering to receive `InteractionSelection.HOVER` will produce both `InteractionType.HOVER` and `InteractionType.UNHOVER` in `onEvent`.\r\n   */\r\n  override events: Record<string, boolean>;\r\n\r\n  /**\r\n   * @reserved\r\n   * A dictionary of events that will be emitted by this component.\r\n   */\r\n  emits?: Record<string, boolean>;\r\n\r\n  /**\r\n   * This event is called once right before the scene node has stopped.\r\n   */\r\n  onDestroy?(): void;\r\n}\r\n\r\n/**\r\n * A node of a scene graph.\r\n * Aggregates `SceneComponent` as children.\r\n */\r\nexport interface ISceneNode {\r\n  /**\r\n   * A human readable name provided by the user.\r\n   */\r\n  name: string;\r\n\r\n  /**\r\n   * The position of the node.\r\n   * The position, quaternion, scale transforms are applied in scale, quaternion, then scale order. (same as THREE.js)\r\n   */\r\n  readonly position: THREE.Vector3;\r\n\r\n  /**\r\n   * The orientation of the node.\r\n   * The position, quaternion, scale transforms are applied in scale, quaternion, then scale order. (same as THREE.js)\r\n   */\r\n  readonly quaternion: THREE.Quaternion;\r\n\r\n  /**\r\n   * The scale of the node.\r\n   * The position, quaternion, scale transforms are applied in scale, quaternion, then scale order. (same as THREE.js)\r\n   */\r\n  readonly scale: THREE.Vector3;\r\n\r\n  /**\r\n   * Create and add a child component to this node.\r\n   *\r\n   * @param factory The name associated with the factory to generate a `SceneComponent`\r\n   * @param initialInputs An initial set of inputs, immediately available to the newly create `SceneComponent.onInit`\r\n   */\r\n  addComponent(factory: string, initialInputs?: SceneComponent['inputs']): SceneComponent;\r\n\r\n  /**\r\n   * An iterator to iterate over the components added to this node using a for-of loop.\r\n   */\r\n  componentIterator(): IterableIterator<SceneComponent>;\r\n\r\n  /**\r\n   * Start the node and its components.\r\n   */\r\n  start(): void;\r\n\r\n  /**\r\n   * Stop the node and its components.\r\n   */\r\n  stop(): void;\r\n}\r\n\r\n/**\r\n * The types of the Interaction events received from the registered `InteractionSelection`\r\n */\r\nexport enum ComponentInteractionType {\r\n  /** CLICK events */\r\n  CLICK = 'INTERACTION.CLICK',\r\n  /** HOVER events */\r\n  HOVER = 'INTERACTION.HOVER',\r\n  /** DRAG events (mousedown then move) */\r\n  DRAG = 'INTERACTION.DRAG',\r\n  DRAG_BEGIN = 'INTERACTION.DRAG_BEGIN',\r\n  DRAG_END = 'INTERACTION.DRAG_END',\r\n  POINTER_MOVE = 'INTERACTION.POINTER_MOVE',\r\n  POINTER_BUTTON = 'INTERACTION.POINTER_BUTTON',\r\n  SCROLL = 'INTERACTION.SCROLL',\r\n  KEY = 'INTERACTION.KEY',\r\n  LONG_PRESS_START = 'INTERACTION.LONG_PRESS_START',\r\n  LONG_PRESS_END = 'INTERACTION.LONG_PRESS_END',\r\n  MULTI_SWIPE = 'INTERACTION.MULTI_SWIPE',\r\n  MULTI_SWIPE_END = 'INTERACTION.MULTI_SWIPE_END',\r\n  PINCH = 'INTERACTION.PINCH',\r\n  PINCH_END = 'INTERACTION.PINCH_END',\r\n  ROTATE = 'INTERACTION.ROTATE',\r\n  ROTATE_END = 'INTERACTION.ROTATE_END',\r\n}\r\n\r\nabstract class ComponentOutputReserved {\r\n  declare objectRoot: THREE.Object3D | null;\r\n  declare collider: THREE.Object3D | null;\r\n}\r\n\r\n// Hack around the type system to get a cleaner interface around `ComponentOutput`\r\ninterface ComponentOut extends Dict<any> {}\r\nclass ComponentOut extends ComponentOutputReserved  {}\r\n\r\n/**\r\n * A general-use bag of properties.\r\n * At a minimum, it has `objectRoot` and `collider` automatically defined.\r\n */\r\nexport type ComponentOutput = ComponentOut;\r\n\r\n/**\r\n * The context of a component (available as `this.context`) in a `SceneComponent` subclass.\r\n * Access to the root `ISceneNode` and the THREE.js are available.\r\n */\r\nexport type ComponentContext = {\r\n  three: typeof THREE;\r\n  root: ISceneNode;\r\n  renderer: THREE.WebGLRenderer;\r\n  user: Dict<any>;\r\n  scene: Scene;\r\n};\r\n\r\n/**\r\n * A raycast intersection with a mesh\r\n */\r\nexport type Intersect = {\r\n  point: THREE.Vector3;\r\n  normal: THREE.Vector3;\r\n  collider: THREE.Object3D;\r\n};\r\n\r\n/**\r\n * A spy that can be attached to a component using `spyOnEvent`\r\n */\r\nexport interface IComponentEventSpy<T = unknown> {\r\n  readonly eventType: string;\r\n  onEvent(eventData?: T): void;\r\n}\r\n\r\n/**\r\n * An object responsible for removing a spy from a component's event\r\n */\r\nexport interface ISubscription {\r\n  cancel(): void;\r\n}\r\n\r\nexport interface IVector2 {\r\n  x: number;\r\n  y: number;\r\n}\r\n\r\nexport interface IVector3 {\r\n  x: number;\r\n  y: number;\r\n  z: number;\r\n}\r\n\r\nexport enum PointerButton {\r\n  PRIMARY,\r\n  MIDDLE,\r\n  SECONDARY,\r\n  BACK,\r\n  FORWARD,\r\n  COUNT,\r\n}\r\n\r\nexport enum PointerButtonMask {\r\n  NONE,\r\n  PRIMARY = 1 << PointerButton.PRIMARY,\r\n  SECONDARY = 1 << PointerButton.SECONDARY,\r\n  MIDDLE = 1 << PointerButton.MIDDLE,\r\n  BACK = 1 << PointerButton.BACK,\r\n  FORWARD = 1 << PointerButton.FORWARD,\r\n  ALL = (1 << PointerButton.COUNT) - 1,\r\n}\r\n\r\nexport enum PointerDevice {\r\n  MOUSE = 'mouse',\r\n  TOUCH = 'touch',\r\n  PEN = 'pen',\r\n  GAMEPAD = 'gamepad',\r\n}\r\n\r\n/**\r\n * Fired on every mouse down, provides current position/buttons down.\r\n */\r\nexport interface DragBeginEvent {\r\n  /** Current position */\r\n  readonly position: IVector2;\r\n  /** Buttons down during event */\r\n  readonly buttons: PointerButtonMask;\r\n}\r\n\r\n/**\r\n * Fired only after the pointer has moved far enough from DragBeginEvent\r\n */\r\nexport interface DragEvent {\r\n  /** Current position */\r\n  readonly position: IVector2;\r\n  /** Delta moved since last drag event */\r\n  readonly delta: IVector2;\r\n  /** Buttons down during event */\r\n  readonly buttons: PointerButtonMask;\r\n}\r\n\r\n/**\r\n * Fired on every mouse up, includes information about the difference between the DragBegin and current positions\r\n */\r\nexport interface DragEndEvent extends DragEvent {\r\n  /** duration since last DragEvent */\r\n  readonly timeSinceLastMove: number;\r\n\r\n  /** The delta between position, and the position from DragBeginEvent */\r\n  readonly fullDelta: IVector2;\r\n}\r\n\r\nexport interface PointerMoveEvent {\r\n  readonly id: number;\r\n  readonly position: IVector2;\r\n  readonly buttons: PointerButtonMask;\r\n  readonly device: PointerDevice;\r\n}\r\n\r\nexport interface PointerButtonEvent {\r\n  readonly id: number;\r\n  readonly position: IVector2;\r\n  readonly button: PointerButton;\r\n  readonly down: boolean;\r\n  readonly device: PointerDevice;\r\n}\r\n\r\nexport interface ScrollEvent {\r\n  readonly position: IVector2;\r\n  readonly delta: IVector2;\r\n}\r\n\r\nexport enum KeyState {\r\n  DOWN,\r\n  PRESSED,\r\n  UP,\r\n}\r\n\r\nexport enum Keys{\r\n  ESCAPE = 27,\r\n  ZERO = 48,\r\n  ONE = 49,\r\n  TWO = 50,\r\n  THREE = 51,\r\n  FOUR = 52,\r\n  FIVE = 53,\r\n  SIX = 54,\r\n  SEVEN = 55,\r\n  EIGHT = 56,\r\n  NINE = 57,\r\n  LEFTARROW = 37,\r\n  UPARROW = 38,\r\n  RIGHTARROW = 39,\r\n  DOWNARROW = 40,\r\n  TAB = 9,\r\n  A = 65,\r\n  B = 66,\r\n  C = 67,\r\n  D = 68,\r\n  E = 69,\r\n  F = 70,\r\n  G = 71,\r\n  H = 72,\r\n  I = 73,\r\n  J = 74,\r\n  K = 75,\r\n  L = 76,\r\n  M = 77,\r\n  N = 78,\r\n  O = 79,\r\n  P = 80,\r\n  Q = 81,\r\n  R = 82,\r\n  S = 83,\r\n  T = 84,\r\n  U = 85,\r\n  V = 86,\r\n  W = 87,\r\n  X = 88,\r\n  Y = 89,\r\n  Z = 90,\r\n  SPACE = 32,\r\n  RETURN = 13,\r\n  DELETE = 46,\r\n  BACKSPACE = 8,\r\n  SEMICOLON = 186,\r\n  PLUSEQUALS = 187,\r\n  DASHUNDERSCORE = 189,\r\n  OPENBRACKET = 219,\r\n  SHIFT = 16,\r\n  ALT = 18,\r\n  CONTROL = 17,\r\n}\r\n\r\nexport interface KeyEvent {\r\n  key: Keys;\r\n  state: KeyState;\r\n  modifiers: {\r\n    altKey: boolean,\r\n    shiftKey: boolean,\r\n    ctrlKey: boolean\r\n  };\r\n}\r\n\r\nexport interface LongPressStartEvent {\r\n  readonly position: IVector2;\r\n  readonly buttons: PointerButtonMask;\r\n  readonly threshold: number;\r\n}\r\n\r\nexport interface LongPressEndEvent {}\r\n\r\nexport interface MultiSwipeEvent {\r\n  readonly pointerCount: number;\r\n  readonly position: IVector2;\r\n  readonly delta: IVector2;\r\n}\r\n\r\nexport interface MultiSwipeEndEvent extends MultiSwipeEvent {\r\n  readonly timeSinceLastMove: number;\r\n}\r\n\r\nexport interface PinchEvent {\r\n  readonly pinchDelta: number;\r\n}\r\n\r\nexport interface PinchEndEvent extends PinchEvent {\r\n  readonly timeSinceLastMove: number;\r\n}\r\n\r\nexport interface RotateEvent {\r\n  readonly rotateDelta: number;\r\n}\r\n\r\nexport interface RotateEndEvent extends RotateEvent {\r\n  readonly timeSinceLastMove: number;\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SceneComponent.js","sourceRoot":"","sources":["../../../../../../projects/ngx-smarterplan-core/src/lib/matterport-extensions/scene-component/SceneComponent.ts"],"names":[],"mappings":"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","sourcesContent":["import THREE, { Scene } from 'three';\nimport Dict = NodeJS.Dict;\n\n/**\n * The base of all `SceneComponent` created with the sdk.\n * All properties of this class are always available to all components generated through the sdk.\n * These properties should all be considered reserved and should not be overwritten by the subclass.\n */\nabstract class SceneComponentPrivate {\n  /**\n   * @reserved\n   * The name registered to the factory used to generate this component.\n   */\n  declare readonly componentType: string;\n\n  /**\n   * @reserved\n   * A dictionary of properties that this component computes. Every component is guaranteed to have `outputs.collider` and `outputs.objectRoot`.\n   * This dictionary is observable and can be the source of a bind target.\n   *\n   */\n  declare outputs: ComponentOutput;\n\n  /**\n   * @reserved\n   * A dictionary of events that will be handled by this component's `onEvent`. Every component is guaranteed to have all of the `InteractionSelection` keys:\n   *  `events[InteractionSelection.CLICK]`, `events[InteractionSelection.HOVER]`, `events[InteractionSelection.DRAG]`\n   * Note: registering to receive `InteractionSelection.HOVER` will produce both `InteractionType.HOVER` and `InteractionType.UNHOVER` in `onEvent`.\n   */\n  declare events: Dict<boolean>;\n\n  /**\n   * @reserved\n   * The context provides access to the underlying framework, e.g. THREE.js.\n   */\n  declare context: ComponentContext;\n\n  /**\n   * @reserved\n   * Binds `this[prop]` to the output of `src[srcProp]`.\n   * When the value of `src[srcProp]` changes, the value is propagated and sets `this[prop]` to the same value automatically.\n   */\n  declare bind: (prop: string, src: SceneComponent['outputs' | 'inputs'], srcProp: keyof SceneComponent['outputs' | 'inputs']) => void;\n\n  /**\n   * @reserved\n   * Notifies this component of an `eventType` when the `src` Component calls `notify` with a `srcEventType` event\n   */\n  declare bindEvent: (eventType: string, src: SceneComponent, srcEventType: string) => void;\n\n  /**\n   * @reserved\n   * Notifies any event bindings of an event with `eventType` and data `eventData`\n   */\n  declare notify: (eventType: string, eventData?: unknown) => void;\n\n  /**\n   * @reserved\n   * Spy on a component's notify from outside of the component system\n   */\n  declare spyOnEvent: (spy: IComponentEventSpy) => ISubscription;\n}\n\nexport abstract class SceneComponent extends SceneComponentPrivate {\n  /**\n   * An optional dictionary of properties that affects the behavior of the component.\n   * The properties can be changed by an external source at any time. It is up to the component to respond appropriately to the changes.\n   * The input properties can also be bind targets to another observable source, e.g. the output property of another component.\n   */\n  inputs?: Dict<any>;\n\n  /**\n   * This event is called once after the scene node its attached to has started.\n   */\n  onInit?(): void;\n\n  /**\n   * This event is called at most once per frame when there are events on this component.\n   * Any of the interaction types specified in `this.interactions` or a call to notify for a bound event will trigger this event.\n   * @property {string | ComponentInteractionType} eventType The event type\n   * @property {unknown} eventData The data payload of the event\n   */\n  onEvent?(eventType: string, eventData: unknown): void;\n\n  /**\n   * This event is called after an input property has changed.\n   * It will be called at most once a frame.\n   */\n  onInputsUpdated?(previousInputs: this['inputs']): void;\n\n  /**\n   * This event is called once a frame after input changes have been detected.\n   */\n  onTick?(tickDelta: number): void;\n\n  /**\n   * @reserved\n   * A dictionary of events that will be handled by this component's `onEvent`. Every component is guaranteed to have all of the `InteractionSelection` keys:\n   *  `events[InteractionSelection.CLICK]`, `events[InteractionSelection.HOVER]`, `events[InteractionSelection.DRAG]`\n   * Note: registering to receive `InteractionSelection.HOVER` will produce both `InteractionType.HOVER` and `InteractionType.UNHOVER` in `onEvent`.\n   */\n  override events: Record<string, boolean>;\n\n  /**\n   * @reserved\n   * A dictionary of events that will be emitted by this component.\n   */\n  emits?: Record<string, boolean>;\n\n  /**\n   * This event is called once right before the scene node has stopped.\n   */\n  onDestroy?(): void;\n}\n\n/**\n * A node of a scene graph.\n * Aggregates `SceneComponent` as children.\n */\nexport interface ISceneNode {\n  /**\n   * A human readable name provided by the user.\n   */\n  name: string;\n\n  /**\n   * The position of the node.\n   * The position, quaternion, scale transforms are applied in scale, quaternion, then scale order. (same as THREE.js)\n   */\n  readonly position: THREE.Vector3;\n\n  /**\n   * The orientation of the node.\n   * The position, quaternion, scale transforms are applied in scale, quaternion, then scale order. (same as THREE.js)\n   */\n  readonly quaternion: THREE.Quaternion;\n\n  /**\n   * The scale of the node.\n   * The position, quaternion, scale transforms are applied in scale, quaternion, then scale order. (same as THREE.js)\n   */\n  readonly scale: THREE.Vector3;\n\n  /**\n   * Create and add a child component to this node.\n   *\n   * @param factory The name associated with the factory to generate a `SceneComponent`\n   * @param initialInputs An initial set of inputs, immediately available to the newly create `SceneComponent.onInit`\n   */\n  addComponent(factory: string, initialInputs?: SceneComponent['inputs']): SceneComponent;\n\n  /**\n   * An iterator to iterate over the components added to this node using a for-of loop.\n   */\n  componentIterator(): IterableIterator<SceneComponent>;\n\n  /**\n   * Start the node and its components.\n   */\n  start(): void;\n\n  /**\n   * Stop the node and its components.\n   */\n  stop(): void;\n}\n\n/**\n * The types of the Interaction events received from the registered `InteractionSelection`\n */\nexport enum ComponentInteractionType {\n  /** CLICK events */\n  CLICK = 'INTERACTION.CLICK',\n  /** HOVER events */\n  HOVER = 'INTERACTION.HOVER',\n  /** DRAG events (mousedown then move) */\n  DRAG = 'INTERACTION.DRAG',\n  DRAG_BEGIN = 'INTERACTION.DRAG_BEGIN',\n  DRAG_END = 'INTERACTION.DRAG_END',\n  POINTER_MOVE = 'INTERACTION.POINTER_MOVE',\n  POINTER_BUTTON = 'INTERACTION.POINTER_BUTTON',\n  SCROLL = 'INTERACTION.SCROLL',\n  KEY = 'INTERACTION.KEY',\n  LONG_PRESS_START = 'INTERACTION.LONG_PRESS_START',\n  LONG_PRESS_END = 'INTERACTION.LONG_PRESS_END',\n  MULTI_SWIPE = 'INTERACTION.MULTI_SWIPE',\n  MULTI_SWIPE_END = 'INTERACTION.MULTI_SWIPE_END',\n  PINCH = 'INTERACTION.PINCH',\n  PINCH_END = 'INTERACTION.PINCH_END',\n  ROTATE = 'INTERACTION.ROTATE',\n  ROTATE_END = 'INTERACTION.ROTATE_END',\n}\n\nabstract class ComponentOutputReserved {\n  declare objectRoot: THREE.Object3D | null;\n  declare collider: THREE.Object3D | null;\n}\n\n// Hack around the type system to get a cleaner interface around `ComponentOutput`\ninterface ComponentOut extends Dict<any> {}\nclass ComponentOut extends ComponentOutputReserved  {}\n\n/**\n * A general-use bag of properties.\n * At a minimum, it has `objectRoot` and `collider` automatically defined.\n */\nexport type ComponentOutput = ComponentOut;\n\n/**\n * The context of a component (available as `this.context`) in a `SceneComponent` subclass.\n * Access to the root `ISceneNode` and the THREE.js are available.\n */\nexport type ComponentContext = {\n  three: typeof THREE;\n  root: ISceneNode;\n  renderer: THREE.WebGLRenderer;\n  user: Dict<any>;\n  scene: Scene;\n};\n\n/**\n * A raycast intersection with a mesh\n */\nexport type Intersect = {\n  point: THREE.Vector3;\n  normal: THREE.Vector3;\n  collider: THREE.Object3D;\n};\n\n/**\n * A spy that can be attached to a component using `spyOnEvent`\n */\nexport interface IComponentEventSpy<T = unknown> {\n  readonly eventType: string;\n  onEvent(eventData?: T): void;\n}\n\n/**\n * An object responsible for removing a spy from a component's event\n */\nexport interface ISubscription {\n  cancel(): void;\n}\n\nexport interface IVector2 {\n  x: number;\n  y: number;\n}\n\nexport interface IVector3 {\n  x: number;\n  y: number;\n  z: number;\n}\n\nexport enum PointerButton {\n  PRIMARY,\n  MIDDLE,\n  SECONDARY,\n  BACK,\n  FORWARD,\n  COUNT,\n}\n\nexport enum PointerButtonMask {\n  NONE,\n  PRIMARY = 1 << PointerButton.PRIMARY,\n  SECONDARY = 1 << PointerButton.SECONDARY,\n  MIDDLE = 1 << PointerButton.MIDDLE,\n  BACK = 1 << PointerButton.BACK,\n  FORWARD = 1 << PointerButton.FORWARD,\n  ALL = (1 << PointerButton.COUNT) - 1,\n}\n\nexport enum PointerDevice {\n  MOUSE = 'mouse',\n  TOUCH = 'touch',\n  PEN = 'pen',\n  GAMEPAD = 'gamepad',\n}\n\n/**\n * Fired on every mouse down, provides current position/buttons down.\n */\nexport interface DragBeginEvent {\n  /** Current position */\n  readonly position: IVector2;\n  /** Buttons down during event */\n  readonly buttons: PointerButtonMask;\n}\n\n/**\n * Fired only after the pointer has moved far enough from DragBeginEvent\n */\nexport interface DragEvent {\n  /** Current position */\n  readonly position: IVector2;\n  /** Delta moved since last drag event */\n  readonly delta: IVector2;\n  /** Buttons down during event */\n  readonly buttons: PointerButtonMask;\n}\n\n/**\n * Fired on every mouse up, includes information about the difference between the DragBegin and current positions\n */\nexport interface DragEndEvent extends DragEvent {\n  /** duration since last DragEvent */\n  readonly timeSinceLastMove: number;\n\n  /** The delta between position, and the position from DragBeginEvent */\n  readonly fullDelta: IVector2;\n}\n\nexport interface PointerMoveEvent {\n  readonly id: number;\n  readonly position: IVector2;\n  readonly buttons: PointerButtonMask;\n  readonly device: PointerDevice;\n}\n\nexport interface PointerButtonEvent {\n  readonly id: number;\n  readonly position: IVector2;\n  readonly button: PointerButton;\n  readonly down: boolean;\n  readonly device: PointerDevice;\n}\n\nexport interface ScrollEvent {\n  readonly position: IVector2;\n  readonly delta: IVector2;\n}\n\nexport enum KeyState {\n  DOWN,\n  PRESSED,\n  UP,\n}\n\nexport enum Keys{\n  ESCAPE = 27,\n  ZERO = 48,\n  ONE = 49,\n  TWO = 50,\n  THREE = 51,\n  FOUR = 52,\n  FIVE = 53,\n  SIX = 54,\n  SEVEN = 55,\n  EIGHT = 56,\n  NINE = 57,\n  LEFTARROW = 37,\n  UPARROW = 38,\n  RIGHTARROW = 39,\n  DOWNARROW = 40,\n  TAB = 9,\n  A = 65,\n  B = 66,\n  C = 67,\n  D = 68,\n  E = 69,\n  F = 70,\n  G = 71,\n  H = 72,\n  I = 73,\n  J = 74,\n  K = 75,\n  L = 76,\n  M = 77,\n  N = 78,\n  O = 79,\n  P = 80,\n  Q = 81,\n  R = 82,\n  S = 83,\n  T = 84,\n  U = 85,\n  V = 86,\n  W = 87,\n  X = 88,\n  Y = 89,\n  Z = 90,\n  SPACE = 32,\n  RETURN = 13,\n  DELETE = 46,\n  BACKSPACE = 8,\n  SEMICOLON = 186,\n  PLUSEQUALS = 187,\n  DASHUNDERSCORE = 189,\n  OPENBRACKET = 219,\n  SHIFT = 16,\n  ALT = 18,\n  CONTROL = 17,\n}\n\nexport interface KeyEvent {\n  key: Keys;\n  state: KeyState;\n  modifiers: {\n    altKey: boolean,\n    shiftKey: boolean,\n    ctrlKey: boolean\n  };\n}\n\nexport interface LongPressStartEvent {\n  readonly position: IVector2;\n  readonly buttons: PointerButtonMask;\n  readonly threshold: number;\n}\n\nexport interface LongPressEndEvent {}\n\nexport interface MultiSwipeEvent {\n  readonly pointerCount: number;\n  readonly position: IVector2;\n  readonly delta: IVector2;\n}\n\nexport interface MultiSwipeEndEvent extends MultiSwipeEvent {\n  readonly timeSinceLastMove: number;\n}\n\nexport interface PinchEvent {\n  readonly pinchDelta: number;\n}\n\nexport interface PinchEndEvent extends PinchEvent {\n  readonly timeSinceLastMove: number;\n}\n\nexport interface RotateEvent {\n  readonly rotateDelta: number;\n}\n\nexport interface RotateEndEvent extends RotateEvent {\n  readonly timeSinceLastMove: number;\n}\n"]}