@colijnit/configurator 1.0.21 → 1.0.22

package/esm2015/utils/file.utils.js

@@ -0,0 +1,139 @@
+import { __awaiter } from "tslib";
+import axios from "axios";
+// Static utility functions holder related to files.
+// @dynamic
+export class FileUtils {
+    // Returns the given dataUri string stripped of the mimetype part.
+    static StripMimeStringFromDataUri(dataUri) {
+        if (!dataUri) {
+            return '';
+        }
+        const mimeString = this.GetMimeStringFromDataUri(dataUri);
+        return dataUri.substr(mimeString.length + 1);
+    }
+    static GetMimeStringFromDataUri(dataUri) {
+        if (!dataUri) {
+            return '';
+        }
+        return dataUri.split(',')[0];
+    }
+    static FileExists(url, assetPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield axios({
+                method: 'get',
+                url: `${assetPath}getFiles.php?assetUrl=${url}`,
+                responseType: "json"
+            });
+            return !!result.data;
+        });
+    }
+    /**
+     * There is some discrepancy regarding locations of h3d objects
+     * Therefor we need to (temporarily?!) fix the content url
+     * Also we need to change some additionals
+     */
+    static FixUrl(assetUrl) {
+        if (!assetUrl) {
+            return '';
+        }
+        let fixedUrl = assetUrl;
+        if (!fixedUrl.endsWith('glb') && !fixedUrl.endsWith('obj') && !fixedUrl.endsWith('glb.gz') && !fixedUrl.endsWith('obj.gz')) {
+            fixedUrl = FileUtils.FixUnityUrl(fixedUrl);
+        }
+        fixedUrl = fixedUrl.replace('/content/', '/content43/');
+        return fixedUrl;
+    }
+    static FixGlbUrl(assetUrl) {
+        if (!assetUrl) {
+            return '';
+        }
+        let fixedUrl = assetUrl;
+        if (assetUrl.indexOf('_webplayer') === -1) {
+            fixedUrl = assetUrl.concat('_webplayer');
+        }
+        fixedUrl = fixedUrl.replace('/content/', '/content43/');
+        if (!fixedUrl.endsWith('.glb')) {
+            fixedUrl = fixedUrl.concat('.glb');
+        }
+        return fixedUrl;
+    }
+    // Return the mimetype of the given filename.
+    static MimeTypeFromFilename(fileName) {
+        const regEx = /(?:\.([^.]+))?$/; // regex to find extension
+        const extension = regEx.exec(fileName)[1];
+        switch (extension) {
+            case 'jpg':
+            case 'jpeg':
+                return 'image/jpeg';
+            case 'png':
+                return 'image/png';
+            case 'bmp':
+                return 'image/bmp';
+        }
+    }
+    /**
+     * Downloads the given file to the users default download location.
+     * @param fileName With or without extension
+     * @param content File content as a string
+     * @param [mimeType = 'text/plain']
+     */
+    static DownloadFile(fileName, content, mimeType = 'text/plain') {
+        const element = document.createElement('a');
+        element.setAttribute('href', 'data:' + mimeType + ';charset=utf-8,' + encodeURIComponent(content));
+        element.setAttribute('download', fileName);
+        element.style.display = 'none';
+        document.body.appendChild(element);
+        element.click();
+        document.body.removeChild(element);
+    }
+    // Returns the contents of given file as a text string.
+    static ReadAsText(file) {
+        return new Promise((resolve) => {
+            const reader = new FileReader();
+            reader.readAsText(file);
+            reader.onloadend = (event) => {
+                if (event.target.readyState === 2) {
+                    resolve(event.target.result);
+                }
+            };
+        });
+    }
+    static GetExtensionFromDataUri(dataUri) {
+        return dataUri.replace(/(data:image\/)(.*?)(;base64.*)/gi, '$2');
+    }
+    static CreateDownloadFileNameFromBase64(dataUri) {
+        const ext = this.GetExtensionFromDataUri(dataUri);
+        return 'preview.' + ext;
+    }
+    static DownloadFromDataUri(dataUri, fileName) {
+        const link = document.createElement('a');
+        link.download = fileName;
+        link.href = dataUri;
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+    }
+    // todo remove once Connector deals with mimetypes and this method isn't used anymore
+    static DocumentBodyToDataUri(documentBody, mimeType) {
+        if (!!documentBody) {
+            return 'data:' + mimeType + ';base64,' + documentBody;
+        }
+        else {
+            return '';
+        }
+    }
+    static FixUnityUrl(url) {
+        if (url.indexOf('_webplayer') === -1) {
+            url = url.concat('_webplayer.ione3d');
+        }
+        else {
+            url = url.replace('_webplayer', '_webplayer.ione3d');
+        }
+        if (!url.endsWith('.gz')) {
+            url = url.concat('.gz');
+        }
+        return url.replace('.unity3d', '');
+    }
+}
+FileUtils._cachedTextureUploads = new Map();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file.utils.js","sourceRoot":"ng://@colijnit/configurator/","sources":["utils/file.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import axios from \"axios\";\n// Static utility functions holder related to files.\n// @dynamic\nexport class FileUtils {\n\n  private static _cachedTextureUploads: Map<string, Object> = new Map();\n\n  // Returns the given dataUri string stripped of the mimetype part.\n  public static StripMimeStringFromDataUri(dataUri: string): string {\n    if (!dataUri) {\n      return '';\n    }\n\n    const mimeString: string = this.GetMimeStringFromDataUri(dataUri);\n    return dataUri.substr(mimeString.length + 1);\n  }\n\n  public static GetMimeStringFromDataUri(dataUri: string): string {\n    if (!dataUri) {\n      return '';\n    }\n\n    return dataUri.split(',')[0];\n  }\n\n  public static async FileExists(url: string, assetPath: string): Promise<boolean> {\n      const result = await axios({\n        method: 'get',\n        url: `${assetPath}getFiles.php?assetUrl=${url}`,\n        responseType: \"json\"\n      })\n      return !!result.data;\n  }\n\n  /**\n   * There is some discrepancy regarding locations of h3d objects\n   * Therefor we need to (temporarily?!) fix the content url\n   * Also we need to change some additionals\n   */\n  public static FixUrl(assetUrl: string): string {\n    if (!assetUrl) {\n      return '';\n    }\n    let fixedUrl: string = assetUrl;\n    if (!fixedUrl.endsWith('glb') && !fixedUrl.endsWith('obj') && !fixedUrl.endsWith('glb.gz') && !fixedUrl.endsWith('obj.gz')) {\n      fixedUrl = FileUtils.FixUnityUrl(fixedUrl);\n    }\n    fixedUrl = fixedUrl.replace('/content/', '/content43/');\n    return fixedUrl;\n  }\n\n  public static FixGlbUrl(assetUrl: string): string {\n    if (!assetUrl) {\n      return '';\n    }\n    let fixedUrl: string = assetUrl;\n    if (assetUrl.indexOf('_webplayer') === -1) {\n      fixedUrl = assetUrl.concat('_webplayer');\n    }\n    fixedUrl = fixedUrl.replace('/content/', '/content43/');\n    if (!fixedUrl.endsWith('.glb')) {\n      fixedUrl = fixedUrl.concat('.glb');\n    }\n    return fixedUrl;\n  }\n\n  // Return the mimetype of the given filename.\n  public static MimeTypeFromFilename(fileName: string): string {\n    const regEx: RegExp = /(?:\\.([^.]+))?$/; // regex to find extension\n    const extension: any = regEx.exec(fileName)[1];\n    switch (extension) {\n      case 'jpg':\n      case 'jpeg':\n        return 'image/jpeg';\n      case 'png':\n        return 'image/png';\n      case 'bmp':\n        return 'image/bmp';\n    }\n  }\n\n  /**\n   * Downloads the given file to the users default download location.\n   * @param fileName With or without extension\n   * @param content File content as a string\n   * @param [mimeType = 'text/plain']\n   */\n  public static DownloadFile(\n    fileName: string,\n    content: string,\n    mimeType: string = 'text/plain'\n  ): void {\n    const element: HTMLAnchorElement = document.createElement('a');\n    element.setAttribute('href', 'data:' + mimeType + ';charset=utf-8,' + encodeURIComponent(content));\n    element.setAttribute('download', fileName);\n\n    element.style.display = 'none';\n    document.body.appendChild(element);\n\n    element.click();\n\n    document.body.removeChild(element);\n  }\n\n  // Returns the contents of given file as a text string.\n  public static ReadAsText(file: File): Promise<string> {\n    return new Promise<string>((resolve: Function) => {\n      const reader: FileReader = new FileReader();\n      reader.readAsText(file);\n      reader.onloadend = (event: any) => {\n        if (event.target.readyState === 2) {\n          resolve(event.target.result);\n        }\n      };\n    });\n  }\n\n  public static GetExtensionFromDataUri(dataUri: string): string {\n    return dataUri.replace(/(data:image\\/)(.*?)(;base64.*)/gi, '$2');\n  }\n\n  public static CreateDownloadFileNameFromBase64(dataUri: string): string {\n    const ext: string = this.GetExtensionFromDataUri(dataUri);\n    return 'preview.' + ext;\n  }\n\n  public static DownloadFromDataUri(dataUri: string, fileName: string): void {\n    const link: any = document.createElement('a');\n    link.download = fileName;\n    link.href = dataUri;\n    document.body.appendChild(link);\n    link.click();\n    document.body.removeChild(link);\n  }\n\n  // todo remove once Connector deals with mimetypes and this method isn't used anymore\n  public static DocumentBodyToDataUri(documentBody: string, mimeType: string): string {\n    if (!!documentBody) {\n      return 'data:' + mimeType + ';base64,' + documentBody;\n    } else {\n      return '';\n    }\n  }\n\n  private static FixUnityUrl(url): string {\n    if (url.indexOf('_webplayer') === -1) {\n      url = url.concat('_webplayer.ione3d');\n    } else {\n      url = url.replace('_webplayer', '_webplayer.ione3d');\n    }\n    if (!url.endsWith('.gz')) {\n      url = url.concat('.gz');\n    }\n    return url.replace('.unity3d', '');\n  }\n}\n"]}

