@smarterplan/ngx-smarterplan-core 1.2.1 → 1.2.3

package/esm2020/lib/matterport-extensions/video-renderer/VideoRenderer.mjs

@@ -0,0 +1,64 @@
+import { SceneComponent } from './../scene-component/SceneComponent';
+import { VideoTexture, LinearFilter, RGBAFormat } from 'three';
+export class VideoRenderer extends SceneComponent {
+    constructor() {
+        super(...arguments);
+        this.inputs = {
+            src: null,
+        };
+        this.outputs = {
+            texture: null,
+        };
+    }
+    onInit() {
+    }
+    onInputsUpdated() {
+        this.releaseTexture();
+        // if (!this.inputs.src) {
+        //   this.video.src = '';
+        //   return;
+        // }
+        if (this.inputs.src instanceof HTMLVideoElement) {
+            // TODO 'https://www.smarterplan.io/wp-content/uploads/2023/03/121222-04.mp4';
+            this.video = this.inputs.src;
+        }
+        else {
+            this.video = this.createVideoElement();
+            // if (typeof this.inputs.src === 'string') {
+            //   this.video.src = this.inputs.src;
+            // } else {
+            //   this.video.srcObject = this.inputs.src;
+            // }
+            this.video.src = './../assets/video/121222-04.mp4';
+            this.video.load();
+        }
+        this.texture = new VideoTexture(this.video);
+        this.texture.minFilter = LinearFilter;
+        this.texture.magFilter = LinearFilter;
+        this.texture.format = RGBAFormat;
+        this.outputs.texture = this.texture;
+        this.video.play();
+    }
+    onDestroy() {
+        this.releaseTexture();
+    }
+    releaseTexture() {
+        if (this.texture) {
+            this.outputs.texture = null;
+            this.texture.dispose();
+        }
+    }
+    createVideoElement() {
+        const video = document.createElement('video');
+        video.crossOrigin = 'anonymous';
+        video.autoplay = true;
+        video.muted = true;
+        video.loop = true;
+        return video;
+    }
+}
+export const videoRendererType = 'mp.videoRenderer';
+export function makeVideoRenderer() {
+    return new VideoRenderer();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/matterport-extensions/view-frustum-mesh/ViewFrustumMesh.mjs

@@ -0,0 +1,221 @@
+import { Object3D, Mesh, PerspectiveCamera, ShaderMaterial, MeshBasicMaterial, BoxGeometry, EdgesGeometry, Color, Matrix4, Vector3, Euler, CylinderBufferGeometry, BackSide, NormalBlending, AdditiveBlending, } from 'three';
+import * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { SceneComponent } from '../scene-component/SceneComponent';
+/**
+ * This class is the extracted View Frustum Mesh from
+ * SecurityCamera example
+ */
+export class ViewFrustumMesh extends SceneComponent {
+    constructor() {
+        super(...arguments);
+        this.root = null;
+        this.pivot = null;
+        this.box = null;
+        this.edges = null;
+        this.inputs = {
+            "nearPlane": 0.1,
+            "farPlane": 10,
+            "horizontalFOV": 52,
+            "aspect": 1.7777777777777777,
+            "localPosition": {
+                "x": 0,
+                "y": 0.18,
+                "z": -0.3
+            },
+            "localRotation": {
+                "x": -15,
+                "y": 0,
+                "z": 0
+            },
+            "color": 65280,
+            "panPeriod": 5,
+            "panAngle": -45
+        };
+        this.highlight = null;
+        this.highlightUniforms = {
+            color: { value: new Color() },
+            projPosition: { value: new Vector3() },
+            lightMatrix: { value: new Matrix4() },
+        };
+        this.outputs = {};
+    }
+    onInit() {
+        this.root = new Object3D();
+        this.pivot = new Object3D();
+        this.root.add(this.pivot);
+        this.outputs.objectRoot = this.root;
+        const euler = new Euler(this.inputs.localRotation.x * Math.PI / 180, this.inputs.localRotation.y * Math.PI / 180, this.inputs.localRotation.z * Math.PI / 180, 'YXZ');
+        this.pivot.quaternion.setFromEuler(euler);
+        this.makeFrustumVisuals();
+        this.pivot.add(this.box);
+        this.pivot.add(this.edges);
+        const aspect = this.inputs.aspect;
+        const DEG2RAD = Math.PI / 180;
+        const RAD2DEG = 1 / DEG2RAD;
+        const verticalFOV = 2 * Math.atan(1 / aspect * Math.tan(0.5 * this.inputs.horizontalFOV * DEG2RAD)) * RAD2DEG;
+        this.projector = new PerspectiveCamera(verticalFOV, aspect, this.inputs.nearPlane, this.inputs.farPlane);
+        this.pivot.add(this.projector);
+        this.makeHighlight();
+        this.context.scene.add(this.highlight);
+    }
+    onTickModified(delta, quaternion) {
+        this.pivot.quaternion.set(quaternion.x, quaternion.y, quaternion.z, quaternion.w);
+        updateHighlightUniforms(this.projector, this.highlightUniforms);
+    }
+    makeFrustumVisuals() {
+        if (this.box) {
+            this.root.remove(this.box);
+            this.box.material.dispose();
+            this.box.geometry.dispose();
+            this.box = null;
+        }
+        if (this.edges) {
+            this.root.remove(this.edges);
+            this.edges.material.dispose();
+            this.edges.geometry.dispose();
+            this.edges = null;
+        }
+        function edgesToCylinders(edgesGeometry, thickness) {
+            const { position } = edgesGeometry.attributes;
+            const { array, count } = position;
+            const r = thickness / 2;
+            const geoms = [];
+            for (let i = 0; i < count * 3 - 1; i += 6) {
+                const a = new Vector3(array[i], array[i + 1], array[i + 2]);
+                const b = new Vector3(array[i + 3], array[i + 4], array[i + 5]);
+                const vec = new Vector3().subVectors(b, a);
+                const len = vec.length();
+                const geom = new CylinderBufferGeometry(r, r, len, 8);
+                geom.translate(0, len / 2, 0);
+                geom.rotateX(Math.PI / 2);
+                geom.lookAt(vec);
+                geom.translate(a.x, a.y, a.z);
+                geoms.push(geom);
+            }
+            // API to be updated in bundle - JSSDK-1222
+            return BufferGeometryUtils.mergeBufferGeometries(geoms);
+        }
+        const frustumLength = this.inputs.farPlane - this.inputs.nearPlane;
+        const boxGeometry = new BoxGeometry(2, 2, frustumLength);
+        const halfHAngle = this.inputs.horizontalFOV * 0.5 * Math.PI / 180;
+        const nearHalfWidth = Math.tan(halfHAngle) * this.inputs.nearPlane;
+        const farHalfWidth = Math.tan(halfHAngle) * this.inputs.farPlane;
+        const nearHalfHeight = nearHalfWidth / this.inputs.aspect;
+        const farHalfHeight = farHalfWidth / this.inputs.aspect;
+        const positions = boxGeometry.getAttribute('position');
+        for (let i = 0; i < positions.count; i++) {
+            const vertexZ = positions.getZ(i);
+            const vertexX = positions.getX(i);
+            const vertexY = positions.getY(i);
+            if (vertexZ > 0) {
+                // back of the camera
+                positions.setX(i, vertexX * nearHalfWidth);
+                positions.setY(i, vertexY * nearHalfHeight);
+            }
+            else {
+                // front of the camera
+                positions.setX(i, vertexX * farHalfWidth);
+                positions.setY(i, vertexY * farHalfHeight);
+            }
+            positions.setZ(i, vertexZ - 0.5 * frustumLength - this.inputs.nearPlane);
+        }
+        const boxMaterial = new MeshBasicMaterial({
+            color: this.inputs.color,
+            opacity: 0.35,
+            transparent: true,
+            side: BackSide,
+            blending: NormalBlending,
+            depthWrite: false,
+        });
+        this.box = new Mesh(boxGeometry, boxMaterial);
+        const edgesGeometry = edgesToCylinders(new EdgesGeometry(boxGeometry), 0.015);
+        this.edges = new Mesh(edgesGeometry, new MeshBasicMaterial({
+            color: 0xffffff,
+            opacity: 0.25,
+            transparent: true,
+            blending: AdditiveBlending,
+            depthWrite: false,
+        }));
+        const edgesGeometry2 = edgesToCylinders(new EdgesGeometry(boxGeometry), 0.06);
+        const edges2 = new Mesh(edgesGeometry2, new MeshBasicMaterial({
+            color: this.inputs.color,
+            opacity: 0.35,
+            transparent: true,
+            blending: AdditiveBlending,
+            depthWrite: false,
+        }));
+        this.pivot.add(edges2);
+    }
+    makeHighlight() {
+        let floorMesh = null;
+        floorMesh = this.context.scene.getObjectByName('FloorMesh:0');
+        const roomMesh = floorMesh.children[5];
+        updateHighlightUniforms(this.projector, this.highlightUniforms);
+        this.highlightUniforms.color.value.setHex(this.inputs.color);
+        const shader = new ShaderMaterial({
+            polygonOffset: true,
+            polygonOffsetUnits: -0.1,
+            transparent: true,
+            uniforms: this.highlightUniforms,
+            vertexShader: vertexShader(),
+            fragmentShader: fragmentShader(),
+        });
+        // a mesh to represent the "highlight"
+        this.highlight = new Mesh(roomMesh.geometry, shader);
+    }
+    onDestroy() {
+        if (this.highlight && this.highlight.parent) {
+            this.highlight.parent.remove(this.highlight);
+            this.highlight.material.dispose();
+        }
+        if (this.edges) {
+            this.edges.geometry.dispose();
+            this.edges.material.dispose();
+        }
+        if (this.box) {
+            this.box.geometry.dispose();
+            this.box.material.dispose();
+        }
+    }
+}
+function vertexShader() {
+    return `
+    uniform mat4 lightMatrix;
+
+    varying vec4 vLightCoords;
+
+    void main() {
+      // create a UV region [0,1] x [0,1] to represent what the lightMatrix "sees"
+      vLightCoords = lightMatrix *  modelMatrix * vec4(position, 1.0);
+      gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+    }
+  `;
+}
+function fragmentShader() {
+    return `
+    uniform vec3 color;
+
+    varying vec4 vLightCoords;
+
+    void main() {
+      vec2 lightUV = vLightCoords.xy / vLightCoords.w;
+      float inView = float(max(lightUV.x, lightUV.y) <= 1.0 && min(lightUV.x, lightUV.y) >= 0.0 && vLightCoords.z > 0.0);
+
+      gl_FragColor = vec4(color, min(inView, 0.2));
+    }
+  `;
+}
+function updateHighlightUniforms(projector, uniforms) {
+    projector.getWorldPosition(uniforms.projPosition.value);
+    // similar to a shadow matrix, but we're using it as a "rectangular" spotlight
+    // [lightBias] * [projection] * [viewMatrix]
+    uniforms.lightMatrix.value.makeScale(0.5, 0.5, 0.5);
+    uniforms.lightMatrix.value.setPosition(new Vector3(0.5, 0.5, 0.5));
+    uniforms.lightMatrix.value.multiplyMatrices(uniforms.lightMatrix.value, projector.projectionMatrix);
+    uniforms.lightMatrix.value.multiplyMatrices(uniforms.lightMatrix.value, projector.matrixWorldInverse);
+}
+export const ViewFrustumMeshType = 'mp.ViewFrustumMesh';
+export const makeViewFrustumMesh = function () {
+    return new ViewFrustumMesh();
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ViewFrustumMesh.js","sourceRoot":"","sources":["../../../../../../projects/ngx-smarterplan-core/src/lib/matterport-extensions/view-frustum-mesh/ViewFrustumMesh.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Object3D,\n  Mesh,\n  PerspectiveCamera,\n  ShaderMaterial,\n  MeshBasicMaterial,\n  BoxGeometry,\n  LineBasicMaterial,\n  EdgesGeometry,\n  Color,\n  Matrix4,\n  Vector3,\n  Euler,\n  CylinderBufferGeometry,\n  BackSide,\n  NormalBlending,\n  AdditiveBlending,\n} from 'three';\nimport * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils.js'\nimport {SceneComponent} from '../scene-component/SceneComponent';\n\ninterface Inputs {\n  nearPlane: number;\n  farPlane: number,\n  horizontalFOV: number,\n  aspect: number,\n  localPosition: { x: number; y: number; z: number; };\n  localRotation: { x: number; y: number; z: number; };\n  color: number;\n  panPeriod: number;\n  panAngle: number;\n}\n\ntype HighlightUniforms = {\n  color: { value: Color },\n  projPosition: { value: Vector3 };\n  lightMatrix: { value: Matrix4 };\n}\n\n/**\n * This class is the extracted View Frustum Mesh from\n * SecurityCamera example\n */\nexport class ViewFrustumMesh extends SceneComponent {\n\n  private root: Object3D | null = null;\n  private pivot: Object3D | null = null;\n  private box: Mesh | null = null;\n  private edges: Mesh | null = null;\n\n  private projector: PerspectiveCamera;\n\n  override inputs: Inputs = {\n    \"nearPlane\": 0.1,\n    \"farPlane\": 10,\n    \"horizontalFOV\": 52,\n    \"aspect\": 1.7777777777777777,\n    \"localPosition\": {\n      \"x\": 0,\n      \"y\": 0.18,\n      \"z\": -0.3\n    },\n    \"localRotation\": {\n      \"x\": -15,\n      \"y\": 0,\n      \"z\": 0\n    },\n    \"color\": 65280,\n    \"panPeriod\": 5,\n    \"panAngle\": -45\n  };\n\n  private highlight: Mesh | null = null;\n\n  private highlightUniforms: HighlightUniforms = {\n    color: {value: new Color()},\n    projPosition: {value: new Vector3()},\n    lightMatrix: {value: new Matrix4()},\n  }\n  override outputs: any = {};\n\n  override onInit() {\n\n    this.root = new Object3D();\n    this.pivot = new Object3D();\n    this.root.add(this.pivot);\n    this.outputs.objectRoot = this.root;\n\n    const euler = new Euler(this.inputs.localRotation.x * Math.PI / 180, this.inputs.localRotation.y * Math.PI / 180, this.inputs.localRotation.z * Math.PI / 180, 'YXZ');\n    this.pivot.quaternion.setFromEuler(euler);\n\n    this.makeFrustumVisuals();\n\n    this.pivot.add(this.box);\n    this.pivot.add(this.edges);\n\n    const aspect = this.inputs.aspect;\n    const DEG2RAD = Math.PI / 180;\n    const RAD2DEG = 1 / DEG2RAD;\n    const verticalFOV = 2 * Math.atan(1 / aspect * Math.tan(0.5 * this.inputs.horizontalFOV * DEG2RAD)) * RAD2DEG;\n    this.projector = new PerspectiveCamera(verticalFOV, aspect, this.inputs.nearPlane, this.inputs.farPlane);\n    this.pivot.add(this.projector);\n\n    this.makeHighlight();\n    this.context.scene.add(this.highlight);\n\n  }\n\n\n  onTickModified(delta: number, quaternion: any) {\n    this.pivot.quaternion.set(quaternion.x,quaternion.y,quaternion.z,quaternion.w);\n    updateHighlightUniforms(this.projector, this.highlightUniforms);\n  }\n\n  private makeFrustumVisuals() {\n    if (this.box) {\n      this.root.remove(this.box);\n      (this.box.material as MeshBasicMaterial).dispose();\n      (this.box.geometry as BoxGeometry).dispose();\n      this.box = null;\n    }\n    if (this.edges) {\n      this.root.remove(this.edges);\n      (this.edges.material as LineBasicMaterial).dispose();\n      (this.edges.geometry as EdgesGeometry).dispose();\n      this.edges = null;\n    }\n\n    function edgesToCylinders(edgesGeometry: EdgesGeometry, thickness: number) {\n      const {position} = edgesGeometry.attributes;\n      const {array, count} = position;\n      const r = thickness / 2;\n      const geoms = [];\n      for (let i = 0; i < count * 3 - 1; i += 6) {\n        const a = new Vector3(array[i], array[i + 1], array[i + 2]);\n        const b = new Vector3(array[i + 3], array[i + 4], array[i + 5]);\n\n        const vec = new Vector3().subVectors(b, a);\n        const len = vec.length();\n        const geom = new CylinderBufferGeometry(r, r, len, 8);\n        geom.translate(0, len / 2, 0);\n        geom.rotateX(Math.PI / 2);\n        geom.lookAt(vec);\n        geom.translate(a.x, a.y, a.z);\n        geoms.push(geom);\n      }\n      // API to be updated in bundle - JSSDK-1222\n      return BufferGeometryUtils.mergeBufferGeometries(geoms);\n    }\n\n    const frustumLength = this.inputs.farPlane - this.inputs.nearPlane;\n    const boxGeometry: BoxGeometry = new BoxGeometry(2, 2, frustumLength);\n    const halfHAngle = this.inputs.horizontalFOV * 0.5 * Math.PI / 180;\n    const nearHalfWidth = Math.tan(halfHAngle) * this.inputs.nearPlane;\n    const farHalfWidth = Math.tan(halfHAngle) * this.inputs.farPlane;\n    const nearHalfHeight = nearHalfWidth / this.inputs.aspect;\n    const farHalfHeight = farHalfWidth / this.inputs.aspect;\n\n    const positions = boxGeometry.getAttribute('position');\n\n    for (let i = 0; i < positions.count; i++) {\n      const vertexZ = positions.getZ(i);\n      const vertexX = positions.getX(i);\n      const vertexY = positions.getY(i);\n      if (vertexZ > 0) {\n        // back of the camera\n        positions.setX(i, vertexX * nearHalfWidth)\n        positions.setY(i, vertexY * nearHalfHeight);\n      } else {\n        // front of the camera\n        positions.setX(i, vertexX * farHalfWidth)\n        positions.setY(i, vertexY * farHalfHeight);\n      }\n      positions.setZ(i, vertexZ - 0.5 * frustumLength - this.inputs.nearPlane);\n    }\n\n    const boxMaterial: MeshBasicMaterial = new MeshBasicMaterial({\n      color: this.inputs.color,\n      opacity: 0.35,\n      transparent: true,\n      side: BackSide,\n      blending: NormalBlending,\n      depthWrite: false,\n    });\n    this.box = new Mesh(boxGeometry, boxMaterial);\n    const edgesGeometry = edgesToCylinders(new EdgesGeometry(boxGeometry), 0.015);\n    this.edges = new Mesh(edgesGeometry, new MeshBasicMaterial({\n      color: 0xffffff,\n      opacity: 0.25,\n      transparent: true,\n      blending: AdditiveBlending,\n      depthWrite: false,\n    }));\n\n    const edgesGeometry2 = edgesToCylinders(new EdgesGeometry(boxGeometry), 0.06);\n    const edges2 = new Mesh(edgesGeometry2, new MeshBasicMaterial({\n      color: this.inputs.color,\n      opacity: 0.35,\n      transparent: true,\n      blending: AdditiveBlending,\n      depthWrite: false,\n    }));\n    this.pivot.add(edges2);\n  }\n\n  private makeHighlight() {\n\n    let floorMesh = null;\n    floorMesh = this.context.scene.getObjectByName('FloorMesh:0');\n    const roomMesh = floorMesh.children[5] as Mesh;\n\n    updateHighlightUniforms(this.projector, this.highlightUniforms);\n    this.highlightUniforms.color.value.setHex(this.inputs.color);\n\n    const shader = new ShaderMaterial({\n      polygonOffset: true,\n      polygonOffsetUnits: -0.1,\n      transparent: true,\n      uniforms: this.highlightUniforms,\n      vertexShader: vertexShader(),\n      fragmentShader: fragmentShader(),\n    });\n\n    // a mesh to represent the \"highlight\"\n    this.highlight = new Mesh(roomMesh.geometry, shader);\n\n  }\n\n  override onDestroy() {\n    if (this.highlight && this.highlight.parent) {\n      this.highlight.parent.remove(this.highlight);\n      (this.highlight.material as ShaderMaterial).dispose();\n    }\n    if (this.edges) {\n      this.edges.geometry.dispose();\n      (this.edges.material as LineBasicMaterial).dispose();\n    }\n    if (this.box) {\n      this.box.geometry.dispose();\n      (this.box.material as MeshBasicMaterial).dispose();\n    }\n  }\n}\n\nfunction vertexShader(): string {\n  return `\n    uniform mat4 lightMatrix;\n\n    varying vec4 vLightCoords;\n\n    void main() {\n      // create a UV region [0,1] x [0,1] to represent what the lightMatrix \"sees\"\n      vLightCoords = lightMatrix *  modelMatrix * vec4(position, 1.0);\n      gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n    }\n  `;\n}\n\nfunction fragmentShader() {\n  return `\n    uniform vec3 color;\n\n    varying vec4 vLightCoords;\n\n    void main() {\n      vec2 lightUV = vLightCoords.xy / vLightCoords.w;\n      float inView = float(max(lightUV.x, lightUV.y) <= 1.0 && min(lightUV.x, lightUV.y) >= 0.0 && vLightCoords.z > 0.0);\n\n      gl_FragColor = vec4(color, min(inView, 0.2));\n    }\n  `;\n}\n\nfunction updateHighlightUniforms(projector: PerspectiveCamera, uniforms: HighlightUniforms) {\n  projector.getWorldPosition(uniforms.projPosition.value);\n\n  // similar to a shadow matrix, but we're using it as a \"rectangular\" spotlight\n  // [lightBias] * [projection] * [viewMatrix]\n  uniforms.lightMatrix.value.makeScale(0.5, 0.5, 0.5);\n  uniforms.lightMatrix.value.setPosition(new Vector3(0.5, 0.5, 0.5))\n  uniforms.lightMatrix.value.multiplyMatrices(uniforms.lightMatrix.value, projector.projectionMatrix);\n  uniforms.lightMatrix.value.multiplyMatrices(uniforms.lightMatrix.value, projector.matrixWorldInverse);\n}\n\nexport const ViewFrustumMeshType = 'mp.ViewFrustumMesh';\nexport const makeViewFrustumMesh = function () {\n  return new ViewFrustumMesh();\n}\n"]}