fx-form-builder-wrapper 2.0.59 → 2.0.62

package/esm2022/lib/components/three-viewer/three-viewer.component.mjs

@@ -0,0 +1,161 @@
+import { Component, ViewChild, Input } from '@angular/core';
+import * as THREE from 'three';
+import { STLLoader } from 'three/examples/jsm/loaders/STLLoader.js';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ThreeViewerComponent {
+    http;
+    viewerContainer;
+    file;
+    manualFileUpload = null;
+    scene;
+    camera;
+    renderer;
+    loader = new STLLoader();
+    model;
+    isDragging = false;
+    previousMousePosition = { x: 0, y: 0 };
+    zoomSpeed = 1.1;
+    constructor(http) {
+        this.http = http;
+    }
+    ngAfterViewInit() {
+        this.initThree();
+    }
+    ngOnChanges(changes) {
+        if (changes['manualFileUpload']?.currentValue && this.manualFileUpload) {
+            this.loadModelFromBlob(this.manualFileUpload);
+        }
+    }
+    ngOnDestroy() {
+        this.cleanupThreeJS();
+    }
+    initThree() {
+        const container = this.viewerContainer.nativeElement;
+        this.scene = new THREE.Scene();
+        this.scene.background = new THREE.Color(0xf0f0f0);
+        this.camera = new THREE.PerspectiveCamera(60, container.clientWidth / container.clientHeight, 0.1, 1000);
+        this.camera.position.set(0, 0, 100);
+        this.renderer = new THREE.WebGLRenderer({ antialias: true });
+        this.renderer.setSize(container.clientWidth, container.clientHeight);
+        container.appendChild(this.renderer.domElement);
+        const ambientLight = new THREE.AmbientLight(0x404040, 2);
+        this.scene.add(ambientLight);
+        const directionalLight = new THREE.DirectionalLight(0xffffff, 1);
+        directionalLight.position.set(1, 1, 1).normalize();
+        this.scene.add(directionalLight);
+        this.initControls();
+        this.animate();
+    }
+    initControls() {
+        const canvas = this.renderer.domElement;
+        // Mouse Drag for Rotation
+        canvas.addEventListener('mousedown', (event) => {
+            this.isDragging = true;
+            this.previousMousePosition.x = event.clientX;
+            this.previousMousePosition.y = event.clientY;
+        });
+        canvas.addEventListener('mouseup', () => {
+            this.isDragging = false;
+        });
+        canvas.addEventListener('mousemove', (event) => {
+            if (!this.isDragging)
+                return;
+            const deltaX = event.clientX - this.previousMousePosition.x;
+            const deltaY = event.clientY - this.previousMousePosition.y;
+            const rotationSpeed = 0.005;
+            this.model?.rotateY(deltaX * rotationSpeed);
+            this.model?.rotateX(deltaY * rotationSpeed);
+            this.previousMousePosition.x = event.clientX;
+            this.previousMousePosition.y = event.clientY;
+        });
+        // Scroll for Zoom
+        canvas.addEventListener('wheel', (event) => {
+            // event.preventDefault();
+            if (event.deltaY < 0) {
+                this.camera.position.multiplyScalar(1 / this.zoomSpeed); // Zoom In
+            }
+            else {
+                this.camera.position.multiplyScalar(this.zoomSpeed); // Zoom Out
+            }
+            this.camera.updateProjectionMatrix();
+        });
+        // Resize Handling
+        window.addEventListener('resize', () => this.onWindowResize());
+    }
+    loadModelFromBlob(blob) {
+        const reader = new FileReader();
+        reader.onload = () => {
+            const arrayBuffer = reader.result;
+            const geometry = this.loader.parse(arrayBuffer);
+            geometry.computeVertexNormals();
+            if (this.model) {
+                this.scene.remove(this.model);
+                this.model.geometry.dispose();
+            }
+            const material = new THREE.MeshPhysicalMaterial({
+                color: 0xF8F0E3,
+                metalness: 0.1,
+                roughness: 0.5,
+                transmission: 0.5, // Creates slight translucency
+                clearcoat: 1.0, // Adds enamel-like reflection
+                clearcoatRoughness: 0.3
+            });
+            this.model = new THREE.Mesh(geometry, material);
+            this.scene.add(this.model);
+            this.centerModel();
+        };
+        reader.readAsArrayBuffer(blob);
+    }
+    centerModel() {
+        if (!this.model)
+            return;
+        const box = new THREE.Box3().setFromObject(this.model);
+        const center = new THREE.Vector3();
+        box.getCenter(center);
+        this.model.position.sub(center);
+        const size = box.getSize(new THREE.Vector3()).length();
+        this.camera.position.set(0, 0, size * 2);
+        this.camera.updateProjectionMatrix();
+        this.onWindowResize();
+    }
+    animate = () => {
+        requestAnimationFrame(this.animate);
+        this.renderer.render(this.scene, this.camera);
+    };
+    onWindowResize() {
+        const container = this.viewerContainer.nativeElement;
+        this.camera.aspect = container.clientWidth / container.clientHeight;
+        this.camera.updateProjectionMatrix();
+        this.renderer.setSize(container.clientWidth, container.clientHeight);
+    }
+    cleanupThreeJS() {
+        // Remove event listeners
+        const canvas = this.renderer.domElement;
+        canvas.removeEventListener('mousedown', () => { });
+        canvas.removeEventListener('mouseup', () => { });
+        canvas.removeEventListener('mousemove', () => { });
+        canvas.removeEventListener('wheel', () => { });
+        window.removeEventListener('resize', () => this.onWindowResize());
+        // Dispose of Three.js resources
+        if (this.model) {
+            this.scene.remove(this.model);
+            this.model.geometry.dispose();
+        }
+        this.renderer.dispose();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ThreeViewerComponent, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: ThreeViewerComponent, isStandalone: true, selector: "app-three-viewer", inputs: { file: "file", manualFileUpload: "manualFileUpload" }, viewQueries: [{ propertyName: "viewerContainer", first: true, predicate: ["viewerContainer"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: "<div #viewerContainer class=\"viewer-container\"></div>\r\n  ", styles: [".viewer-container{position:relative;width:100%;max-height:500px;overflow:hidden}button{position:absolute;top:10px;background:#000000b3;color:#fff;border:none;padding:5px 10px;cursor:pointer;margin:5px}button:hover{background:#000000e6}::ng-deep canvas{display:block;width:100%!important;height:100%!important;min-height:450px!important;min-width:986px!important}@media (min-width: 1600px){.viewer-container{width:100%;max-height:650px}canvas{min-width:1326px!important}}\n"] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ThreeViewerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-three-viewer', standalone: true, template: "<div #viewerContainer class=\"viewer-container\"></div>\r\n  ", styles: [".viewer-container{position:relative;width:100%;max-height:500px;overflow:hidden}button{position:absolute;top:10px;background:#000000b3;color:#fff;border:none;padding:5px 10px;cursor:pointer;margin:5px}button:hover{background:#000000e6}::ng-deep canvas{display:block;width:100%!important;height:100%!important;min-height:450px!important;min-width:986px!important}@media (min-width: 1600px){.viewer-container{width:100%;max-height:650px}canvas{min-width:1326px!important}}\n"] }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }], propDecorators: { viewerContainer: [{
+                type: ViewChild,
+                args: ['viewerContainer', { static: true }]
+            }], file: [{
+                type: Input
+            }], manualFileUpload: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"three-viewer.component.js","sourceRoot":"","sources":["../../../../../../projects/fx-builder-wrapper/src/lib/components/three-viewer/three-viewer.component.ts","../../../../../../projects/fx-builder-wrapper/src/lib/components/three-viewer/three-viewer.component.html"],"names":[],"mappings":"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","sourcesContent":["import { \r\n  Component, ElementRef, AfterViewInit, ViewChild, Input, OnChanges, SimpleChanges, OnDestroy \r\n} from '@angular/core';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport * as THREE from 'three';\r\nimport { STLLoader } from 'three/examples/jsm/loaders/STLLoader.js';\r\n\r\n@Component({\r\n  selector: 'app-three-viewer',\r\n  templateUrl: './three-viewer.component.html',\r\n  styleUrls: ['./three-viewer.component.scss'],\r\n  standalone: true\r\n})\r\nexport class ThreeViewerComponent implements AfterViewInit, OnChanges, OnDestroy {\r\n  @ViewChild('viewerContainer', { static: true }) viewerContainer!: ElementRef;\r\n  @Input() file!: any;\r\n  @Input() manualFileUpload: Blob | null = null;\r\n\r\n  private scene!: THREE.Scene;\r\n  private camera!: THREE.PerspectiveCamera;\r\n  private renderer!: THREE.WebGLRenderer;\r\n  private loader = new STLLoader();\r\n  private model!: THREE.Mesh | null;\r\n\r\n  private isDragging = false;\r\n  private previousMousePosition = { x: 0, y: 0 };\r\n  private zoomSpeed = 1.1;\r\n\r\n  constructor(private http: HttpClient) {}\r\n\r\n  ngAfterViewInit(): void {\r\n    this.initThree();\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes['manualFileUpload']?.currentValue && this.manualFileUpload) {\r\n      this.loadModelFromBlob(this.manualFileUpload);\r\n    }\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.cleanupThreeJS();\r\n  }\r\n\r\n  private initThree(): void {\r\n    const container = this.viewerContainer.nativeElement;\r\n    this.scene = new THREE.Scene();\r\n    this.scene.background = new THREE.Color(0xf0f0f0);\r\n\r\n    this.camera = new THREE.PerspectiveCamera(60, container.clientWidth / container.clientHeight, 0.1, 1000);\r\n    this.camera.position.set(0, 0, 100);\r\n\r\n    this.renderer = new THREE.WebGLRenderer({ antialias: true });\r\n    this.renderer.setSize(container.clientWidth, container.clientHeight);\r\n    container.appendChild(this.renderer.domElement);\r\n\r\n    const ambientLight = new THREE.AmbientLight(0x404040, 2);\r\n    this.scene.add(ambientLight);\r\n\r\n    const directionalLight = new THREE.DirectionalLight(0xffffff, 1);\r\n    directionalLight.position.set(1, 1, 1).normalize();\r\n    this.scene.add(directionalLight);\r\n\r\n    this.initControls();\r\n    this.animate();\r\n  }\r\n\r\n  private initControls(): void {\r\n    const canvas = this.renderer.domElement;\r\n\r\n    // Mouse Drag for Rotation\r\n    canvas.addEventListener('mousedown', (event) => {\r\n      this.isDragging = true;\r\n      this.previousMousePosition.x = event.clientX;\r\n      this.previousMousePosition.y = event.clientY;\r\n    });\r\n\r\n    canvas.addEventListener('mouseup', () => {\r\n      this.isDragging = false;\r\n    });\r\n\r\n    canvas.addEventListener('mousemove', (event) => {\r\n      if (!this.isDragging) return;\r\n\r\n      const deltaX = event.clientX - this.previousMousePosition.x;\r\n      const deltaY = event.clientY - this.previousMousePosition.y;\r\n\r\n      const rotationSpeed = 0.005;\r\n      this.model?.rotateY(deltaX * rotationSpeed);\r\n      this.model?.rotateX(deltaY * rotationSpeed);\r\n\r\n      this.previousMousePosition.x = event.clientX;\r\n      this.previousMousePosition.y = event.clientY;\r\n    });\r\n\r\n    // Scroll for Zoom\r\n    canvas.addEventListener('wheel', (event) => {\r\n      // event.preventDefault();\r\n      if (event.deltaY < 0) {\r\n        this.camera.position.multiplyScalar(1 / this.zoomSpeed); // Zoom In\r\n      } else {\r\n        this.camera.position.multiplyScalar(this.zoomSpeed); // Zoom Out\r\n      }\r\n      this.camera.updateProjectionMatrix();\r\n    });\r\n\r\n    // Resize Handling\r\n    window.addEventListener('resize', () => this.onWindowResize());\r\n  }\r\n\r\n  private loadModelFromBlob(blob: Blob): void {\r\n    const reader = new FileReader();\r\n    reader.onload = () => {\r\n      const arrayBuffer = reader.result as ArrayBuffer;\r\n      const geometry = this.loader.parse(arrayBuffer);\r\n      geometry.computeVertexNormals();\r\n\r\n      if (this.model) {\r\n        this.scene.remove(this.model);\r\n        this.model.geometry.dispose();\r\n      }\r\n\r\n      const material = new THREE.MeshPhysicalMaterial({\r\n        color: 0xF8F0E3,\r\n        metalness: 0.1,\r\n        roughness: 0.5,\r\n        transmission: 0.5, // Creates slight translucency\r\n        clearcoat: 1.0,    // Adds enamel-like reflection\r\n        clearcoatRoughness: 0.3\r\n      });\r\n      \r\n      this.model = new THREE.Mesh(geometry, material);\r\n      this.scene.add(this.model);\r\n\r\n      this.centerModel();\r\n    };\r\n    reader.readAsArrayBuffer(blob);\r\n  }\r\n\r\n  private centerModel(): void {\r\n    if (!this.model) return;\r\n    const box = new THREE.Box3().setFromObject(this.model);\r\n    const center = new THREE.Vector3();\r\n    box.getCenter(center);\r\n    this.model.position.sub(center);\r\n\r\n    const size = box.getSize(new THREE.Vector3()).length();\r\n    this.camera.position.set(0, 0, size * 2);\r\n    this.camera.updateProjectionMatrix();\r\n    this.onWindowResize();\r\n  }\r\n\r\n  private animate = (): void => {\r\n    requestAnimationFrame(this.animate);\r\n    this.renderer.render(this.scene, this.camera);\r\n  };\r\n\r\n  onWindowResize(): void {\r\n    const container = this.viewerContainer.nativeElement;\r\n    this.camera.aspect = container.clientWidth / container.clientHeight;\r\n    this.camera.updateProjectionMatrix();\r\n    this.renderer.setSize(container.clientWidth, container.clientHeight);\r\n  }\r\n\r\n  private cleanupThreeJS(): void {\r\n    // Remove event listeners\r\n    const canvas = this.renderer.domElement;\r\n    canvas.removeEventListener('mousedown', () => {});\r\n    canvas.removeEventListener('mouseup', () => {});\r\n    canvas.removeEventListener('mousemove', () => {});\r\n    canvas.removeEventListener('wheel', () => {});\r\n    window.removeEventListener('resize', () => this.onWindowResize());\r\n\r\n    // Dispose of Three.js resources\r\n    if (this.model) {\r\n      this.scene.remove(this.model);\r\n      this.model.geometry.dispose();\r\n    }\r\n    this.renderer.dispose();\r\n  }\r\n}\r\n","<div #viewerContainer class=\"viewer-container\"></div>\r\n  "]}