package/esm2015/utils/image.utils.js

@@ -0,0 +1,52 @@
+import * as THREE from 'three';
+// @dynamic
+export class ImageUtils {
+    static CreateTextureFromBase64(id, base64, material) {
+        return new Promise((resolve) => {
+            if (ImageUtils.textures.has(id)) {
+                resolve(ImageUtils.textures.get(id));
+            }
+            else {
+                if (!base64) {
+                    resolve(new THREE.Texture());
+                }
+                else {
+                    const loader = new THREE.TextureLoader();
+                    loader.load(base64, (texture) => {
+                        texture.anisotropy = 16;
+                        texture.wrapS = THREE.RepeatWrapping;
+                        texture.wrapT = THREE.RepeatWrapping;
+                        texture.repeat = new THREE.Vector2(material ? material.repeatX : 1, material ? material.repeatY : 1);
+                        texture.needsUpdate = true;
+                        ImageUtils.textures.set(id, texture);
+                        resolve(texture);
+                    });
+                }
+            }
+        });
+    }
+    static getDocBodyWithMimeTypeDefinition(fileName, documentBody) {
+        if (documentBody === null) {
+            return documentBody;
+        }
+        const fileExtension = fileName.substr(fileName.lastIndexOf('.') + 1);
+        switch (fileExtension.toLowerCase()) {
+            case "jpg":
+            case "jpeg":
+                return "data:image/jpg;base64," + documentBody;
+            case "png":
+                return "data:image/png;base64," + documentBody;
+            case "gif":
+                return "data:image/gif;base64," + documentBody;
+            case "bmp":
+                return "data:image/bmp;base64," + documentBody;
+            default:
+                return "data:image/png;base64," + documentBody;
+        }
+    }
+    static getFixedImageFilepathUrl(imageFilepathUrl) {
+        return imageFilepathUrl.replace("/content/", "/content43/");
+    }
+}
+ImageUtils.textures = new Map();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/utils/object.utils.js

