@colijnit/homedecorator 255.1.1

package/esm2015/app/core/utils/material.utils.js

@@ -0,0 +1,407 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as THREE from 'three';
+import { SRGBColorSpace, Vector2 } from 'three';
+import * as md5 from 'md5';
+import { TextureType } from '../model/texture-type';
+export class MaterialUtils {
+    static SetAssetPath(path) {
+        MaterialUtils.assetPath = path;
+    }
+    static ClearCaches() {
+        MaterialUtils.imageCache.clear();
+        const textures = Array.from(MaterialUtils.textureCache.values());
+        textures.forEach((t) => t.dispose());
+        MaterialUtils.textureCache.clear();
+    }
+    static FromUrl(url, stretch, tileSize, repeatX, repeatY, dimensions, tileRotation) {
+        const ratio = dimensions ? (dimensions.x / dimensions.y) : 1; // Required to keep scale equal on surfaces of any dimension
+        const tileSizeMax = 300;
+        if (this.textureCache.has(url)) {
+            const texture = this.textureCache.get(url).clone();
+            tileSize = (tileSizeMax / 100) + 0.01 - tileSize; // Scale negatively
+            if (!stretch) {
+                texture.repeat = repeatX ? new Vector2((repeatX * ratio) * tileSize, (repeatY * ratio) * tileSize) :
+                    new Vector2(tileSize * ratio, tileSize * ratio);
+                texture.rotation = tileRotation ? -tileRotation : 0;
+                texture.center = new Vector2(0.5, 0.5);
+                texture.needsUpdate = true;
+            }
+            return Promise.resolve(texture);
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                const textureLoader = new THREE.TextureLoader();
+                textureLoader.load(MaterialUtils.assetPath + url, threeTexture => {
+                    if (!stretch) {
+                        threeTexture.wrapT = THREE.RepeatWrapping;
+                        threeTexture.wrapS = THREE.RepeatWrapping;
+                        threeTexture.repeat = repeatX ? new Vector2((repeatX * ratio) * tileSize, (repeatY * ratio) * tileSize) :
+                            new Vector2(tileSize * ratio, tileSize * ratio);
+                        threeTexture.rotation = tileRotation ? -tileRotation : 0;
+                        threeTexture.center = new Vector2(0.5, 0.5);
+                        threeTexture.needsUpdate = true;
+                    }
+                    threeTexture.anisotropy = 16;
+                    MaterialUtils.textureCache.set(url, threeTexture);
+                    return resolve(threeTexture);
+                }, undefined, // onprogress
+                reject);
+            });
+        }
+    }
+    // use canvas to create rotated textures
+    static RotatedCanvasTexture(texture, textureURL, dimensions, adjustScale, repeatX, repeatY) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const img = yield MaterialUtils.LoadImageCached(textureURL);
+            return MaterialUtils.CreateTileMap(img, texture, dimensions, adjustScale, repeatX, repeatY);
+        });
+    }
+    static CustomTileMapTexture(texture, dimensions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let img = yield MaterialUtils.LoadImageCached(texture.data);
+            if (MaterialUtils.TextureSourceModified(texture)) {
+                img = yield MaterialUtils.CreateShiftedDataUrl(img, texture);
+            }
+            const ratio = dimensions.x / dimensions.y;
+            const tileSizeMax = 300;
+            const newTileSize = (tileSizeMax / 100) + 0.01 - texture.tileSize; // Scale negatively
+            const t = new THREE.Texture();
+            const image = new Image();
+            // When img is cached it is returned as a base64 string, this needs to be converted to an Image since Texture does not accept base64 as image data
+            if (img.toString().startsWith('data')) {
+                image.src = img.toString();
+                t.image = image;
+            }
+            else {
+                t.image = img;
+            }
+            if (!texture.stretch) {
+                t.wrapT = THREE.RepeatWrapping;
+                t.wrapS = THREE.RepeatWrapping;
+                t.repeat = texture.repeatX ? new Vector2((texture.repeatX * ratio) * newTileSize, (texture.repeatY * ratio) * newTileSize) :
+                    new Vector2(newTileSize * ratio, newTileSize * ratio);
+                t.rotation = texture.tileRotation ? -texture.tileRotation : 0;
+                t.center = new Vector2(0.5, 0.5);
+                t.needsUpdate = true;
+            }
+            t.anisotropy = 16;
+            return t;
+        });
+    }
+    // use canvas to create texture from photo
+    static FromImage(texture /*, dimensions: THREE.Vector2*/) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const img = yield MaterialUtils.LoadImageCached(texture.data);
+            const canvas = yield MaterialUtils.GetCanvasFromImageTexture(img, texture, true);
+            const threeTexture = new THREE.Texture(canvas);
+            threeTexture.colorSpace = SRGBColorSpace;
+            threeTexture.needsUpdate = true;
+            return threeTexture;
+        });
+    }
+    static ReadAndResizePhotoAsDataURL(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const imageSrc = yield MaterialUtils.ReadFileAsDataURL(file);
+            return MaterialUtils.LoadImageCached(imageSrc, false);
+            // const image = new Image();
+            // return new Promise(async (resolve, reject) => {
+            //   image.onload = () => {
+            //     // const transparant = file.name.endsWith('.png');
+            //     const canvas = MaterialUtils.GetCanvasFromImageTexture(image);
+            //     const newSrc = canvas.toDataURL(`image/${file.name.endsWith('.png') ? 'png' : 'jpg'}`);
+            //     // const newSrc = MaterialUtils.ResizeImage(image, transparant);
+            //     resolve(newSrc);
+            //   };
+            //   image.onerror = error => reject(error);
+            //   image.src = await MaterialUtils.ReadFileAsDataURL(file);
+            // });
+        });
+    }
+    static LoadImageCached(src, resize = true) {
+        let imageCachedKeyString = '';
+        const isDataUri = src.indexOf('base64') > -1;
+        let srcKey = src;
+        let type = 'image/jpeg';
+        if (isDataUri) {
+            srcKey = md5(src);
+            if (src.indexOf('image/png') > -1) {
+                type = 'image/png';
+            }
+        }
+        else {
+            const ext = src.substr(src.lastIndexOf('.') + 1, src.length);
+            if (ext.indexOf('png') > -1) {
+                type = 'image/png';
+            }
+        }
+        const imageCachedKey = {
+            src: srcKey,
+            resize: resize
+        };
+        imageCachedKeyString = JSON.stringify(imageCachedKey);
+        const imageFromCache = this.imageCache.get(imageCachedKeyString);
+        if (imageFromCache) {
+            return Promise.resolve(imageFromCache);
+        }
+        const image = new Image();
+        image.crossOrigin = 'Anonymous';
+        image.src = isDataUri ? src : (src.startsWith(MaterialUtils.assetPath) ? src : MaterialUtils.assetPath + src);
+        return new Promise((resolve, reject) => {
+            image.onload = () => {
+                if (resize) {
+                    const resizedImage = new Image();
+                    resizedImage.onload = () => {
+                        this.imageCache.set(imageCachedKeyString, resizedImage);
+                        resolve(resizedImage);
+                    };
+                    resizedImage.onerror = error => reject(error);
+                    // Currently always forcing transparency to ensure alpha channel is accounted for.
+                    const canvas = MaterialUtils.GetCanvasFromImageTexture(image);
+                    const resizedImageSrc = canvas.toDataURL(type);
+                    // const resizedImageSrc = MaterialUtils.ResizeImage(image, true);
+                    resizedImage.src = resizedImageSrc;
+                }
+                else {
+                    this.imageCache.set(imageCachedKeyString, image);
+                    resolve(image);
+                }
+            };
+            image.onerror = error => reject(error);
+        });
+    }
+    static GetMaterialMaps(material, texture, dimensions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!texture) {
+                return;
+            }
+            switch (texture.type) {
+                case TextureType.CustomPattern:
+                    material.map = yield MaterialUtils.CustomTileTexture(texture);
+                    material.map.colorSpace = SRGBColorSpace;
+                    return;
+                case TextureType.Basic:
+                    material.map = yield MaterialUtils.RotatedImageTexture(texture, texture.url);
+                    material.map.colorSpace = SRGBColorSpace;
+                    return;
+                case TextureType.PBR:
+                    if (texture.materializeUrl) {
+                        yield this.loadMaterializeMaps(material, texture);
+                    }
+                    else {
+                        material.map = yield MaterialUtils.RotatedImageTexture(texture, texture.url);
+                        material.map.colorSpace = SRGBColorSpace;
+                        material.roughnessMap = texture.roughnessMap ? yield MaterialUtils.RotatedImageTexture(texture, texture.roughnessMap) : null;
+                        material.bumpMap = texture.bumpMap ? yield MaterialUtils.RotatedImageTexture(texture, texture.bumpMap) : null;
+                        material.normalMap = texture.normalMap ? yield MaterialUtils.RotatedImageTexture(texture, texture.normalMap) : null;
+                        material.metalnessMap = texture.metalnessMap ? yield MaterialUtils.RotatedImageTexture(texture, texture.metalnessMap) : null;
+                        material.aoMap = texture.aoMap ? yield MaterialUtils.RotatedImageTexture(texture, texture.aoMap) : null;
+                        material.alphaMap = texture.alphaMap ? yield MaterialUtils.RotatedImageTexture(texture, texture.alphaMap) : null;
+                    }
+                    return;
+            }
+        });
+    }
+    static loadMaterializeMaps(material, texture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            material.map = yield MaterialUtils.FromUrl(texture.materializeUrl + '_diffuseOriginal.jpg', texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation);
+            material.normalMap = yield MaterialUtils.FromUrl(texture.materializeUrl + '_normal.jpg', texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation);
+            material.roughnessMap = yield MaterialUtils.FromUrl(texture.materializeUrl + '_smoothness.jpg', texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation);
+            material.metalnessMap = yield MaterialUtils.FromUrl(texture.materializeUrl + '_metallic.jpg', texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation);
+            material.aoMap = yield MaterialUtils.FromUrl(texture.materializeUrl + '_ao.jpg', texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation);
+            // material.displacementMap = await MaterialUtils.FromUrl(texture.materializeUrl + '_height.jpg', texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY);
+            material.map.colorSpace = SRGBColorSpace;
+            material.needsUpdate = true;
+            return;
+        });
+    }
+    static GetCanvasFromImageTexture(img, texture, shift, flip) {
+        const canvas = document.createElement('canvas');
+        const useDimensions = texture && !!texture.dimensions;
+        const imgRatio = img.width / img.height;
+        let mapRatio = 1;
+        canvas.width = img.width;
+        canvas.height = img.height;
+        if (useDimensions) {
+            mapRatio = texture.dimensions.x / texture.dimensions.y;
+            canvas.width = texture.dimensions.x * MaterialUtils.canvasRatio;
+            canvas.height = texture.dimensions.y * MaterialUtils.canvasRatio;
+        }
+        let textureWidth;
+        let textureHeight;
+        if (imgRatio < mapRatio) {
+            // wider than the picture: stretch the width of picture
+            textureWidth = canvas.width;
+            textureHeight = textureWidth / imgRatio;
+        }
+        else {
+            // higher than the picture: stretch the height of picture
+            textureHeight = canvas.height;
+            textureWidth = textureHeight * imgRatio;
+        }
+        const tileCtx = canvas.getContext('2d');
+        const scaleNorm = (texture && texture.scale ? texture.scale : 100) / 100;
+        const offset = new Vector2(0, 0);
+        if (texture && texture.offset) {
+            offset.copy(texture.offset).divideScalar(scaleNorm);
+        }
+        const transX = textureWidth * scaleNorm / 2;
+        const transY = textureHeight * scaleNorm / 2;
+        if (flip) {
+            tileCtx.translate(textureWidth, 0);
+            tileCtx.scale(-1, 1);
+        }
+        if (shift) {
+            tileCtx.translate(transX + (useDimensions ? MaterialUtils.canvasRatio : 1) * offset.x, transY + (useDimensions ? MaterialUtils.canvasRatio : 1) * offset.y);
+        }
+        if (texture && !!texture.rotation) {
+            tileCtx.rotate(texture.rotation);
+        }
+        tileCtx.drawImage(img, 0, 0, img.width, img.height, (shift ? -transX : 0), (shift ? -transY : 0), textureWidth * scaleNorm, textureHeight * scaleNorm);
+        return canvas;
+    }
+    // use canvas to create texture from flipped photo
+    static FromFlippedImage(texture, dimensions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const origImg = yield MaterialUtils.LoadImageCached(texture.data);
+            const canvas = yield MaterialUtils.GetCanvasFromImageTexture(origImg, texture, false, true);
+            const threeTexture = new THREE.Texture(canvas);
+            threeTexture.needsUpdate = true;
+            return threeTexture;
+        });
+    }
+    static CreateShiftedDataUrl(img, texture) {
+        const canvas = document.createElement('canvas');
+        const shiftCtx = canvas.getContext('2d');
+        const textureWidth = canvas.width = img.width;
+        const textureHeight = canvas.height = img.height;
+        const scaleNorm = texture.scale / 100;
+        const transX = texture.offset.x / scaleNorm + textureWidth * scaleNorm / 2;
+        const transY = texture.offset.y / scaleNorm + textureHeight * scaleNorm / 2;
+        shiftCtx.translate(transX, transY);
+        if (!!texture.rotation) {
+            shiftCtx.rotate(texture.rotation);
+        }
+        shiftCtx.drawImage(img, -textureWidth * scaleNorm / 2, -textureHeight * scaleNorm / 2, textureWidth * scaleNorm, textureHeight * scaleNorm);
+        if (!!texture.rotation) {
+            shiftCtx.rotate(-texture.rotation);
+        }
+        shiftCtx.translate(-transX, -transY);
+        return canvas.toDataURL();
+    }
+    // use canvas to create custom textures
+    static CustomTileTexture(texture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const img = yield MaterialUtils.LoadImageCached(texture.data);
+            const canvas = yield MaterialUtils.GetCanvasFromImageTexture(img, texture, true, true);
+            return MaterialUtils.CreateTileFromTexture(canvas, texture);
+        });
+    }
+    static RotatedImageTexture(texture, textureURL) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const img = yield MaterialUtils.LoadImageCached(textureURL);
+            const canvas = yield MaterialUtils.GetCanvasFromImageTexture(img, texture, false, true);
+            return MaterialUtils.CreateTileFromTexture(canvas, texture);
+        });
+    }
+    static CreateTileDataUrl(img, texture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof img === 'string') {
+                img = yield this.CreateImageElementFromSource(img);
+            }
+            const canvas = document.createElement('canvas');
+            const tileUnit = img.width < img.height ? img.width : img.height;
+            canvas.width = MaterialUtils.canvasRatio * texture.tileSize * 100;
+            canvas.height = MaterialUtils.canvasRatio * texture.tileSize * 100;
+            const tileCtx = canvas.getContext('2d');
+            tileCtx.drawImage(img, 0, 0, tileUnit, tileUnit, 0, 0, canvas.width, canvas.height);
+            return canvas.toDataURL();
+        });
+    }
+    static CreateTileMap(img, texture, oDimensions, adjustScale, repeatX, repeatY) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof img === 'string') {
+                img = yield this.CreateImageElementFromSource(img);
+            }
+            const dimensions = adjustScale ? oDimensions.multiplyScalar(MaterialUtils.canvasRatio) : oDimensions.clone();
+            dimensions.x = repeatX ? dimensions.x * repeatX : dimensions.x;
+            dimensions.y = repeatY ? dimensions.y * repeatY : dimensions.y;
+            const canvas = document.createElement('canvas');
+            canvas.width = dimensions.x;
+            canvas.height = dimensions.y;
+            const rotation = texture.tileRotation;
+            const imgSize = MaterialUtils.canvasRatio * texture.tileSize * 100;
+            const ctx = canvas.getContext('2d');
+            // use translation to ensure that texture is rotated around center
+            ctx.translate(dimensions.x / 2, dimensions.y / 2);
+            ctx.rotate(rotation);
+            ctx.translate(-dimensions.x / 2, -dimensions.y / 2);
+            // calculate bounding box size of rotated texture
+            const bbHeight = Math.abs(dimensions.y * Math.cos(rotation)) + Math.abs(dimensions.x * Math.sin(rotation));
+            const bbWidth = Math.abs(dimensions.x * Math.cos(rotation)) + Math.abs(dimensions.y * Math.sin(rotation));
+            // draw images to canvas to create texture
+            for (let i = Math.floor(-bbWidth / 2 / imgSize); i <= bbWidth / 2 / imgSize; i++) {
+                for (let j = Math.floor(-bbHeight / 2 / imgSize); j <= bbHeight / 2 / imgSize; j++) {
+                    ctx.drawImage(img, i * imgSize + dimensions.x / 2, j * imgSize + dimensions.y / 2, imgSize, imgSize);
+                }
+            }
+            const threeTexture = new THREE.Texture(canvas);
+            threeTexture.needsUpdate = true;
+            return threeTexture;
+        });
+    }
+    static CreateTileFromTexture(canvas, texture) {
+        const threeTexture = new THREE.Texture(canvas);
+        threeTexture.wrapT = THREE.RepeatWrapping;
+        threeTexture.wrapS = THREE.RepeatWrapping;
+        const repeatX = texture.tileSize ? (texture.repeatX ? texture.repeatX : 1) / texture.tileSize : 1;
+        const repeatY = texture.tileSize ? (texture.repeatY ? texture.repeatY : 1) / texture.tileSize : 1;
+        threeTexture.repeat.set(repeatX, repeatY);
+        threeTexture.rotation = (texture.tileRotation || 0) + Math.PI;
+        threeTexture.colorSpace = SRGBColorSpace;
+        threeTexture.needsUpdate = true;
+        return threeTexture;
+    }
+    static ReadFileAsDataURL(file) {
+        const fileReader = new FileReader();
+        return new Promise((resolve, reject) => {
+            fileReader.onload = (e) => resolve(e.target.result);
+            fileReader.onerror = error => reject(error);
+            fileReader.readAsDataURL(file);
+        });
+    }
+    static TextureSourceModified(texture) {
+        return !!texture.rotation || texture.scale !== 100
+            || !!texture.offset.x || !!texture.offset.y;
+    }
+    static CreateImageElementFromSource(src) {
+        if (!MaterialUtils.imgElement) {
+            MaterialUtils.imgElement = new Image();
+        }
+        return new Promise((resolve) => {
+            MaterialUtils.imgElement.onload = () => {
+                resolve(MaterialUtils.imgElement);
+            };
+            MaterialUtils.imgElement.src = src;
+        });
+    }
+}
+MaterialUtils.canvasRatio = 4;
+MaterialUtils.defaultWindow = new THREE.MeshPhongMaterial({
+    color: 0x000000,
+    transparent: true,
+    opacity: 0.0
+});
+MaterialUtils.MAX_DIMENSION = 1200;
+MaterialUtils.assetPath = '';
+MaterialUtils.imgElement = undefined;
+MaterialUtils.imageCache = new Map();
+MaterialUtils.textureCache = new Map();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"material.utils.js","sourceRoot":"","sources":["../../../../../../src/client/app/core/utils/material.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import * as THREE from 'three';\r\nimport {MeshStandardMaterial, SRGBColorSpace, Vector2} from 'three';\r\nimport * as md5 from 'md5';\r\nimport {Texture} from '../model/texture';\r\nimport {TextureType} from '../model/texture-type';\r\n\r\ninterface ImageCachedKey {\r\n  src: string;\r\n  resize: boolean;\r\n}\r\n\r\nexport class MaterialUtils {\r\n\r\n  public static readonly canvasRatio = 4;\r\n  public static readonly defaultWindow = new THREE.MeshPhongMaterial({\r\n    color: 0x000000,\r\n    transparent: true,\r\n    opacity: 0.0\r\n  });\r\n  public static MAX_DIMENSION = 1200;\r\n  private static assetPath: string = '';\r\n\r\n  private static imgElement: HTMLImageElement = undefined;\r\n\r\n  public static imageCache = new Map<string, HTMLImageElement>();\r\n  public static textureCache = new Map<string, THREE.Texture>();\r\n\r\n  public static SetAssetPath(path: string): void {\r\n    MaterialUtils.assetPath = path;\r\n  }\r\n\r\n  public static ClearCaches(): void {\r\n    MaterialUtils.imageCache.clear();\r\n    const textures = Array.from(MaterialUtils.textureCache.values());\r\n    textures.forEach((t) => t.dispose());\r\n    MaterialUtils.textureCache.clear();\r\n  }\r\n\r\n  public static FromUrl(\r\n    url: string, stretch: boolean, tileSize: number, repeatX?: number, repeatY?: number, dimensions?: THREE.Vector2, tileRotation?: number): Promise<THREE.Texture> {\r\n    const ratio: number = dimensions ? (dimensions.x / dimensions.y) : 1; // Required to keep scale equal on surfaces of any dimension\r\n    const tileSizeMax: number = 300;\r\n\r\n    if (this.textureCache.has(url)) {\r\n      const texture = this.textureCache.get(url).clone();\r\n      tileSize = (tileSizeMax / 100) + 0.01 - tileSize; // Scale negatively\r\n      if (!stretch) {\r\n        texture.repeat = repeatX ? new Vector2((repeatX * ratio) * tileSize, (repeatY * ratio) * tileSize) :\r\n          new Vector2(tileSize * ratio, tileSize * ratio);\r\n        texture.rotation = tileRotation ? -tileRotation : 0;\r\n        texture.center = new Vector2(0.5, 0.5);\r\n        texture.needsUpdate = true;\r\n      }\r\n      return Promise.resolve(texture);\r\n    } else {\r\n      return new Promise((resolve, reject) => {\r\n        const textureLoader = new THREE.TextureLoader();\r\n        textureLoader.load(\r\n          MaterialUtils.assetPath + url,\r\n          threeTexture => {\r\n            if (!stretch) {\r\n              threeTexture.wrapT = THREE.RepeatWrapping;\r\n              threeTexture.wrapS = THREE.RepeatWrapping;\r\n              threeTexture.repeat = repeatX ? new Vector2((repeatX * ratio) * tileSize, (repeatY * ratio) * tileSize) :\r\n                new Vector2(tileSize * ratio, tileSize * ratio);\r\n              threeTexture.rotation = tileRotation ? -tileRotation : 0;\r\n              threeTexture.center = new Vector2(0.5, 0.5);\r\n              threeTexture.needsUpdate = true;\r\n            }\r\n            threeTexture.anisotropy = 16;\r\n            MaterialUtils.textureCache.set(url, threeTexture);\r\n            return resolve(threeTexture);\r\n          },\r\n          undefined, // onprogress\r\n          reject\r\n        );\r\n      });\r\n    }\r\n  }\r\n\r\n// use canvas to create rotated textures\r\n  public static async RotatedCanvasTexture(texture: Texture, textureURL: string, dimensions: THREE.Vector2, adjustScale: boolean, repeatX?: number, repeatY?: number): Promise<THREE.Texture> {\r\n    const img = await MaterialUtils.LoadImageCached(textureURL);\r\n    return MaterialUtils.CreateTileMap(img, texture, dimensions, adjustScale, repeatX, repeatY);\r\n  }\r\n\r\n  public static async CustomTileMapTexture(texture: Texture, dimensions: THREE.Vector2): Promise<THREE.Texture> {\r\n    let img = await MaterialUtils.LoadImageCached(texture.data);\r\n    if (MaterialUtils.TextureSourceModified(texture)) {\r\n      img = await MaterialUtils.CreateShiftedDataUrl(img, texture);\r\n    }\r\n    const ratio: number = dimensions.x / dimensions.y;\r\n    const tileSizeMax: number = 300;\r\n    const newTileSize: number = (tileSizeMax / 100) + 0.01 - texture.tileSize; // Scale negatively\r\n    const t: THREE.Texture = new THREE.Texture();\r\n    const image = new Image();\r\n\r\n    // When img is cached it is returned as a base64 string, this needs to be converted to an Image since Texture does not accept base64 as image data\r\n    if (img.toString().startsWith('data')) {\r\n      image.src = img.toString();\r\n      t.image = image;\r\n    } else {\r\n      t.image = img;\r\n    }\r\n\r\n    if (!texture.stretch) {\r\n      t.wrapT = THREE.RepeatWrapping;\r\n      t.wrapS = THREE.RepeatWrapping;\r\n      t.repeat = texture.repeatX ? new Vector2((texture.repeatX * ratio) * newTileSize, (texture.repeatY * ratio) * newTileSize) :\r\n        new Vector2(newTileSize * ratio, newTileSize * ratio);\r\n      t.rotation = texture.tileRotation ? -texture.tileRotation : 0;\r\n      t.center = new Vector2(0.5, 0.5);\r\n      t.needsUpdate = true;\r\n    }\r\n    t.anisotropy = 16;\r\n    return t;\r\n  }\r\n\r\n// use canvas to create texture from photo\r\n  public static async FromImage(texture: Texture/*, dimensions: THREE.Vector2*/): Promise<THREE.Texture> {\r\n    const img = await MaterialUtils.LoadImageCached(texture.data);\r\n    const canvas = await MaterialUtils.GetCanvasFromImageTexture(img, texture, true);\r\n    const threeTexture = new THREE.Texture(canvas);\r\n    threeTexture.colorSpace = SRGBColorSpace;\r\n    threeTexture.needsUpdate = true;\r\n    return threeTexture;\r\n  }\r\n\r\n  public static async ReadAndResizePhotoAsDataURL(file: File): Promise<HTMLImageElement> {\r\n    const imageSrc: string = await MaterialUtils.ReadFileAsDataURL(file);\r\n    return MaterialUtils.LoadImageCached(imageSrc, false);\r\n    // const image = new Image();\r\n    // return new Promise(async (resolve, reject) => {\r\n    //   image.onload = () => {\r\n    //     // const transparant = file.name.endsWith('.png');\r\n    //     const canvas = MaterialUtils.GetCanvasFromImageTexture(image);\r\n    //     const newSrc = canvas.toDataURL(`image/${file.name.endsWith('.png') ? 'png' : 'jpg'}`);\r\n    //     // const newSrc = MaterialUtils.ResizeImage(image, transparant);\r\n    //     resolve(newSrc);\r\n    //   };\r\n    //   image.onerror = error => reject(error);\r\n    //   image.src = await MaterialUtils.ReadFileAsDataURL(file);\r\n    // });\r\n  }\r\n\r\n  public static LoadImageCached(src: string, resize: boolean = true): Promise<HTMLImageElement> {\r\n    let imageCachedKeyString = '';\r\n    const isDataUri = src.indexOf('base64') > -1;\r\n    let srcKey: string = src;\r\n    let type: string = 'image/jpeg';\r\n\r\n    if (isDataUri) {\r\n      srcKey = md5(src);\r\n      if (src.indexOf('image/png') > -1) {\r\n        type = 'image/png';\r\n      }\r\n    } else {\r\n      const ext: string = src.substr(src.lastIndexOf('.') + 1, src.length);\r\n      if (ext.indexOf('png') > -1) {\r\n        type = 'image/png';\r\n      }\r\n    }\r\n    const imageCachedKey: ImageCachedKey = {\r\n      src: srcKey,\r\n      resize: resize\r\n    };\r\n    imageCachedKeyString = JSON.stringify(imageCachedKey);\r\n    const imageFromCache = this.imageCache.get(imageCachedKeyString);\r\n    if (imageFromCache) {\r\n      return Promise.resolve(imageFromCache);\r\n    }\r\n\r\n    const image = new Image();\r\n    image.crossOrigin = 'Anonymous';\r\n    image.src = isDataUri ? src : (src.startsWith(MaterialUtils.assetPath) ? src : MaterialUtils.assetPath + src);\r\n    return new Promise((resolve, reject) => {\r\n      image.onload = () => {\r\n        if (resize) {\r\n          const resizedImage = new Image();\r\n          resizedImage.onload = () => {\r\n            this.imageCache.set(imageCachedKeyString, resizedImage);\r\n            resolve(resizedImage);\r\n          };\r\n          resizedImage.onerror = error => reject(error);\r\n\r\n          // Currently always forcing transparency to ensure alpha channel is accounted for.\r\n          const canvas = MaterialUtils.GetCanvasFromImageTexture(image);\r\n          const resizedImageSrc = canvas.toDataURL(type);\r\n          // const resizedImageSrc = MaterialUtils.ResizeImage(image, true);\r\n          resizedImage.src = resizedImageSrc;\r\n        } else {\r\n          this.imageCache.set(imageCachedKeyString, image);\r\n          resolve(image);\r\n        }\r\n      };\r\n      image.onerror = error => reject(error);\r\n    });\r\n  }\r\n\r\n  public static async GetMaterialMaps(material: MeshStandardMaterial, texture: Texture, dimensions?: Vector2): Promise<void> {\r\n    if (!texture) {\r\n      return;\r\n    }\r\n    switch (texture.type) {\r\n      case TextureType.CustomPattern:\r\n        material.map = await MaterialUtils.CustomTileTexture(texture);\r\n        material.map.colorSpace = SRGBColorSpace;\r\n        return;\r\n      case TextureType.Basic:\r\n        material.map = await MaterialUtils.RotatedImageTexture(texture, texture.url);\r\n        material.map.colorSpace = SRGBColorSpace;\r\n        return;\r\n      case TextureType.PBR:\r\n        if (texture.materializeUrl) {\r\n          await this.loadMaterializeMaps(material, texture);\r\n        } else {\r\n          material.map = await MaterialUtils.RotatedImageTexture(texture, texture.url);\r\n          material.map.colorSpace = SRGBColorSpace;\r\n          material.roughnessMap = texture.roughnessMap ? await MaterialUtils.RotatedImageTexture(texture, texture.roughnessMap) : null;\r\n          material.bumpMap = texture.bumpMap ? await MaterialUtils.RotatedImageTexture(texture, texture.bumpMap) : null;\r\n          material.normalMap = texture.normalMap ? await MaterialUtils.RotatedImageTexture(texture, texture.normalMap) : null;\r\n          material.metalnessMap = texture.metalnessMap ? await MaterialUtils.RotatedImageTexture(texture, texture.metalnessMap) : null;\r\n          material.aoMap = texture.aoMap ? await MaterialUtils.RotatedImageTexture(texture, texture.aoMap) : null;\r\n          material.alphaMap = texture.alphaMap ? await MaterialUtils.RotatedImageTexture(texture, texture.alphaMap) : null;\r\n        }\r\n        return;\r\n    }\r\n  }\r\n\r\n  public static async loadMaterializeMaps(material: MeshStandardMaterial, texture: Texture) {\r\n    material.map = await MaterialUtils.FromUrl(texture.materializeUrl + '_diffuseOriginal.jpg', texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation);\r\n    material.normalMap = await MaterialUtils.FromUrl(texture.materializeUrl + '_normal.jpg', texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation);\r\n    material.roughnessMap = await MaterialUtils.FromUrl(texture.materializeUrl + '_smoothness.jpg', texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation);\r\n    material.metalnessMap = await MaterialUtils.FromUrl(texture.materializeUrl + '_metallic.jpg', texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation);\r\n    material.aoMap = await MaterialUtils.FromUrl(texture.materializeUrl + '_ao.jpg', texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY, texture.dimensions, texture.tileRotation);\r\n    // material.displacementMap = await MaterialUtils.FromUrl(texture.materializeUrl + '_height.jpg', texture.stretch, texture.tileSize, texture.repeatX, texture.repeatY);\r\n    material.map.colorSpace = SRGBColorSpace;\r\n    material.needsUpdate = true;\r\n    return;\r\n  }\r\n\r\n  public static GetCanvasFromImageTexture(img: HTMLImageElement, texture?: Texture, shift?: boolean, flip?: boolean): HTMLCanvasElement {\r\n    const canvas = document.createElement('canvas');\r\n    const useDimensions: boolean = texture && !!texture.dimensions;\r\n    const imgRatio = img.width / img.height;\r\n    let mapRatio = 1;\r\n    canvas.width = img.width;\r\n    canvas.height = img.height;\r\n    if (useDimensions) {\r\n      mapRatio = texture.dimensions.x / texture.dimensions.y;\r\n      canvas.width = texture.dimensions.x * MaterialUtils.canvasRatio;\r\n      canvas.height = texture.dimensions.y * MaterialUtils.canvasRatio;\r\n    }\r\n    let textureWidth;\r\n    let textureHeight;\r\n    if (imgRatio < mapRatio) {\r\n      // wider than the picture: stretch the width of picture\r\n      textureWidth = canvas.width;\r\n      textureHeight = textureWidth / imgRatio;\r\n    } else {\r\n      // higher than the picture: stretch the height of picture\r\n      textureHeight = canvas.height;\r\n      textureWidth = textureHeight * imgRatio;\r\n    }\r\n    const tileCtx = canvas.getContext('2d');\r\n\r\n    const scaleNorm = (texture && texture.scale ? texture.scale : 100) / 100;\r\n\r\n    const offset: Vector2 = new Vector2(0, 0);\r\n    if (texture && texture.offset) {\r\n      offset.copy(texture.offset).divideScalar(scaleNorm);\r\n    }\r\n\r\n    const transX: number = textureWidth * scaleNorm / 2;\r\n    const transY: number = textureHeight * scaleNorm / 2;\r\n\r\n    if (flip) {\r\n      tileCtx.translate(textureWidth, 0);\r\n      tileCtx.scale(-1, 1);\r\n    }\r\n    if (shift) {\r\n      tileCtx.translate(\r\n        transX + (useDimensions ? MaterialUtils.canvasRatio : 1) * offset.x,\r\n        transY + (useDimensions ? MaterialUtils.canvasRatio : 1) * offset.y);\r\n    }\r\n    if (texture && !!texture.rotation) {\r\n      tileCtx.rotate(texture.rotation);\r\n    }\r\n    tileCtx.drawImage(\r\n      img,\r\n      0,\r\n      0,\r\n      img.width,\r\n      img.height,\r\n      (shift ? -transX : 0),\r\n      (shift ? -transY : 0),\r\n      textureWidth * scaleNorm,\r\n      textureHeight * scaleNorm\r\n    );\r\n    return canvas;\r\n  }\r\n\r\n  // use canvas to create texture from flipped photo\r\n  public static async FromFlippedImage(texture: Texture, dimensions: THREE.Vector2): Promise<THREE.Texture> {\r\n    const origImg = await MaterialUtils.LoadImageCached(texture.data);\r\n    const canvas = await MaterialUtils.GetCanvasFromImageTexture(origImg, texture, false, true);\r\n    const threeTexture = new THREE.Texture(canvas);\r\n    threeTexture.needsUpdate = true;\r\n    return threeTexture;\r\n  }\r\n\r\n  private static CreateShiftedDataUrl(img: HTMLImageElement, texture: Texture): any {\r\n    const canvas = document.createElement('canvas');\r\n    const shiftCtx = canvas.getContext('2d');\r\n    const textureWidth = canvas.width = img.width;\r\n    const textureHeight = canvas.height = img.height;\r\n    const scaleNorm = texture.scale / 100;\r\n\r\n    const transX = texture.offset.x / scaleNorm + textureWidth * scaleNorm / 2;\r\n    const transY = texture.offset.y / scaleNorm + textureHeight * scaleNorm / 2;\r\n    shiftCtx.translate(transX, transY);\r\n\r\n    if (!!texture.rotation) {\r\n      shiftCtx.rotate(texture.rotation);\r\n    }\r\n\r\n    shiftCtx.drawImage(\r\n      img,\r\n      -textureWidth * scaleNorm / 2,\r\n      -textureHeight * scaleNorm / 2,\r\n      textureWidth * scaleNorm,\r\n      textureHeight * scaleNorm\r\n    );\r\n\r\n    if (!!texture.rotation) {\r\n      shiftCtx.rotate(-texture.rotation);\r\n    }\r\n    shiftCtx.translate(-transX, -transY);\r\n\r\n    return canvas.toDataURL();\r\n  }\r\n\r\n  // use canvas to create custom textures\r\n  private static async CustomTileTexture(texture: Texture): Promise<THREE.Texture> {\r\n    const img = await MaterialUtils.LoadImageCached(texture.data);\r\n    const canvas = await MaterialUtils.GetCanvasFromImageTexture(img, texture, true, true);\r\n    return MaterialUtils.CreateTileFromTexture(canvas, texture);\r\n  }\r\n\r\n  private static async RotatedImageTexture(texture: Texture, textureURL: string): Promise<THREE.Texture> {\r\n    const img = await MaterialUtils.LoadImageCached(textureURL);\r\n    const canvas = await MaterialUtils.GetCanvasFromImageTexture(img, texture, false, true);\r\n    return MaterialUtils.CreateTileFromTexture(canvas, texture);\r\n  }\r\n\r\n  private static async CreateTileDataUrl(img: HTMLImageElement, texture: Texture): Promise<any> {\r\n    if (typeof img === 'string') {\r\n      img = await this.CreateImageElementFromSource(img);\r\n    }\r\n    const canvas = document.createElement('canvas');\r\n    const tileUnit = img.width < img.height ? img.width : img.height;\r\n    canvas.width = MaterialUtils.canvasRatio * texture.tileSize * 100;\r\n    canvas.height = MaterialUtils.canvasRatio * texture.tileSize * 100;\r\n    const tileCtx = canvas.getContext('2d');\r\n    tileCtx.drawImage(\r\n      img,\r\n      0, 0,\r\n      tileUnit, tileUnit,\r\n      0, 0,\r\n      canvas.width, canvas.height\r\n    );\r\n    return canvas.toDataURL();\r\n  }\r\n\r\n  private static async CreateTileMap(img: HTMLImageElement, texture: Texture, oDimensions: THREE.Vector2, adjustScale: boolean, repeatX?: number, repeatY?: number): Promise<THREE.Texture> {\r\n    if (typeof img === 'string') {\r\n      img = await this.CreateImageElementFromSource(img);\r\n    }\r\n    const dimensions = adjustScale ? oDimensions.multiplyScalar(MaterialUtils.canvasRatio) : oDimensions.clone();\r\n    dimensions.x = repeatX ? dimensions.x * repeatX : dimensions.x;\r\n    dimensions.y = repeatY ? dimensions.y * repeatY : dimensions.y;\r\n    const canvas = document.createElement('canvas');\r\n    canvas.width = dimensions.x;\r\n    canvas.height = dimensions.y;\r\n    const rotation = texture.tileRotation;\r\n    const imgSize = MaterialUtils.canvasRatio * texture.tileSize * 100;\r\n    const ctx = canvas.getContext('2d');\r\n    // use translation to ensure that texture is rotated around center\r\n    ctx.translate(dimensions.x / 2, dimensions.y / 2);\r\n    ctx.rotate(rotation);\r\n    ctx.translate(-dimensions.x / 2, -dimensions.y / 2);\r\n    // calculate bounding box size of rotated texture\r\n    const bbHeight = Math.abs(dimensions.y * Math.cos(rotation)) + Math.abs(dimensions.x * Math.sin(rotation));\r\n    const bbWidth = Math.abs(dimensions.x * Math.cos(rotation)) + Math.abs(dimensions.y * Math.sin(rotation));\r\n    // draw images to canvas to create texture\r\n    for (let i = Math.floor(-bbWidth / 2 / imgSize); i <= bbWidth / 2 / imgSize; i++) {\r\n      for (let j = Math.floor(-bbHeight / 2 / imgSize); j <= bbHeight / 2 / imgSize; j++) {\r\n        ctx.drawImage(img, i * imgSize + dimensions.x / 2, j * imgSize + dimensions.y / 2, imgSize, imgSize);\r\n      }\r\n    }\r\n    const threeTexture = new THREE.Texture(canvas);\r\n    threeTexture.needsUpdate = true;\r\n    return threeTexture;\r\n  }\r\n\r\n  private static CreateTileFromTexture(canvas: HTMLCanvasElement, texture: Texture): THREE.Texture {\r\n    const threeTexture = new THREE.Texture(canvas);\r\n    threeTexture.wrapT = THREE.RepeatWrapping;\r\n    threeTexture.wrapS = THREE.RepeatWrapping;\r\n    const repeatX: number = texture.tileSize ? (texture.repeatX ? texture.repeatX : 1) / texture.tileSize : 1;\r\n    const repeatY: number = texture.tileSize ? (texture.repeatY ? texture.repeatY : 1) / texture.tileSize : 1;\r\n    threeTexture.repeat.set(repeatX, repeatY);\r\n    threeTexture.rotation = (texture.tileRotation || 0) + Math.PI;\r\n    threeTexture.colorSpace = SRGBColorSpace;\r\n    threeTexture.needsUpdate = true;\r\n    return threeTexture;\r\n  }\r\n\r\n  private static ReadFileAsDataURL(file: File): Promise<string> {\r\n    const fileReader = new FileReader();\r\n    return new Promise((resolve, reject) => {\r\n      fileReader.onload = (e: any) => resolve(e.target.result);\r\n      fileReader.onerror = error => reject(error);\r\n      fileReader.readAsDataURL(file);\r\n    });\r\n  }\r\n\r\n  private static TextureSourceModified(texture: Texture): boolean {\r\n    return !!texture.rotation || texture.scale !== 100\r\n      || !!texture.offset.x || !!texture.offset.y;\r\n  }\r\n\r\n  private static CreateImageElementFromSource(src: string): Promise<HTMLImageElement> {\r\n    if (!MaterialUtils.imgElement) {\r\n      MaterialUtils.imgElement = new Image();\r\n    }\r\n    return new Promise((resolve: Function) => {\r\n      MaterialUtils.imgElement.onload = () => {\r\n        resolve(MaterialUtils.imgElement);\r\n      };\r\n      MaterialUtils.imgElement.src = src;\r\n    });\r\n  }\r\n}\r\n"]}