@smarterplan/ngx-smarterplan-core 1.2.0 → 1.2.2

package/esm2020/lib/matterport-extensions/hsl-loader/HlsLoader.mjs

@@ -0,0 +1,68 @@
+import { SceneComponent } from './../scene-component/SceneComponent';
+// @ts-ignore
+import Hls from 'hls.js';
+export class HlsLoader extends SceneComponent {
+    constructor() {
+        super(...arguments);
+        this.video = null;
+        this.texture = null;
+        this.hls = null;
+        this.inputs = {
+            src: './../assets/video/121222-04.mp4',
+            enabled: true,
+        };
+        this.outputs = {
+            video: null,
+            aspect: 1,
+        };
+    }
+    onInit(videoTexture) {
+        this.outputs.video = videoTexture;
+        this.outputs.aspect = 720 / 480;
+        if (this.inputs.enabled) {
+            this.setupStream();
+        }
+    }
+    onInputsUpdated() {
+        this.setupStream();
+    }
+    onDestroy() {
+        this.releaseResources();
+    }
+    createVideoElement() {
+        const video = document.createElement('video');
+        video.crossOrigin = 'anonymous';
+        video.setAttribute('height', '480');
+        video.setAttribute('width', '720');
+        video.volume = 0.1;
+        return video;
+    }
+    setupStream() {
+        this.releaseResources();
+        if (this.inputs.enabled) {
+            this.video = this.createVideoElement();
+            this.hls = new Hls();
+            this.hls.loadSource(this.inputs.src);
+            this.hls.attachMedia(this.video);
+            this.hls.on(Hls.Events.MANIFEST_PARSED, () => {
+                this.outputs.video = this.video;
+            });
+        }
+    }
+    releaseResources() {
+        if (this.hls) {
+            this.hls.destroy();
+            this.hls = null;
+        }
+        if (this.texture) {
+            this.texture.dispose();
+            this.texture = null;
+            this.outputs.video = null;
+        }
+    }
+}
+export const hlsLoaderType = 'mp.hlsLoader';
+export function makeHlsLoader() {
+    return new HlsLoader();
+}
+//# sourceMappingURL=data:application/json;base64,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

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,190 @@
+import { SceneComponent } from '../scene-component/SceneComponent';
+import { AnimationMixer, LoopOnce, AnimationClip, Texture, VectorKeyframeTrack, InterpolateSmooth, MeshBasicMaterial, LinearFilter } 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) {
+                            let video, videoImage, videoImageContext, videoTexture;
+                            // create the video element
+                            video = document.createElement('video');
+                            video.src = "./../assets/video/121222-04.mp4";
+                            video.load(); // must call after setting/changing source
+                            video.loop = true;
+                            video.play();
+                            videoImage = document.createElement('canvas');
+                            videoImage.width = 480;
+                            videoImage.height = 204;
+                            videoImageContext = videoImage.getContext('2d');
+                            // background color if no video present
+                            videoImageContext.fillStyle = '#000000';
+                            videoImageContext.fillRect(0, 0, videoImage.width, videoImage.height);
+                            videoTexture = new Texture(videoImage);
+                            videoTexture.minFilter = LinearFilter;
+                            videoTexture.magFilter = LinearFilter;
+                            const movieMaterial = new MeshBasicMaterial({ map: videoTexture });
+                            // const newMaterial = new MeshBasicMaterial({map: this.inputs.texture});
+                            // const newMaterial = new MeshBasicMaterial({map: this.inputs.texture});
+                            // this.mesh.material[idx] = newMaterial;
+                            this.mesh.material[idx] = movieMaterial;
+                            const render = () => {
+                                if (video.readyState === video.HAVE_ENOUGH_DATA) {
+                                    videoImageContext.drawImage(video, 0, 0);
+                                    if (videoTexture)
+                                        videoTexture.needsUpdate = true;
+                                }
+                                const camera = this.rootScene.children.find(u => u.constructor.name === 'CameraRig');
+                                this.context.renderer.render(this.context.scene, camera);
+                            };
+                            setInterval(() => {
+                                render();
+                            }, 200);
+                        }
+                    });
+                }
+            });
+            // 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  LinearFilter,\n  DoubleSide\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              let video, videoImage, videoImageContext, videoTexture;\n              // create the video element\n              video = document.createElement('video');\n              video.src = \"./../assets/video/121222-04.mp4\";\n              video.load(); // must call after setting/changing source\n              video.loop = true;\n              video.play();\n\n              videoImage = document.createElement('canvas');\n              videoImage.width = 480;\n              videoImage.height = 204;\n\n              videoImageContext = videoImage.getContext('2d');\n              // background color if no video present\n              videoImageContext.fillStyle = '#000000';\n              videoImageContext.fillRect(0, 0, videoImage.width, videoImage.height);\n\n              videoTexture = new Texture(videoImage)\n              videoTexture.minFilter = LinearFilter;\n              videoTexture.magFilter = LinearFilter;\n              const movieMaterial = new MeshBasicMaterial({map: videoTexture})\n              // const newMaterial = new MeshBasicMaterial({map: this.inputs.texture});\n              // const newMaterial = new MeshBasicMaterial({map: this.inputs.texture});\n              // this.mesh.material[idx] = newMaterial;\n              this.mesh.material[idx] = movieMaterial;\n\n\n              const render = () => {\n                if (video.readyState === video.HAVE_ENOUGH_DATA) {\n                  videoImageContext.drawImage(video, 0, 0);\n                  if (videoTexture)\n                    videoTexture.needsUpdate = true;\n                }\n                const camera = this.rootScene.children.find(u=>u.constructor.name === 'CameraRig');\n                this.context.renderer.render(this.context.scene, camera);\n              }\n              setInterval(()=>{\n                render();\n              },200);\n\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"]}