@@ -0,0 +1,49 @@
+import { Mesh } from "three";
+export class ObjectUtils {
+    static DisposeMaterial(material) {
+        if (!material) {
+            return;
+        }
+        if (Array.isArray(material)) {
+            material.forEach(mtrl => {
+                this.materialProps
+                    .filter(mapType => mtrl[mapType])
+                    .forEach(mapType => mtrl[mapType].dispose());
+                mtrl.dispose();
+            });
+        }
+        else {
+            this.materialProps
+                .filter(mapType => material[mapType] && material[mapType].dispose)
+                .forEach(mapType => material[mapType].dispose());
+            if (material.dispose) {
+                material.dispose();
+            }
+        }
+    }
+    static DisposeObject(object) {
+        if (!object) {
+            return;
+        }
+        if (object.children.length) {
+            object.children.forEach(child => this.DisposeObject(child));
+        }
+        this.DisposeNode(object);
+    }
+    static DisposeNode(node) {
+        node.traverse((obj) => {
+            if (obj instanceof Mesh) {
+                if (obj.geometry) {
+                    obj.geometry.dispose();
+                }
+                this.DisposeMaterial(obj.material);
+            }
+            if (typeof obj.dispose === 'function') {
+                // @ts-ignore
+                obj.dispose();
+            }
+        });
+    }
+}
+ObjectUtils.materialProps = ['map', 'lightMap', 'bumpMap', 'normalMap', 'specularMap', 'envMap', 'aoMap', 'roughnessMap', 'metalnessMap'];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/utils/scene-utils.js

@@ -0,0 +1,94 @@
+import * as THREE from 'three';
+export class SceneUtils {
+    static TrySelectorConnection(scene, parent, part1, part2, createAddableFn) {
+        let addable;
+        if (createAddableFn) {
+            addable = part2;
+            part2 = createAddableFn(addable);
+        }
+        for (let i = 0; i < part1.children.length; i++) {
+            for (let ii = 0; ii < part2.children.length; ii++) {
+                const con1 = part1.children[i];
+                const con2 = part2.children[ii];
+                // if these connectors can connect connect them
+                if (!con1['connected'] && !con2['connected'] && this.CanSelectorConnect(con1, con2)) {
+                    // if addable, continue this loop with a new addable
+                    if (addable) {
+                        const newPart2 = createAddableFn(addable, part2, part1);
+                        // reference of part2 changed, so refresh con2
+                        this.SelectorConnect(scene, parent, con1, newPart2.children[ii]);
+                    }
+                    else {
+                        return this.SelectorConnect(scene, parent, con1, con2);
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    static Convert3DPointToScreenPoint(point, camera, width, height) {
+        if (!point) {
+            return new THREE.Vector2();
+        }
+        const vector = point.clone().project(camera);
+        vector.x = (vector.x + 1) / 2 * width;
+        vector.y = -(vector.y - 1) / 2 * height;
+        return new THREE.Vector2(vector.x, vector.y);
+    }
+    static CanSelectorConnect(con1, con2) {
+        const con1Name = con1 instanceof THREE.Object3D ? con1.name : con1.connector;
+        const con2Name = con2 instanceof THREE.Object3D ? con2.name : con2.connector;
+        const sameParent = con1 instanceof THREE.Object3D && con2 instanceof THREE.Object3D ? con1.parent === con2.parent : false;
+        const parts1 = con1Name.toUpperCase().split('_'), parts2 = con2Name.toUpperCase().split('_');
+        if (parts1.length >= 3 && parts2.length >= 3 && !sameParent) {
+            const connectable = parts1[0] === 'C' && parts2[0] === 'C' &&
+                parts1[1] === parts2[1] && parts1[2] !== parts2[2];
+            return connectable;
+        }
+        return false;
+    }
+    static SelectorConnect(scene, parent, con1, con2) {
+        if (!scene || !parent) {
+            return false;
+        }
+        con1['connectedTo'] = con2.parent.name;
+        con2['connectedTo'] = con1.parent.name;
+        const motherRotation = new THREE.Euler(0, 0, 0);
+        const motherPosition = new THREE.Vector3(0, 0, 0);
+        scene.updateMatrixWorld(true);
+        motherRotation.copy(parent.rotation);
+        parent.getWorldPosition(motherPosition);
+        parent.rotation.set(0, 0, 0);
+        parent.position.set(0, 0, 0);
+        const con1Quat = new THREE.Quaternion();
+        con1.getWorldQuaternion(con1Quat);
+        const con2Quat = new THREE.Quaternion();
+        con2.getWorldQuaternion(con2Quat);
+        const con1QuatParent = new THREE.Quaternion();
+        con1.parent.getWorldQuaternion(con1QuatParent);
+        const con2QuatParent = new THREE.Quaternion();
+        con2.parent.getWorldQuaternion(con2QuatParent);
+        const rotation = new THREE.Quaternion().multiplyQuaternions(con1Quat.invert(), con2Quat).multiply(new THREE.Quaternion().multiplyQuaternions(con1QuatParent, con1QuatParent));
+        con2.parent.quaternion.copy(rotation);
+        // Update because the matrix has been tempered with
+        scene.updateMatrixWorld(true);
+        // Move the connectors towards eachother
+        const con1Pos = new THREE.Vector3();
+        con1.getWorldPosition(con1Pos);
+        const con2Pos = new THREE.Vector3();
+        con2.getWorldPosition(con2Pos);
+        const move = con1Pos.sub(con2Pos);
+        con2.parent.position.x += move.x;
+        con2.parent.position.y += move.y;
+        con2.parent.position.z += move.z;
+        // reset parent's objects rotation and position
+        parent.rotation.copy(motherRotation);
+        parent.position.copy(motherPosition);
+        scene.updateMatrixWorld(true);
+        // Set the connected flag
+        con1['connected'] = true;
+        con2['connected'] = true;
+        return true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scene-utils.js","sourceRoot":"ng://@colijnit/configurator/","sources":["utils/scene-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import * as THREE from 'three';\r\n\r\nexport class SceneUtils {\r\n\r\n    public static TrySelectorConnection(scene: THREE.Scene, parent: THREE.Object3D,\r\n        part1: any, part2: any, createAddableFn?: Function): boolean {\r\n        let addable: any;\r\n        if (createAddableFn) {\r\n            addable = part2;\r\n            part2 = createAddableFn(addable);\r\n        }\r\n        for (let i = 0; i < part1.children.length; i++) {\r\n            for (let ii = 0; ii < part2.children.length; ii++) {\r\n                const con1: THREE.Object3D = part1.children[i];\r\n                const con2: THREE.Object3D = part2.children[ii];\r\n                // if these connectors can connect connect them\r\n                if (!con1['connected'] && !con2['connected'] && this.CanSelectorConnect(con1, con2)) {\r\n                    // if addable, continue this loop with a new addable\r\n                    if (addable) {\r\n                        const newPart2: THREE.Object3D = createAddableFn(addable, part2, part1);\r\n                        // reference of part2 changed, so refresh con2\r\n                        this.SelectorConnect(scene, parent, con1, newPart2.children[ii]);\r\n                    } else {\r\n                        return this.SelectorConnect(scene, parent, con1, con2);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n\r\n    public static Convert3DPointToScreenPoint(point: THREE.Vector3, camera: THREE.Camera, width: number, height: number): THREE.Vector2 {\r\n        if (!point) {\r\n            return new THREE.Vector2();\r\n        }\r\n        const vector: THREE.Vector3 = point.clone().project(camera);\r\n        vector.x = (vector.x + 1) / 2 * width;\r\n        vector.y = -(vector.y - 1) / 2 * height;\r\n        return new THREE.Vector2(vector.x, vector.y);\r\n    }\r\n\r\n    public static CanSelectorConnect(con1: THREE.Object3D | any, con2: THREE.Object3D | any): boolean {\r\n        const con1Name: string = con1 instanceof THREE.Object3D ? con1.name : con1.connector;\r\n        const con2Name: string = con2 instanceof THREE.Object3D ? con2.name : con2.connector;\r\n        const sameParent: boolean = con1 instanceof THREE.Object3D && con2 instanceof THREE.Object3D ? con1.parent === con2.parent : false;\r\n        const parts1: string[] = con1Name.toUpperCase().split('_'),\r\n            parts2: string[] = con2Name.toUpperCase().split('_');\r\n        if (parts1.length >= 3 && parts2.length >= 3 && !sameParent) {\r\n            const connectable: boolean = parts1[0] === 'C' && parts2[0] === 'C' &&\r\n                parts1[1] === parts2[1] && parts1[2] !== parts2[2];\r\n            return connectable;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    private static SelectorConnect(scene: THREE.Scene, parent: THREE.Object3D, con1: THREE.Object3D, con2: THREE.Object3D): boolean {\r\n        if (!scene || !parent) {\r\n            return false;\r\n        }\r\n        con1['connectedTo'] = con2.parent.name;\r\n        con2['connectedTo'] = con1.parent.name;\r\n\r\n        const motherRotation: THREE.Euler = new THREE.Euler(0, 0, 0);\r\n        const motherPosition: THREE.Vector3 = new THREE.Vector3(0, 0, 0);\r\n\r\n        scene.updateMatrixWorld(true);\r\n        motherRotation.copy(parent.rotation);\r\n        parent.getWorldPosition(motherPosition);\r\n\r\n        parent.rotation.set(0, 0, 0);\r\n        parent.position.set(0, 0, 0);\r\n\r\n        const con1Quat: THREE.Quaternion = new THREE.Quaternion();\r\n        con1.getWorldQuaternion(con1Quat);\r\n        const con2Quat: THREE.Quaternion = new THREE.Quaternion();\r\n        con2.getWorldQuaternion(con2Quat);\r\n        const con1QuatParent: THREE.Quaternion = new THREE.Quaternion();\r\n        con1.parent.getWorldQuaternion(con1QuatParent);\r\n        const con2QuatParent: THREE.Quaternion = new THREE.Quaternion();\r\n        con2.parent.getWorldQuaternion(con2QuatParent);\r\n\r\n        const rotation: THREE.Quaternion = new THREE.Quaternion().multiplyQuaternions(\r\n            con1Quat.invert(),\r\n            con2Quat\r\n        ).multiply(\r\n            new THREE.Quaternion().multiplyQuaternions(\r\n                con1QuatParent,\r\n                con1QuatParent\r\n            )\r\n        );\r\n\r\n        con2.parent.quaternion.copy(rotation);\r\n        // Update because the matrix has been tempered with\r\n        scene.updateMatrixWorld(true);\r\n\r\n        // Move the connectors towards eachother\r\n        const con1Pos: THREE.Vector3 = new THREE.Vector3();\r\n        con1.getWorldPosition(con1Pos);\r\n        const con2Pos: THREE.Vector3 = new THREE.Vector3();\r\n        con2.getWorldPosition(con2Pos);\r\n\r\n        const move: THREE.Vector3 = con1Pos.sub(con2Pos);\r\n        con2.parent.position.x += move.x;\r\n        con2.parent.position.y += move.y;\r\n        con2.parent.position.z += move.z;\r\n\r\n        // reset parent's objects rotation and position\r\n        parent.rotation.copy(motherRotation);\r\n        parent.position.copy(motherPosition);\r\n\r\n        scene.updateMatrixWorld(true);\r\n\r\n        // Set the connected flag\r\n        con1['connected'] = true;\r\n        con2['connected'] = true;\r\n        return true;\r\n    }\r\n\r\n}\r\n"]}